Merge branch 'master' of https://github.com/torgeek/learnxinyminutes-docs

1 files changed, 254 insertions, 0 deletions

diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown
new file mode 100644
index 00000000..72302695
--- /dev/null
+++ b/pt-br/pascal-pt.html.markdown
@@ -0,0 +1,254 @@
+---
+language: Pascal
+filename: learnpascal-pt.pas
+contributors:
+    - ["Ganesha Danu", "https://github.com/blinfoldking"]
+    - ["Keith Miyake", "https//github.com/kaymmm"]
+    - ["Raul Almeida", "https://github.com/almeidaraul"]
+translators:
+    - ["Raul Almeida", "https://github.com/almeidaraul"]
+lang: pt-br
+---
+
+
+>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))
+
+
+
+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 aprendendo_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
+    80
+        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.
+```
+
+```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
+    vet_char : array [0..255] of CHAR;
+        // 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
+        // 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
+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;
+           // 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];
+           // 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;
+           // defina o tamanho de vetores dinâmicos antes de usá-los
+
+// 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]
+
+    // 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 - ignora o resto) 
+    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'; //concatenaçã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) }
+
+    // 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; 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.
+```
+
+```pascal
+PROGRAM programacao_com_funcoes;
+
+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;
+{ calcula a! recursivamente }
+
+// pode-se declarar variáveis locais para funções e procedimentos
+// exemplo:
+// VAR
+//    local_a : INTEGER;
+
+BEGIN
+	{ 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)
+    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; 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
+}
+
+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
+    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
+
+    // escrever valor de inutil (sempre 3, já que salvainteiro não a altera)
+    WRITELN('inutil = ', inutil); 
+END.
+
+```
+