From 722dc2d63fc63d9e4514280c8d44d7f87d65b7ff Mon Sep 17 00:00:00 2001 From: Raul Gomes Pimentel de Almeida Date: Mon, 11 Feb 2019 14:31:33 -0200 Subject: Translated the Pascal text to Brazilian Portuguese (created pascal-pt.html.markdown) TO DO/Observations: -Change capitalization of native words -Change some variable names (to more portuguese-appropriate alternatives) -Introduction is still in English --- pt-br/pascal-pt.html.markdown | 208 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 pt-br/pascal-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown new file mode 100644 index 00000000..6e175216 --- /dev/null +++ b/pt-br/pascal-pt.html.markdown @@ -0,0 +1,208 @@ +--- +language: Pascal +filename: learnpascal.pas +contributors: + - ["Raul Almeida", "http://github.com/almeidaraul"] +--- + + +>Pascal is an imperative and procedural programming language, which Niklaus Wirth designed in 1968–69 and published in 1970, as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honor of the French mathematician, philosopher and physicist Blaise Pascal. +source : [wikipedia](https://en.wikipedia.org/wiki/Pascal_(programming_language)) + + + +Para compilar e executar um programa em Pascal, você pode usar o freepascal, um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/) + +```pascal +//Corpo de um programa em Pascal +//isso é um comentário +{ + isso também é um comentário, + mas com várias linhas +} + +//cabeçalho do programa +program learn_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra. + +const + { + aqui você declara valores constantes + } +type + { + aqui você declara tipos não nativos + } +var + { + aqui você declara variáveis + } + +//programa de fato +begin + { + aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos + } +end. //o "end" no final do programa requer um ponto final. +``` + +```pascal +//formas de declarar uma variável +var a:integer; +var b:integer; + +var + a : integer; + b : integer; + +var a,b : integer; +``` + +```pascal +program Learn_More; +//agora, mais sobre tipos de dados e operações + +const + PI = 3.141592654; + GNU = 'GNU''s Not Unix'; + // a convenção é usar caixa alta para constantes + // constantes têm valores fixos que só podem ser alterados antes da compilação + // constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string) + +type + ch_array : array [0..255] of char; + // isso declara um novo tipo de variável, ch_array, que tem 256 caracteres + md_array : array of array of integer; + // vetores de vetores são vetores multidimensionais + // pode-se definir vetores de tamanho 0 (daí, usa-se alocação dinâmica) + // vetores do tipo md_array são de duas dimensões + +//declarando variáveis +var + int, c, d : integer; + // três variáveis que guardam valores inteiros + // inteiros têm 16 bits (vão de -32768 a 32767) + r : real; + // uma variável que guarda um valor real + // reais vão de 3.4E-38 a 3.4E38 + bool : boolean; + // uma variável que guarda um valor booleano (verdadeiro ou falso) + ch : char; + // uma variável que guarda um caractere + // caracteres têm 8 bits + str : string; + // esse tipo de variável não é padrão, mas é incluído na maioria dos compiladores + // string é um vetor de caracteres com tamanho padrão de 255 elementos + s : string[50]; + // você pode especificar o tamanho de uma string desta maneira para otimizar o uso de memória + my_str: ch_array; + // aqui, uma variável de um tipo personalizado declarado acima + my_2d : md_array; + // vetores de alocação dinâmica de memória precisam receber um tamanho antes de serem usados + + // tipos adicionais de inteiros + b : byte; // faixa [0..255] + shi : shortint; // faixa [-128..127] + smi : smallint; // faixa [-32,768..32,767] (inteiro padrão) + w : word; // faixa [0..65,535] + li : longint; // faixa [-2,147,483,648..2,147,483,647] + lw : longword; // faixa [0..4,294,967,295] + c : cardinal; // longword + i64 : int64; // faixa [-9223372036854775808..9223372036854775807] + qw : qword; // faixa [0..18,446,744,073,709,551,615] + + // tipos adicionais de reais + rr : real; // faixa depende da plataforma (8 bits, 16 bits, etc) + rs : single; // faixa [1.5E-45..3.4E38] + rd : double; // faixa [5.0E-324 .. 1.7E308] + re : extended; // faixa [1.9E-4932..1.1E4932] + rc : comp; // faixa [-2E64+1 .. 2E63-1] + +Begin + int := 1;// usa-se := para atribuir valores a variáveis + r := 3.14; + ch := 'a'; + str := 'apple'; + bool := true; + //pascal não é case-sensitive (não diferencia maiúsculas de minúsculas) + //uma opção de organização é usar maiúsculas para termos da linguagem (BEGIN, END, INTEGER, etc) e constantes + //aritmética + int := 1 + 1; // int deixa de ser 1 e passa a ser 2 + int := int + 1; // int = 2 + 1 = 3; + int := 4 div 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora") + int := 3 div 2; //int = 1 + int := 1 div 2; //int = 0 + + bool := true or false; // bool = true + bool := false and true; // bool = false + bool := true xor true; // bool = false + + r := 3 / 2; // usa-se a "/" para divisões entre inteiros + r := int; // um real pode receber um valor inteiro (mas não o contrário) + + c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento] + str := 'hello' + 'world'; //concatenção de strings + + my_str[0] := 'a'; // só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez) + + setlength(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 + for c := 0 to 9 do // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes) + for d := 0 to 9 do // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa + my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [dimensão1, dimensão2, dimensão3...] + +End. +``` + +```pascal +program Functional_Programming; + +Var + i, dummy : integer; + +{ OBS: diferença entre procedimento e função + função: realiza operações e retorna valor + procedimento: só realiza operações +} +//declarando e descrevendo uma função +function fatorial_recursiva(const a: integer) : integer; +{ calcula a! recursivamente } + +// pode-se declarar variáveis locais para funções e procedimentos +// exemplo: +// Var +// local_a : integer; + +Begin + If a >= 1 Then + // o valor de retorno é atribuído como se a função fosse uma variável + fatorial_recursiva := a * fatorial_recursiva(a-1) + Else + fatorial_recursiva := 1; +End; // o END de funções e procedimentos recebe ponto e vírgula + +//declarando e descrevendo um procedimento +procedure salvainteiro(var i : integer; dummy : integer); +{ recebe entrada do usuário e salva na variável i + passagem de valor: + por referência - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa + por valor - "dummy: integer"; implica que o valor do argumento é copiado e alterações na variável dummy não são guardadas +} + +Begin + write('Insira um inteiro: '); //escreve sem quebrar linha + readln(i); //lê i com quebra de linha + dummy := 4; // dummy não terá seu valor alterado fora do procedimento. +End; + +Begin // programa principal + dummy := 3; + salvainteiro(i, dummy); + + // escrevendo i! + writeln(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita + + // escrevendo o valor de dummy + writeln('dummy = ', dummy); // sempre vai escrever 3, já que o valor de dummy não é alterado por salvainteiro +End. + +``` + -- cgit v1.2.3 From d5529d632ff29549db61296e9c21d195625037cc Mon Sep 17 00:00:00 2001 From: Raul Gomes Pimentel de Almeida Date: Mon, 11 Feb 2019 19:32:24 -0200 Subject: Finished the Pascal text for Brazilian Portuguese. Added some extra details about loops and if/else blocks (modified pascal-pt.html.markdown) --- pt-br/pascal-pt.html.markdown | 171 +++++++++++++++++++++++------------------- 1 file changed, 92 insertions(+), 79 deletions(-) (limited to 'pt-br') diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown index 6e175216..3c6343ca 100644 --- a/pt-br/pascal-pt.html.markdown +++ b/pt-br/pascal-pt.html.markdown @@ -6,8 +6,8 @@ contributors: --- ->Pascal is an imperative and procedural programming language, which Niklaus Wirth designed in 1968–69 and published in 1970, as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honor of the French mathematician, philosopher and physicist Blaise Pascal. -source : [wikipedia](https://en.wikipedia.org/wiki/Pascal_(programming_language)) +>Pascal é uma linguagem de programação estruturada, que recebeu este nome em homenagem ao matemático e físico Blaise Pascal. Foi criada em 1970 pelo suíço Niklaus Wirth,tendo em mente encorajar o uso de código estruturado. +fonte : [wikipédia](https://pt.wikipedia.org/wiki/Pascal_(linguagem_de_programa%C3%A7%C3%A3o)) @@ -22,102 +22,105 @@ Para compilar e executar um programa em Pascal, você pode usar o freepascal, um } //cabeçalho do programa -program learn_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra. +PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra. -const +CONST { aqui você declara valores constantes } -type +TYPE { aqui você declara tipos não nativos } -var +VAR { aqui você declara variáveis } //programa de fato -begin +BEGIN { aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos + blocos de código começam com BEGIN e terminam com END (como as chaves em C) } -end. //o "end" no final do programa requer um ponto final. +END. //o "end" no final do programa requer um ponto final. ``` ```pascal //formas de declarar uma variável -var a:integer; -var b:integer; +VAR a:INTEGER; +VAR b:INTEGER; -var - a : integer; - b : integer; +VAR + a : INTEGER; + b : INTEGER; -var a,b : integer; +VAR a,b : INTEGER; ``` ```pascal -program Learn_More; +PROGRAM Learn_More; //agora, mais sobre tipos de dados e operações -const +CONST PI = 3.141592654; GNU = 'GNU''s Not Unix'; // a convenção é usar caixa alta para constantes // constantes têm valores fixos que só podem ser alterados antes da compilação // constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string) -type - ch_array : array [0..255] of char; - // isso declara um novo tipo de variável, ch_array, que tem 256 caracteres - md_array : array of array of integer; +TYPE + vet_char : array [0..255] of CHAR; + // isso declara um novo tipo de variável, vet_char, que tem 256 caracteres + vet_multd : array of array of INTEGER; // vetores de vetores são vetores multidimensionais // pode-se definir vetores de tamanho 0 (daí, usa-se alocação dinâmica) - // vetores do tipo md_array são de duas dimensões + // vetores do tipo vet_multd são de duas dimensões //declarando variáveis -var - int, c, d : integer; +VAR + int, c, d : INTEGER; // três variáveis que guardam valores inteiros // inteiros têm 16 bits (vão de -32768 a 32767) - r : real; + r : REAL; // uma variável que guarda um valor real // reais vão de 3.4E-38 a 3.4E38 - bool : boolean; + bool : BOOLEAN; // uma variável que guarda um valor booleano (verdadeiro ou falso) - ch : char; + ch : CHAR; // uma variável que guarda um caractere // caracteres têm 8 bits - str : string; + str : STRING; // esse tipo de variável não é padrão, mas é incluído na maioria dos compiladores // string é um vetor de caracteres com tamanho padrão de 255 elementos - s : string[50]; + s : STRING[50]; // você pode especificar o tamanho de uma string desta maneira para otimizar o uso de memória - my_str: ch_array; + my_str: vet_char; // aqui, uma variável de um tipo personalizado declarado acima - my_2d : md_array; + my_2d : vet_multd; // vetores de alocação dinâmica de memória precisam receber um tamanho antes de serem usados +// outros tipos de dados (pascal é uma linguagem fortemente tipada) + // tipos adicionais de inteiros - b : byte; // faixa [0..255] - shi : shortint; // faixa [-128..127] - smi : smallint; // faixa [-32,768..32,767] (inteiro padrão) - w : word; // faixa [0..65,535] - li : longint; // faixa [-2,147,483,648..2,147,483,647] - lw : longword; // faixa [0..4,294,967,295] - c : cardinal; // longword - i64 : int64; // faixa [-9223372036854775808..9223372036854775807] - qw : qword; // faixa [0..18,446,744,073,709,551,615] + b : BYTE; // faixa [0..255] + shi : SHORTINT; // faixa [-128..127] + smi : SMALLINT; // faixa [-32,768..32,767] (inteiro padrão) + w : WORD; // faixa [0..65,535] + li : LONGINT; // faixa [-2,147,483,648..2,147,483,647] + lw : LONGWORD; // faixa [0..4,294,967,295] + c : CARDINAL; // longword + i64 : INT64; // faixa [-9223372036854775808..9223372036854775807] + qw : QWORD; // faixa [0..18,446,744,073,709,551,615] // tipos adicionais de reais - rr : real; // faixa depende da plataforma (8 bits, 16 bits, etc) - rs : single; // faixa [1.5E-45..3.4E38] - rd : double; // faixa [5.0E-324 .. 1.7E308] - re : extended; // faixa [1.9E-4932..1.1E4932] - rc : comp; // faixa [-2E64+1 .. 2E63-1] + rr : REAL; // faixa depende da plataforma (8 bits, 16 bits, etc) + rs : SINGLE; // faixa [1.5E-45..3.4E38] + rd : DOUBLE; // faixa [5.0E-324 .. 1.7E308] + re : EXTENDED; // faixa [1.9E-4932..1.1E4932] + rc : COMP; // faixa [-2E64+1 .. 2E63-1] -Begin +BEGIN int := 1;// usa-se := para atribuir valores a variáveis r := 3.14; ch := 'a'; @@ -128,13 +131,13 @@ Begin //aritmética int := 1 + 1; // int deixa de ser 1 e passa a ser 2 int := int + 1; // int = 2 + 1 = 3; - int := 4 div 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora") - int := 3 div 2; //int = 1 - int := 1 div 2; //int = 0 + int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora") + int := 3 DIV 2; //int = 1 + int := 1 DIV 2; //int = 0 - bool := true or false; // bool = true - bool := false and true; // bool = false - bool := true xor true; // bool = false + bool := true OR false; // bool = true + bool := false AND true; // bool = false + bool := true XOR true; // bool = false r := 3 / 2; // usa-se a "/" para divisões entre inteiros r := int; // um real pode receber um valor inteiro (mas não o contrário) @@ -144,65 +147,75 @@ Begin my_str[0] := 'a'; // só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez) - setlength(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 - for c := 0 to 9 do // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes) - for d := 0 to 9 do // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa + // LAÇOS + WHILE (ch != 'a') DO + BEGIN + writeln('ch é diferente de a'); + IF (ch = 'c') THEN + writeln('ch é igual a c'); + END; + + SETLENGTH(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 + FOR c := 0 to 9 DO // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes) + FOR d := 0 to 9 DO // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [dimensão1, dimensão2, dimensão3...] + -End. +END. ``` ```pascal -program Functional_Programming; +PROGRAM programacao_com_funcoes; -Var - i, dummy : integer; +VAR + i, inutil : INTEGER; { OBS: diferença entre procedimento e função função: realiza operações e retorna valor procedimento: só realiza operações } //declarando e descrevendo uma função -function fatorial_recursiva(const a: integer) : integer; +FUNCTION fatorial_recursiva(CONST a: INTEGER) : INTEGER; { calcula a! recursivamente } // pode-se declarar variáveis locais para funções e procedimentos // exemplo: -// Var -// local_a : integer; +// VAR +// local_a : INTEGER; -Begin - If a >= 1 Then +BEGIN + // obs: o ELSE só funciona se não houver ponto e vírgula no bloco do IF (exemplo: IF a THEN writeln('a'); ELSE writeln('b') é um programa que não compila) + IF a >= 1 THEN // o valor de retorno é atribuído como se a função fosse uma variável fatorial_recursiva := a * fatorial_recursiva(a-1) - Else + ELSE fatorial_recursiva := 1; -End; // o END de funções e procedimentos recebe ponto e vírgula +END; // o END de funções e procedimentos recebe ponto e vírgula //declarando e descrevendo um procedimento -procedure salvainteiro(var i : integer; dummy : integer); +PROCEDURE salvainteiro(VAR i : INTEGER; inutil : INTEGER); { recebe entrada do usuário e salva na variável i passagem de valor: por referência - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa - por valor - "dummy: integer"; implica que o valor do argumento é copiado e alterações na variável dummy não são guardadas + por valor - "inutil: integer"; implica que o valor do argumento é copiado e alterações na variável inutil não são guardadas } -Begin - write('Insira um inteiro: '); //escreve sem quebrar linha - readln(i); //lê i com quebra de linha - dummy := 4; // dummy não terá seu valor alterado fora do procedimento. -End; +BEGIN + WRITE('Insira um inteiro: '); //escreve sem quebrar linha + READLN(i); //lê i com quebra de linha + inutil := 4; // inutil não terá seu valor alterado fora do procedimento. +END; -Begin // programa principal - dummy := 3; - salvainteiro(i, dummy); +BEGIN // programa principal + inutil := 3; + salvainteiro(i, inutil); // escrevendo i! - writeln(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita + WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita - // escrevendo o valor de dummy - writeln('dummy = ', dummy); // sempre vai escrever 3, já que o valor de dummy não é alterado por salvainteiro -End. + // escrevendo o valor de inutil + WRITELN('inutil = ', inutil); // sempre vai escrever 3, já que o valor de inutil não é alterado por salvainteiro +END. ``` -- cgit v1.2.3 From a689a8c7dbef6b6148ba10ebcf910fc77a98ccae Mon Sep 17 00:00:00 2001 From: Raul Gomes Pimentel de Almeida Date: Mon, 11 Feb 2019 19:58:20 -0200 Subject: Minor changes on line breaking for Pascal in pt-br --- pt-br/pascal-pt.html.markdown | 84 +++++++++++++++++++++++++++++-------------- 1 file changed, 57 insertions(+), 27 deletions(-) (limited to 'pt-br') diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown index 3c6343ca..d6d675c3 100644 --- a/pt-br/pascal-pt.html.markdown +++ b/pt-br/pascal-pt.html.markdown @@ -2,7 +2,9 @@ language: Pascal filename: learnpascal.pas contributors: - - ["Raul Almeida", "http://github.com/almeidaraul"] + - ["Ganesha Danu", "https://github.com/blinfoldking"] + - ["Keith Miyake", "https//github.com/kaymmm"] + - ["Raul Almeida", "https://github.com/almeidaraul"] --- @@ -11,7 +13,8 @@ fonte : [wikipédia](https://pt.wikipedia.org/wiki/Pascal_(linguagem_de_programa -Para compilar e executar um programa em Pascal, você pode usar o freepascal, um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/) +Para compilar e executar um programa em Pascal, você pode usar o freepascal, +um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/) ```pascal //Corpo de um programa em Pascal @@ -22,7 +25,8 @@ Para compilar e executar um programa em Pascal, você pode usar o freepascal, um } //cabeçalho do programa -PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra. +PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do +programa deve começar com uma letra. CONST { @@ -40,8 +44,11 @@ VAR //programa de fato BEGIN { - aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos - blocos de código começam com BEGIN e terminam com END (como as chaves em C) + aqui ficam todas as instruções que não pertencem nem a funções + nem a procedimentos + + blocos de código começam com BEGIN e terminam com END + (como as chaves em C) } END. //o "end" no final do programa requer um ponto final. ``` @@ -65,16 +72,20 @@ PROGRAM Learn_More; CONST PI = 3.141592654; GNU = 'GNU''s Not Unix'; - // a convenção é usar caixa alta para constantes - // constantes têm valores fixos que só podem ser alterados antes da compilação - // constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string) + { a convenção é usar caixa alta para constantes + + constantes têm valores fixos que só podem ser alterados + antes da compilação + + constantes podem ser de qualquer tipo nativo (integer, real, boolean, + char, string) TYPE vet_char : array [0..255] of CHAR; - // isso declara um novo tipo de variável, vet_char, que tem 256 caracteres + // isso declara um novo tipo de variável, vet_char, com 256 caracteres vet_multd : array of array of INTEGER; // vetores de vetores são vetores multidimensionais - // pode-se definir vetores de tamanho 0 (daí, usa-se alocação dinâmica) + // use vetores de tamanho 0 (daí, usa-se alocação dinâmica) // vetores do tipo vet_multd são de duas dimensões //declarando variáveis @@ -91,14 +102,14 @@ VAR // uma variável que guarda um caractere // caracteres têm 8 bits str : STRING; - // esse tipo de variável não é padrão, mas é incluído na maioria dos compiladores + // STRING não é um tipo padrão, mas vem na maioria dos compiladores // string é um vetor de caracteres com tamanho padrão de 255 elementos s : STRING[50]; - // você pode especificar o tamanho de uma string desta maneira para otimizar o uso de memória + // especificar o tamanho de uma string assim otimiza o uso de memória my_str: vet_char; // aqui, uma variável de um tipo personalizado declarado acima my_2d : vet_multd; - // vetores de alocação dinâmica de memória precisam receber um tamanho antes de serem usados + // defina o tamanho de vetores dinâmicos antes de usá-los // outros tipos de dados (pascal é uma linguagem fortemente tipada) @@ -127,11 +138,12 @@ BEGIN str := 'apple'; bool := true; //pascal não é case-sensitive (não diferencia maiúsculas de minúsculas) - //uma opção de organização é usar maiúsculas para termos da linguagem (BEGIN, END, INTEGER, etc) e constantes - //aritmética + // uma opção de organização é usar maiúsculas para termos da linguagem + // (BEGIN, END, INTEGER, etc) e constantes + // aritmética int := 1 + 1; // int deixa de ser 1 e passa a ser 2 int := int + 1; // int = 2 + 1 = 3; - int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora") + int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira - ignora o resto) int := 3 DIV 2; //int = 1 int := 1 DIV 2; //int = 0 @@ -145,7 +157,8 @@ BEGIN c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento] str := 'hello' + 'world'; //concatenção de strings - my_str[0] := 'a'; // só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez) + my_str[0] := 'a'; { só se pode atribuir valores a vetores elemento + por elemento (não o vetor inteiro de uma vez) } // LAÇOS WHILE (ch != 'a') DO @@ -155,10 +168,15 @@ BEGIN writeln('ch é igual a c'); END; - SETLENGTH(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 - FOR c := 0 to 9 DO // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes) - FOR d := 0 to 9 DO // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa - my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [dimensão1, dimensão2, dimensão3...] + SETLENGTH(my_2d,10,10); + // inicialização de um vetor com alocação dinâmica; my_2d vira um 10x10 + FOR c := 0 to 9 DO + { vetores começam em 0 e terminam em tamanho-1 + (exceto se, declarando o tipo, forem especificados valores diferentes) } + FOR d := 0 to 9 DO + // a variável usada em um laço FOR deve ter sido declarada no cabeçalho + my_2d[c,d] := c * d; + // acessam-se elementos de vetores multidimensionais com [d1, d2, d3...] END. @@ -184,7 +202,14 @@ FUNCTION fatorial_recursiva(CONST a: INTEGER) : INTEGER; // local_a : INTEGER; BEGIN - // obs: o ELSE só funciona se não houver ponto e vírgula no bloco do IF (exemplo: IF a THEN writeln('a'); ELSE writeln('b') é um programa que não compila) + { O bloco ELSE só funciona se não houver ponto e vírgula no bloco do IF + exemplo: + IF a THEN + writeln('a'); + ELSE + writeln('b'); + Isso não permitiria que o programa compilasse } + IF a >= 1 THEN // o valor de retorno é atribuído como se a função fosse uma variável fatorial_recursiva := a * fatorial_recursiva(a-1) @@ -196,8 +221,12 @@ END; // o END de funções e procedimentos recebe ponto e vírgula PROCEDURE salvainteiro(VAR i : INTEGER; inutil : INTEGER); { recebe entrada do usuário e salva na variável i passagem de valor: - por referência - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa - por valor - "inutil: integer"; implica que o valor do argumento é copiado e alterações na variável inutil não são guardadas + + POR REFERÊNCIA - "VAR i: integer"; implica que alterações na variável i + dentro da função são guardadas para o escopo de todo o programa + + POR VALOR - "inutil: integer"; implica que o valor do argumento é copiado + e alterações na variável inutil não são guardadas } BEGIN @@ -211,10 +240,11 @@ BEGIN // programa principal salvainteiro(i, inutil); // escrevendo i! - WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita + WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha + // valores numéricos são automaticamente convertidos para texto na escrita - // escrevendo o valor de inutil - WRITELN('inutil = ', inutil); // sempre vai escrever 3, já que o valor de inutil não é alterado por salvainteiro + // escrever valor de inutil (sempre 3, já que salvainteiro não a altera) + WRITELN('inutil = ', inutil); END. ``` -- cgit v1.2.3 From 14357102aa1c818272b7c5077adbc4fca62e5b7b Mon Sep 17 00:00:00 2001 From: Andre Polykanine Date: Wed, 13 Feb 2019 02:14:08 +0200 Subject: Fixed frontmatter --- pt-br/pascal-pt.html.markdown | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'pt-br') diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown index d6d675c3..3a37271a 100644 --- a/pt-br/pascal-pt.html.markdown +++ b/pt-br/pascal-pt.html.markdown @@ -1,10 +1,12 @@ --- language: Pascal -filename: learnpascal.pas +filename: learnpascal-pt.pas contributors: - - ["Ganesha Danu", "https://github.com/blinfoldking"] - - ["Keith Miyake", "https//github.com/kaymmm"] + - ["Ganesha Danu", "https://github.com/blinfoldking"] + - ["Keith Miyake", "https//github.com/kaymmm"] +translators: - ["Raul Almeida", "https://github.com/almeidaraul"] +lang: pt-br --- @@ -43,7 +45,7 @@ VAR //programa de fato BEGIN - { + 80 aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos -- cgit v1.2.3