Finished the Pascal text for Brazilian Portuguese.

Added some extra details about loops and if/else blocks

(modified pascal-pt.html.markdown)
This commit is contained in:
Raul Gomes Pimentel de Almeida 2019-02-11 19:32:24 -02:00
parent 722dc2d63f
commit d5529d632f

View File

@ -6,8 +6,8 @@ contributors:
---
>Pascal is an imperative and procedural programming language, which Niklaus Wirth designed in 196869 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.
```