summaryrefslogtreecommitdiffhomepage
path: root/pt-br
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br')
-rw-r--r--pt-br/c-pt.html.markdown649
-rw-r--r--pt-br/coffeescript-pt.html.markdown106
-rw-r--r--pt-br/git-pt.html.markdown402
-rw-r--r--pt-br/go-pt.html.markdown6
-rw-r--r--pt-br/haskell-pt.html.markdown2
-rw-r--r--pt-br/json-pt.html.markdown62
-rw-r--r--pt-br/markdown-pt.html.markdown251
-rw-r--r--pt-br/php-pt.html.markdown2
8 files changed, 1477 insertions, 3 deletions
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
new file mode 100644
index 00000000..451df4f3
--- /dev/null
+++ b/pt-br/c-pt.html.markdown
@@ -0,0 +1,649 @@
+---
+language: c
+filename: learnc.c
+contributors:
+ - ["Adam Bard", "http://adambard.com/"]
+ - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
+translators:
+ - ["João Farias", "https://github.com/JoaoGFarias"]
+lang: pt-br
+filename: c-pt.el
+---
+
+Ah, C. Ainda é **a** linguagem de computação de alta performance.
+
+C é a liguangem de mais baixo nível que a maioria dos programadores
+irão usar, e isso dá a ela uma grande velocidade bruta. Apenas fique
+antento que este manual de gerenciamento de memória e C vai levanter-te
+tão longe quanto você precisa.
+
+```c
+// Comentários de uma linha iniciam-se com // - apenas disponível a partir do C99
+
+/*
+Comentários de multiplas linhas se parecem com este.
+Funcionam no C89 também.
+*/
+
+// Constantes: #define <palavra-chave>
+#definie DAY_IN_YEAR 365
+
+//enumarações também são modos de definir constantes.
+enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB};
+// SEG recebe 2 automaticamente, TER recebe 3, etc.
+
+// Cabeçalhos são inclusos com #include
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// (Nomes dos arquivos entre <colchetes> são cabeçalhos para bibliotecas padrão de C.)
+// Para cabeçalhos próprios, use aspas ao invés de colchetes:
+#include "minha_biblioteca.h"
+
+// Declare assinaturas das funções no início do arquivo .h ou no topo
+// do seu arquivo .c.
+void funcao_1(char c);
+int funcao_2(void);
+
+// Deve-se declarar um 'protótipo de função' antes do main() quando as ocorrências
+// dessas funções estão após sua função main()
+int soma_dois_ints(int x1, int x2); // protótipo de função
+
+// O ponto de entrada do teu programa é uma função
+// chamada main, com tipo de retorno inteiro
+int main() {
+ // Usa-se printf para escrever na tela,
+ // para "saída formatada"
+ // %d é um inteiro, \n é uma nova linha
+ printf("%d\n", 0); // => Imprime 0
+ // Todos as declarações devem acabar com
+ // ponto e vírgula
+
+ ///////////////////////////////////////
+ // Tipos
+ ///////////////////////////////////////
+
+ // ints normalmente tem 4 bytes
+ int x_int = 0;
+
+ // shorts normalmente tem 2 bytes
+ short x_short = 0;
+
+ // chars sempre tem um byte
+ char x_char = 0;
+ char y_char = 'y'; // Literais de caracter são cercados por '
+
+ // longs tem entre 4 e 8 bytes; longs long tem garantia
+ // de ter pelo menos 64 bits
+ long x_long = 0;
+ long long x_long_long = 0;
+
+ // floats são normalmente números de ponto flutuante
+ // com 32 bits
+ float x_float = 0.0;
+
+ // doubles são normalmente números de ponto flutuante
+ // com 64 bits
+ double x_double = 0.0;
+
+ // Tipos inteiros podem ser sem sinal.
+ unsigned short ux_short;
+ unsigned int ux_int;
+ unsigned long long ux_long_long;
+
+ // caracteres dentro de aspas simples são inteiros
+ // no conjunto de caracteres da máquina.
+ '0' // => 48 na tabela ASCII.
+ 'A' // => 65 na tabela ASCII.
+
+ // sizeof(T) devolve o tamanho de uma variável do tipo T em bytes
+ // sizeof(obj) devolve o tamanho de uma expressão (variável, literal, etc.).
+ printf("%zu\n", sizeof(int)); // => 4 (na maioria das máquinas com palavras de 4 bytes)
+
+ // Se o argumento do operador `sizeof` é uma expressão, então seus argumentos
+ // não são avaliados (exceto em VLAs (veja abaixo)).
+ // O valor devolve, neste caso, é uma constante de tempo de compilação.
+ int a = 1;
+ // size_t é um inteiro sem sinal com pelo menos 2 bytes que representa
+ // o tamanho de um objeto.
+ size_t size = sizeof(a++); // a++ não é avaliada.
+ printf("sizeof(a++) = %zu where a = %d\n", size, a);
+ // imprime "sizeof(a++) = 4 onde a = 1" (quando em uma arquitetura de 32 bits)
+
+ // Arrays precisam ser inicializados com um tamanho concreto
+ char meu_char_array[20]; // Este array ocupa 1 * 20 = 20 bytes
+ int meu_int_array[20]; // Este array ocupa 4 * 20 = 80 bytes
+ // (assumindo palavras de 4 bytes)
+
+ // Você pode inicializar um array com 0 desta forma:
+ char meu_array[20] = {0};
+
+ // Indexar um array é semelhante a outras linguages
+ // Melhor dizendo, outras linguagens são semelhantes a C
+ meu_array[0]; // => 0
+
+ // Array são mutáveis; são apenas memória!
+ meu_array[1] = 2;
+ printf("%d\n", meu_array[1]); // => 2
+
+ // No C99 (e como uma features opcional em C11), arrays de tamanho variável
+ // VLA (do inglês), podem ser declarados também. O tamanho destes arrays
+ // não precisam ser uma constante de tempo de compilação:
+ printf("Entre o tamanho do array: "); // Pergunta ao usuário pelo tamanho
+ char buf[0x100];
+ fgets(buf, sizeof buf, stdin);
+
+ // strtoul transforma a string em um inteiro sem sinal
+ size_t size = strtoul(buf, NULL, 10);
+ int var_length_array[size]; // declara o VLA
+ printf("sizeof array = %zu\n", sizeof var_length_array);
+
+ //Uma possível saída para esse programa seria:
+ // > Entre o tamanho do array:: 10
+ // > sizeof array = 40
+
+ // String são apenas arrays de caracteres terminados por um
+ // byte NUL (0x00), representado em string pelo caracter especial '\0'.
+ // (Não precisamos incluir o byte NUL em literais de string; o compilador
+ // o insere ao final do array para nós.)
+ char uma_string[20] = "Isto é uma string";
+ // Observe que 'é' não está na tabela ASCII
+ // A string vai ser salva, mas a saída vai ser estranha
+ // Porém, comentários podem conter acentos
+ printf("%s\n", uma_string); // %s formata a string
+
+ printf("%d\n", uma_string[16]); // => 0
+ // i.e., byte #17 é 0 (assim como 18, 19, e 20)
+
+ // Se temos caracteres entre aspas simples, temos um caracter literal.
+ // Seu tipo é `int`, *não* `char` (por razões históricas).
+ int cha = 'a'; // ok
+ char chb = 'a'; // ok também (conversão implícita de int para char)
+
+ // Arrays multi-dimensionais:
+ int multi_array[2][5] = {
+ {1, 2, 3, 4, 5},
+ {6, 7, 8, 9, 0}
+ };
+ // Acesso a elementos:
+ int array_int = multi_array[0][2]; // => 3
+
+ ///////////////////////////////////////
+ // Operadores
+ ///////////////////////////////////////
+
+ // Atalho para multiplas declarações:
+ int i1 = 1, i2 = 2;
+ float f1 = 1.0, f2 = 2.0;
+
+ int a, b, c;
+ a = b = c = 0;
+
+ // Aritimética é óbvia
+ i1 + i2; // => 3
+ i2 - i1; // => 1
+ i2 * i1; // => 2
+ i1 / i2; // => 0 (0.5, porém, é truncado para 0)
+
+ f1 / f2; // => 0.5, mais ou menos epsilon
+ // Números e cálculos de ponto flutuante não são exatos
+
+ // Modulo também existe
+ 11 % 3; // => 2
+
+ // Operadores de comparação provavelmente são familiares,
+ // porém não há tipo booleano em C. Usa-se ints no lugar.
+ // (Ou _Bool or bool em C99.)
+ // 0 é falso e qualquer outra coisa é verdadeiro
+ // (Os operadores de comparação devolvem 0 ou 1.)
+ // Comparison operators are probably familiar, but
+ 3 == 2; // => 0 (falso)
+ 3 != 2; // => 1 (verdadeiro)
+ 3 > 2; // => 1
+ 3 < 2; // => 0
+ 2 <= 2; // => 1
+ 2 >= 2; // => 1
+
+ // C não é Python - comparações não se encadeam.
+ int a = 1;
+ // Errado:
+ int entre_0_e_2 = 0 < a < 2;
+ // Correto:
+ int entre_0_e_2 = 0 < a && a < 2;
+
+ // Lógica funciona sobre ints
+ !3; // => 0 (Não lógico)
+ !0; // => 1
+ 1 && 1; // => 1 (E lógico)
+ 0 && 1; // => 0
+ 0 || 1; // => 1 (Ou lógico)
+ 0 || 0; // => 0
+
+ //Expressão condicional ( ? : )
+ int a = 5;
+ int b = 10;
+ int z;
+ z = (a > b) ? a : b; // => 10 "se a > b retorne a, senão retorne b."
+
+ //Operadores de incremento e decremento:
+ char *s = "iLoveC";
+ int j = 0;
+ s[j++]; // => "i". Retorna o j-ésimo item de s E DEPOIS incrementa o valor de j.
+ j = 0;
+ s[++j]; // => "L". Incrementa o valor de j. E DEPOIS retorna o j-ésimo item de s.
+ // o mesmo com j-- e --j
+
+ // Operadores bit a bit!
+ ~0x0F; // => 0xF0 (negação bit a bit, "complemento de 1")
+ 0x0F & 0xF0; // => 0x00 (bit a bit E)
+ 0x0F | 0xF0; // => 0xFF (bit a bit OU)
+ 0x04 ^ 0x0F; // => 0x0B (bit a bit OU EXCLUSIVO)
+ 0x01 << 1; // => 0x02 (bit a bit shift para esquerda (por 1))
+ 0x02 >> 1; // => 0x01 (bit a bit shift para direita (por 1))
+
+ // Cuidado quando fizer shift em inteiro com sinal - o seguinte é indefinido:
+ // - Fazer shift sobre um bit de sinal de um inteiro com sinal (int a = 1 << 32)
+ // - Fazer shift a esquerda sobre um número negativo (int a = -1 << 2)
+ // - Fazer shift maior que a largura do tipo de LHS:
+ // int a = 1 << 32; // Indefinido se int é de tamanho 32 bits
+
+ ///////////////////////////////////////
+ // Estruturas de Controle
+ ///////////////////////////////////////
+
+ if (0) {
+ printf("Nunca rodará\n");
+ } else if (0) {
+ printf("Também nunca rodará\n");
+ } else {
+ printf("Eu serei impresso\n");
+ }
+
+ // Loops while existem
+ int ii = 0;
+ while (ii < 10) { //QUALQUER valor diferente de 0 é verdadeiro
+ printf("%d, ", ii++); // ii++ incrementa o valor de ii APÓS usá-lo
+ } // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+ printf("\n");
+
+ int kk = 0;
+ do {
+ printf("%d, ", kk);
+ } while (++kk < 10); // ++kk incrementa o valor de kk ANTES de usá-lo
+ // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+ printf("\n");
+
+ // Loops for também
+ int jj;
+ for (jj=0; jj < 10; jj++) {
+ printf("%d, ", jj);
+ } // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+ printf("\n");
+
+ // *****NOTAS*****:
+ // Loops e Funções PRECISAM ter um corpo. Se nenhum corpo é necessário:
+ int i;
+ for (i = 0; i <= 5; i++) {
+ ; // Use ponto e vírgula para agir como um corpo (declaração nula)
+ }
+
+ // Criando branchs com escolhas múltiplas: switch()
+ switch (alguma_expressao_integral) {
+ case 0: // labels precisam ser expressões integrais **constantes**
+ faca_algo();
+ break; // Sem break, o controle continua após a label
+ case 1:
+ faca_outra_coisa();
+ break;
+ default:
+ // Se `alguma_expressao_integral` não coincidir com nenhuma label
+ fputs("erro!\n", stderr);
+ exit(-1);
+ break;
+ }
+
+
+ ///////////////////////////////////////
+ // Cast de tipos
+ ///////////////////////////////////////
+
+ // Todo valor em C tem um tipo, mas você pode fazer um cast de um valor em outro tipo
+ // se você quiser (com algumas restrições).
+
+ int x_hex = 0x01; // Você pode colocar valores hexadecimais em variáveis
+
+ // Cast entre tipos tentará preservar seus valores numéricos
+ printf("%d\n", x_hex); // => Imprime 1
+ printf("%d\n", (short) x_hex); // => Imprime 1
+ printf("%d\n", (char) x_hex); // => Imprime 1
+
+ // Tipos irão ter overflow sem aviso
+ printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 se char tem 8 bits)
+
+ // Para determinar o valor máximo de um `char`, de um `signed char` e de
+ // um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX
+ // e UCHAR_MAX de <limits.h>
+
+ // Tipos inteiros podem sofrer cast para pontos-flutuantes e vice-versa.
+ printf("%f\n", (float)100); // %f formata um float
+ printf("%lf\n", (double)100); // %lf formata um double
+ printf("%d\n", (char)100.0);
+
+ ///////////////////////////////////////
+ // Ponteiros
+ ///////////////////////////////////////
+
+ // Um ponteiro é uma variável declarada para armazenar um endereço de memória.
+ // Seu declaração irá também dizer o tipo de dados para o qual ela aponta. Você
+ // Pode usar o endereço de memória de suas variáveis, então, brincar com eles.
+
+ int x = 0;
+ printf("%p\n", (void *)&x); // Use & para usar o endereço de uma variável
+ // (%p formata um objeto ponteiro do tipo void *)
+ // => Imprime algum endereço de memória;
+
+ // Ponteiros começam com * na sua declaração
+ int *px, nao_eh_um_ponteiro; // px é um ponteiro para um int
+ px = &x; // armazena o endereço de x em px
+ printf("%p\n", (void *)px); // => Imprime algum endereço de memória
+ printf("%zu, %zu\n", sizeof(px), sizeof(nao_eh_um_ponteiro));
+ // => Imprime "8, 4" em um sistema típico de 64 bits
+
+ // Para pegar um valor no endereço apontado por um ponteiro,
+ // coloque * na frente para de-referenciá-lo.
+ // Nota: sim, é confuso usar '*' _tanto_ para declaração de ponteiro
+ // como para de-referenciá-lo.
+ printf("%d\n", *px); // => Imprime 0, o valor de x
+
+ // Você também pode mudar o valor que o ponteiro está apontando.
+ // Teremo que cercar a de-referência entre parenteses, pois
+ // ++ tem uma precedência maior que *.
+ (*px)++; // Incrementa o valor que px está apontando por 1
+ printf("%d\n", *px); // => Imprime 1
+ printf("%d\n", x); // => Imprime 1
+
+ // Arrays são um boa maneira de alocar um bloco contínuo de memória
+ int x_array[20]; // Declara um array de tamanho 20 (não pode-se mudar o tamanho
+ int xx;
+ for (xx = 0; xx < 20; xx++) {
+ x_array[xx] = 20 - xx;
+ } //Inicializa x_array com 20, 19, 18,... 2, 1
+
+ // Declara um ponteiro do tipo int e inicialize ele para apontar para x_array
+ int* x_ptr = x_array;
+ // x_ptr agora aponta para o primeiro elemento do array (o inteiro 20).
+ // Isto funciona porque arrays são apenas ponteiros para seu primeiros elementos.
+ // Por exemplo, quando um array é passado para uma função ou é atribuído a um
+ // ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro.
+ // Exceções: quando o array é o argumento de um operador `&` (endereço-de):
+ // Exceptions: when the array is the argument of the `&` (address-of) operator:
+ int arr[10];
+ int (*ptr_to_arr)[10] = &arr; // &arr não é do tipo `int *`!
+ // É do tipo "ponteiro para array" (de `int`s).
+ // ou quando o array é uma string literal usada para inicializar um array de char:
+ char arr[] = "foobarbazquirk";
+ // ou quando é um argumento dos operadores `sizeof` ou `alignof`:
+ int arr[10];
+ int *ptr = arr; // equivalente a int *ptr = &arr[0];
+ printf("%zu, %zu\n", sizeof arr, sizeof ptr); // provavelmente imprime "40, 4" ou "40, 8"
+
+ // Ponteiros podem ser incrementados ou decrementados baseado no seu tipo
+ // (isto é chamado aritimética de ponteiros
+ printf("%d\n", *(x_ptr + 1)); // => Imprime 19
+ printf("%d\n", x_array[1]); // => Imprime 19
+
+ // Você também pode alocar dinamicamente blocos de memória com a função
+ // da biblioteca padrão malloc, a qual recebe um argumento do tipo size_t
+ // representando o número de bytes a ser alocado (geralmente da heap, apesar de
+ // isto poder não ser verdadeiro em, e.g., sistemas embarcados - o C padrão diz
+ // nada sobre isso).
+ int *my_ptr = malloc(sizeof(*my_ptr) * 20);
+ for (xx = 0; xx < 20; xx++) {
+ *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx
+ } //Inicializa a memória com 20, 19, 18, 17... 2, 1 (como ints)
+
+ // Dereferenciar memória que você não alocou cria
+ // "resultados imprevisíveis" - o programa é dito ter um "comportamento indefinido"
+ printf("%d\n", *(my_ptr + 21)); // => Imprime quem-sabe-o-que? Talvez até quebre o programa.
+
+ // Quando termina-se de usar um bloco de memória alocado, você pode liberá-lo,
+ // ou ninguém mais será capaz de usá-lo até o fim da execução
+ // (Isto cham-se "memory leak"):
+ free(my_ptr);
+
+ // Strings são arrays de char, mas elas geralmente são representadas
+ // como um ponteiro para char (com o apontador para o primeiro elemento do array).
+ // É boa prática usar `const char *' quando de-referenciando uma literal string,
+ // dado que elas não deverão ser modificadas (i.e. "foo"[0] = 'a' é ILEGAL.)
+ const char *my_str = "Esta é a minha literal string";
+ printf("%c\n", *my_str); // => 'T'
+
+ // Este não é o caso se a string for um array
+ // (potencialmente inicializado com um literal string)
+ // que reside em uma memória de escrita, como em:
+ char foo[] = "foo";
+ foo[0] = 'a'; // Isto é legal, foo agora contém "aoo"
+
+ funcao_1();
+} // fim da função main
+
+///////////////////////////////////////
+// Funções
+///////////////////////////////////////
+
+//Sintaxe de declaração de funções:
+// <tipo de retorno> <nome da função>(<argumentos>)
+
+int soma_dois_int(int x1, int x2)
+{
+ return x1 + x2; // Use return para retornar um valor
+}
+
+/*
+Funções são chamadas por valor. Quando uma função é chamada, os argumentos passados
+para a função são cópias dos argumento originais (a não ser arrays). Qualquer coisa
+que você faz nos argumentos de uma função não alteram o valor do argumento original
+onde a função foi chamada.
+
+Use ponteiros se você precisa alterar os valores dos argumentos originais
+
+Exemplo: reversão de string in-place
+*/
+
+// Uma função void não retorna valor algum
+void str_reverse(char *str_in)
+{
+ char tmp;
+ int ii = 0;
+ size_t len = strlen(str_in); // `strlen()` é parte da biblioteca padrão C
+ for (ii = 0; ii < len / 2; ii++) {
+ tmp = str_in[ii];
+ str_in[ii] = str_in[len - ii - 1]; // iiº char do final
+ str_in[len - ii - 1] = tmp;
+ }
+}
+
+/*
+char c[] = "Isto é um teste.";
+str_reverse(c);
+printf("%s\n", c); // => ".etset mu é otsI"
+*/
+
+// Se estiver referenciando variáveis externas à função, use a palavra-chave extern.
+int i = 0;
+void testFunc() {
+ extern int i; //i aqui agora está usando a variável externa
+}
+
+// Faça variáveis externas privadas para o código-fonte com static:
+static int i = 0; // Outros arquivos usando testFunc() não podem acessar a variável i
+void testFunc() {
+ extern int i;
+}
+//**Você pode declarar funções como static para torná-las privadas**
+
+
+///////////////////////////////////////
+// Tipos definidos pelo usuário e structs
+///////////////////////////////////////
+
+// Typedefs podem ser usadas para criar apelidos para tipos
+typedef int meu_tipo;
+meu_tipo var_meu_tipo = 0;
+
+// Structs são apenas coleções de dados, os membros são alocados sequencialmente,
+// na ordem que são escritos:
+struct retangulo {
+ int altura;
+ int largura;
+};
+
+// Geralmente não é verdade que
+// sizeof(struct retangulo) == sizeof(int) + sizeof(int)
+// devido ao potencial de preenchimento entre os membros da estrutura
+// (isto é por razões de alinhamento). [1]
+
+void funcao_1()
+{
+ struct retangulo meu_retan;
+
+ // Acesse os membros da estrutura com .
+ meu_retan.altura = 10;
+ meu_retan.largura = 20;
+
+ // Você pode declarar ponteiros para structs
+ struct retangulo *meu_retan_ptr = &meu_retan;
+
+ // Use de-referenciamento para setar os membros da
+ // struct apontada...
+ (*meu_retan_ptr).altura = 30;
+
+ // ... ou ainda melhor: prefira usar o atalho -> para melhorar legibilidade
+ meu_retan_ptr->largura = 10; // O mesmo que (*meu_retan_ptr).largura = 10;
+}
+
+//Você pode aplicar um typedef para uma struct por conveniência
+typedef struct retangulo retan;
+
+int area(retan r)
+{
+ return r.largura * r.altura;
+}
+
+// Se você tiver structus grande, você pode passá-las "por ponteiro"
+// para evitar cópia de toda a struct:
+int area(const retan *r)
+{
+ return r->largura * r->altura;
+}
+
+///////////////////////////////////////
+// Ponteiros para funções
+///////////////////////////////////////
+/*
+Em tempo de execução, funções são localizadas em endereços de memória
+conhecidos. Ponteiros para funções são como qualquer outro ponteiro
+(apenas guardam endereços de memória), mas podem ser usados para invocar funções
+diretamente e passá-las para por toda parte.
+Entretanto, a sintaxe de definição por ser um pouco confusa.
+
+Exemplo: use str_reverso através de um ponteiro
+*/
+void str_reverso_através_ponteiro(char *str_entrada) {
+ // Define uma variável de ponteiro para função, nomeada f.
+ void (*f)(char *); //Assinatura deve ser exatamente igual à função alvo.
+ f = &str_reverso; //Atribue o endereço da função em si (determinado em tempo de execução.
+ // f = str_reverso; Também funciona - função tornam-se ponteiros, assim como arrays
+ (*f)(str_entrada); // Chamando a função através do ponteiro
+ // f(str_entrada); // Esta é uma sintaxe alternativa, mas equivalente.
+}
+
+/*
+Desde que as assinaturas das funções sejam compatíveis, você pode atribuir qualquer
+função ao mesmo ponteiro. Ponteiros para funções são geralmente um typedef por
+simplicidade e legibilidade, como segue:
+*/
+
+typedef void (*minha_função_type)(char *);
+
+// Declarando o ponteiro:
+// ...
+// minha_função_type f;
+
+//Caracteres especiais:
+'\a' // Alerta (sino)
+'\n' // Nova linha
+'\t' // Tab (justifica texto a esquerda)
+'\v' // Tab vertical
+'\f' // Nova linha (formfeed)
+'\r' // Retorno de carroça
+'\b' // Backspace
+'\0' // Caracter nulo. Geralmente colocado ao final de string em C.
+ // oi\n\0. \0 é usado por convenção para marcar o fim da string.
+'\\' // Barra invertida
+'\?' // Interrogação
+'\'' // Aspas simples
+'\"' // Aspas duplas
+'\xhh' // Número hexadecimal. Exemplo: '\xb' = tab vertical
+'\ooo' // Número octal. Exemplo: '\013' = tab vertical
+
+// formatando impressão:
+"%d" // inteiro
+"%3d" // inteiro com pelo menos 3 dígitos (justifica texto a direita)
+"%s" // string
+"%f" // ponto-flutuante
+"%ld" // long
+"%3.2f" // ponto-flutuante com pelo menos 3 dígitos a esquerda e 2 a direita
+"%7.4s" // (também pode-se fazer com strings)
+"%c" // char
+"%p" // ponteiro
+"%x" // hexadecimal
+"%o" // octal
+"%%" // imprime %
+
+///////////////////////////////////////
+// Ordem de avaliação
+///////////////////////////////////////
+
+//-----------------------------------------------------------//
+// Operadores | Associatividade //
+//-----------------------------------------------------------//
+// () [] -> . | esquerda para direita //
+// ! ~ ++ -- + = *(type)sizeof | direita para esqureda //
+// * / % | esquerda para direita //
+// + - | esquerda para direita //
+// << >> | esquerda para direita //
+// < <= > >= | esquerda para direita //
+// == != | esquerda para direita //
+// & | esquerda para direita //
+// ^ | esquerda para direita //
+// | | esquerda para direita //
+// && | esquerda para direita //
+// || | esquerda para direita //
+// ?: | direita para esqureda //
+// = += -= *= /= %= &= ^= |= <<= >>= | direita para esqureda //
+// , | esquerda para direita //
+//-----------------------------------------------------------//
+
+```
+
+## Leitura adicional
+
+É recomendado ter uma cópia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language).
+Este é *o* livro sobre C, escrito pelos criadores da linguage. Mas cuidado - ele é antigo e contém alguns erros (bem,
+ideias que não são consideradas boas hoje) ou práticas mudadas.
+
+Outra boa referência é [Learn C the hard way](http://c.learncodethehardway.org/book/).
+
+Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http://c-faq.com).
+
+É importante usar espaços e indentação adequadamente e ser consistente com seu estilo de código em geral.
+Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e são, veja
+[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle).
+
+Além disso, Google é teu amigo.
+[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
diff --git a/pt-br/coffeescript-pt.html.markdown b/pt-br/coffeescript-pt.html.markdown
new file mode 100644
index 00000000..8b1094b1
--- /dev/null
+++ b/pt-br/coffeescript-pt.html.markdown
@@ -0,0 +1,106 @@
+---
+language: coffeescript
+contributors:
+ - ["Tenor Biel", "http://github.com/L8D"]
+ - ["Xavier Yao", "http://github.com/xavieryao"]
+translators:
+ - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br
+filename: learncoffeescript-pt.coffee
+---
+
+CoffeeScript é uma pequena linguagem que compila um-para-um para o JavaScript
+equivalente, e não há interpretação em tempo de execução. Como um dos sucessores
+de JavaScript, CoffeeScript tenta o seu melhor para exibir uma saída legível,
+bem-impressa e bom funcionamento dos códigos JavaScript em todo o tempo de
+execução JavaScript.
+
+Veja também [site do CoffeeScript](http://coffeescript.org/), que tem um tutorial
+completo sobre CoffeeScript.
+
+``` coffeescript
+#CoffeeScript é uma linguagem moderna
+#Segue as tendências de muitas linguagens modernas
+#Assim, os comentários são iguais a Ruby e Python, eles usam símbolos numéricos.
+
+###
+Os comentários em bloco são como estes, e eles traduzem diretamente para '/ *'s e
+'* /'s para o código JavaScript que resulta...
+
+Você deveria entender mais de semântica de JavaScript antes de continuar...
+###
+
+# Tarefa:
+numero = 42 #=> número var = 42;
+oposto = true #=> var oposto = true;
+
+# Condições:
+numero = -42 if oposto #=> if (oposto) {número = -42;}
+
+# Funções:
+quadrado = (x) -> x * x #=> var quadrado = function (x) {return x * x;}
+
+preencher = (recipiente, líquido = "coffee") ->
+ "Preenchendo o #{recipiente} with #{líquido}..."
+#=>var preencher;
+#
+#preencher = function(recipiente, líquido) {
+# if (líquido == null) {
+# líquido = "coffee";
+# }
+# return "Preenchendo o " + recipiente + " with " + líquido + "...";
+#};
+
+# Alcances:
+list = [1 .. 5] #=> lista var = [1, 2, 3, 4, 5];
+
+# Objetos:
+math =
+ root: Math.sqrt
+ square: square
+ cube: (x) -> x * square x
+#=> var math = {
+# "root": Math.sqrt,
+# "square": square,
+# "cube": function(x) { return x * square(x); }
+#}
+
+# Splats:
+corrida = (vencedor, corredores...) ->
+ print vencedor, corredores
+#=>corrida = function() {
+# var corredores, vencedor;
+# vencedor = arguments[0], corredores = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+# return print(vencedor, corredores);
+#};
+
+# Existências:
+alert "Eu sabia!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Eu sabia!"); }
+
+# Compressão de Matrizes:
+cubes = (math.cube num for num in list)
+#=>cubes = (function() {
+# var _i, _len, _results;
+# _results = [];
+# for (_i = 0, _len = list.length; _i < _len; _i++) {
+# num = list[_i];
+# _results.push(math.cube(num));
+# }
+# return _results;
+# })();
+
+comidas = ['brócolis', 'espinafre', 'chocolate']
+eat alimento for alimento in comidas when alimento isnt 'chocolate'
+#=>comidas = ['brócolis', 'espinafre', 'chocolate'];
+#
+#for (_k = 0, _len2 = comidas.length; _k < _len2; _k++) {
+# alimento = comidas[_k];
+# if (alimento !== 'chocolate') {
+# eat(alimento);
+# }
+
+## Recursos adicionais
+
+- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
+- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) \ No newline at end of file
diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown
new file mode 100644
index 00000000..6d2a55cd
--- /dev/null
+++ b/pt-br/git-pt.html.markdown
@@ -0,0 +1,402 @@
+---
+category: tool
+tool: git
+contributors:
+ - ["Jake Prather", "http://github.com/JakeHP"]
+translators:
+ - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br
+filename: learngit-pt.txt
+---
+
+Git é um sistema de controle de versão distribuído e de gerenciamento de código-fonte.
+
+Ele faz isso através de uma série de momentos instantâneos de seu projeto, e ele funciona
+com esses momentos para lhe fornecer a funcionalidade para a versão e
+gerenciar o seu código-fonte.
+
+## Versionando Conceitos
+
+### O que é controle de versão?
+
+O controle de versão é um sistema que registra alterações em um arquivo ou conjunto
+de arquivos, ao longo do tempo.
+
+### Versionamento Centralizado VS Versionamento Distribuído
+
+* Controle de versão centralizado concentra-se na sincronização, controle e backup de arquivos.
+* Controle de versão distribuído concentra-se na partilha de mudanças. Toda mudança tem um ID único.
+* Sistemas Distribuídos não têm estrutura definida. Você poderia facilmente ter um estilo SVN,
+sistema centralizado, com git.
+
+[Informação Adicional](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
+
+### Porque usar o Git?
+
+* Possibilidade de trabalhar offline
+* Colaborar com os outros é fácil!
+* Ramificação é fácil
+* Mesclagem é fácil
+* Git é rápido
+* Git é flexível.
+
+## Arquitetura Git
+
+### Repositório
+
+Um conjunto de arquivos, diretórios, registros históricos, cometes, e cabeças. Imagine-o
+como uma estrutura de dados de código-fonte, com o atributo que cada "elemento" do
+código-fonte dá-lhe acesso ao seu histórico de revisão, entre outras coisas.
+
+Um repositório git é composto do diretório git. e árvore de trabalho.
+
+### Diretório .git (componente do repositório)
+
+O diretório git. contém todas as configurações, registros, galhos, cabeça(HEAD) e muito mais.
+[Lista Detalhada](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Árvore de trabalho (componente do repositório)
+
+Esta é, basicamente, os diretórios e arquivos no seu repositório. Ele é muitas vezes referida
+como seu diretório de trabalho.
+
+### Índice (componente do diretório .git)
+
+O Índice é a área de teste no git. É basicamente uma camada que separa a sua árvore de trabalho
+a partir do repositório Git. Isso dá aos desenvolvedores mais poder sobre o que é enviado para o
+repositório Git.
+
+### Comete (commit)
+
+A commit git é um instantâneo de um conjunto de alterações ou manipulações a sua árvore de trabalho.
+Por exemplo, se você adicionou 5 imagens, e removeu outros dois, estas mudanças serão contidas
+em um commit (ou instantâneo). Esta confirmação pode ser empurrado para outros repositórios, ou não!
+
+### Ramo (branch)
+
+Um ramo é, essencialmente, um ponteiro que aponta para o último commit que você fez. Como
+você se comprometer, este ponteiro irá atualizar automaticamente e apontar para o último commit.
+
+### Cabeça (HEAD) e cabeça (head) (componente do diretório .git)
+
+HEAD é um ponteiro que aponta para o ramo atual. Um repositório tem apenas 1 * ativo * HEAD.
+head é um ponteiro que aponta para qualquer commit. Um repositório pode ter qualquer número de commits.
+
+### Recursos Conceituais
+
+* [Git para Cientistas da Computação](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git para Designers](http://hoth.entp.com/output/git_for_designers.html)
+
+## Comandos
+
+### init
+
+Criar um repositório Git vazio. As configurações do repositório Git, informações armazenadas,
+e mais são armazenados em um diretório (pasta) com o nome ". git".
+
+```bash
+$ git init
+```
+
+### config
+
+Para configurar as definições. Quer seja para o repositório, o próprio sistema, ou
+configurações globais.
+
+```bash
+# Impressão e definir algumas variáveis ​​de configuração básica (global)
+$ git config --global user.email
+$ git config --global user.name
+
+$ git config --global user.email "MyEmail@Zoho.com"
+$ git config --global user.name "My Name"
+```
+
+[Saiba mais sobre o git config.](http://git-scm.com/docs/git-config)
+
+### help
+
+Para lhe dar um acesso rápido a um guia extremamente detalhada de cada comando. ou
+apenas dar-lhe um rápido lembrete de algumas semânticas.
+
+```bash
+# Rapidamente verificar os comandos disponíveis
+$ git help
+
+# Confira todos os comandos disponíveis
+$ git help -a
+
+# Ajuda específica de comando - manual do usuário
+# git help <command_here>
+$ git help add
+$ git help commit
+$ git help init
+```
+
+### status
+
+Para mostrar as diferenças entre o arquivo de índice (basicamente o trabalho de
+copiar/repo) e a HEAD commit corrente.
+
+```bash
+# Irá exibir o ramo, os arquivos não monitorados, as alterações e outras diferenças
+$ git status
+
+# Para saber outras "tid bits" sobre git status
+$ git help status
+```
+
+### add
+
+Para adicionar arquivos para a atual árvore/directory/repo trabalho. Se você não
+der `git add` nos novos arquivos para o trabalhando árvore/diretório, eles não serão
+incluídos em commits!
+
+```bash
+# Adicionar um arquivo no seu diretório de trabalho atual
+$ git add HelloWorld.java
+
+# Adicionar um arquivo em um diretório aninhado
+$ git add /path/to/file/HelloWorld.c
+
+# Suporte a expressões regulares!
+$ git add ./*.java
+```
+
+### branch
+
+Gerenciar seus ramos. Você pode visualizar, editar, criar, apagar ramos usando este comando.
+
+```bash
+# Lista ramos e controles remotos existentes
+$ git branch -a
+
+# Criar um novo ramo
+$ git branch myNewBranch
+
+# Apagar um ramo
+$ git branch -d myBranch
+
+# Renomear um ramo
+# git branch -m <oldname> <newname>
+$ git branch -m myBranchName myNewBranchName
+
+# Editar a descrição de um ramo
+$ git branch myBranchName --edit-description
+```
+
+### checkout
+
+Atualiza todos os arquivos na árvore de trabalho para corresponder à versão no
+índice, ou árvore especificada.
+
+```bash
+# Finalizar um repo - padrão de ramo mestre
+$ git checkout
+# Checa um ramo especificado
+$ git checkout branchName
+# Criar um novo ramo e mudar para ela, como: "<nome> git branch; git checkout <nome>"
+$ git checkout -b newBranch
+```
+
+### clone
+
+Clones, ou cópias, de um repositório existente para um novo diretório. Ele também adiciona
+filiais remotas de rastreamento para cada ramo no repo clonado, que permite que você empurre
+a um ramo remoto.
+
+```bash
+# Clone learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+```
+
+### commit
+
+Armazena o conteúdo atual do índice em um novo "commit". Este commit contém
+as alterações feitas e uma mensagem criada pelo utilizador.
+
+```bash
+# commit com uma mensagem
+$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
+```
+
+### diff
+
+Mostra as diferenças entre um arquivo no diretório, o índice de trabalho e commits.
+
+```bash
+# Mostrar diferença entre o seu diretório de trabalho e o índice.
+$ git diff
+
+# Mostrar diferenças entre o índice e o commit mais recente.
+$ git diff --cached
+
+# Mostrar diferenças entre o seu diretório de trabalho e o commit mais recente.
+$ git diff HEAD
+```
+
+### grep
+
+Permite procurar rapidamente um repositório.
+
+Configurações opcionais:
+
+```bash
+# Obrigado ao Travis Jeffery por isto
+# Configure os números de linha a serem mostrados nos resultados de busca grep
+$ git config --global grep.lineNumber true
+
+# Fazer resultados de pesquisa mais legível, incluindo agrupamento
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Procure por "variableName" em todos os arquivos java
+$ git grep 'variableName' -- '*.java'
+
+# Procure por uma linha que contém "arrayListName" e "adicionar" ou "remover"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+```
+
+Google é seu amigo; para mais exemplos
+[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Mostrar commits para o repositório.
+
+```bash
+# Mostrar todos os commits
+$ git log
+
+# Mostrar um número X de commits
+$ git log -n 10
+
+# Mostrar somente commits mesclados
+$ git log --merges
+```
+
+### merge
+
+"Merge" em mudanças de commits externos no branch atual.
+
+```bash
+# Mesclar o ramo especificado para o atual.
+$ git merge branchName
+
+# Gera sempre uma mesclagem commit ao mesclar
+$ git merge --no-ff branchName
+```
+
+### mv
+
+Renomear ou mover um arquivo
+
+```bash
+# Renomear um arquivo
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Mover um arquivo
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Força renomear ou mover
+# "ExistingFile" já existe no diretório, será substituído
+$ git mv -f myFile existingFile
+```
+
+### pull
+
+Puxa de um repositório e se funde com outro ramo.
+
+```bash
+# Atualize seu repo local, através da fusão de novas mudanças
+# A partir da "origem" remoto e ramo "master (mestre)".
+# git pull <remote> <branch>
+# git pull => implícito por padrão => git pull origin master
+$ git pull origin master
+
+# Mesclar em mudanças de ramo remoto e rebase
+# Ramo commita em seu repo local, como: "git pull <remote> <branch>, git rebase <branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+Empurre e mesclar as alterações de uma ramificação para uma remota e ramo.
+
+```bash
+# Pressione e mesclar as alterações de um repo local para um
+# Chamado remoto "origem" e ramo de "mestre".
+# git push <remote> <branch>
+# git push => implícito por padrão => git push origin master
+$ git push origin master
+
+# Para ligar atual filial local com uma filial remota, bandeira add-u:
+$ git push -u origin master
+# Agora, a qualquer hora que você quer empurrar a partir desse mesmo ramo local, uso de atalho:
+$ git push
+```
+
+### rebase (CAUTELA)
+
+Tire todas as alterações que foram commitadas em um ramo, e reproduzi-las em outro ramo.
+* Não rebase commits que você tenha empurrado a um repo público *.
+
+```bash
+# Rebase experimentBranch para mestre
+# git rebase <basebranch> <topicbranch>
+$ git rebase master experimentBranch
+```
+
+[Leitura Adicional.](http://git-scm.com/book/en/Git-Branching-Rebasing)
+
+### reset (CAUTELA)
+
+Repor o atual HEAD de estado especificado. Isto permite-lhe desfazer fusões (merge),
+puxa (push), commits, acrescenta (add), e muito mais. É um grande comando, mas também
+perigoso se não saber o que se está fazendo.
+
+```bash
+# Repor a área de teste, para coincidir com o último commit (deixa diretório inalterado)
+$ git reset
+
+# Repor a área de teste, para coincidir com o último commit, e substituir diretório trabalhado
+$ git reset --hard
+
+# Move a ponta ramo atual para o especificado commit (deixa diretório inalterado)
+# Todas as alterações ainda existem no diretório.
+$ git reset 31f2bb1
+
+# Move a ponta ramo atual para trás, para o commit especificado
+# E faz o jogo dir trabalho (exclui mudanças não commitadas e todos os commits
+# Após o commit especificado).
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+O oposto do git add, git rm remove arquivos da atual árvore de trabalho.
+
+```bash
+# remove HelloWorld.c
+$ git rm HelloWorld.c
+
+# Remove um arquivo de um diretório aninhado
+$ git rm /pather/to/the/file/HelloWorld.c
+```
+
+# # Mais informações
+
+* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
+
+* [git-scm - Video Tutorials](http://git-scm.com/videos)
+
+* [git-scm - Documentation](http://git-scm.com/docs)
+
+* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/)
+
+* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
+
+* [GitGuys](http://www.gitguys.com/)
+
+* [Git - guia prático](http://rogerdudler.github.io/git-guide/index.pt_BR.html) \ No newline at end of file
diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown
index cca58b16..c7339831 100644
--- a/pt-br/go-pt.html.markdown
+++ b/pt-br/go-pt.html.markdown
@@ -6,6 +6,7 @@ filename: learngo-pt.go
lang: pt-br
contributors:
- ["Sonia Keys", "https://github.com/soniakeys"]
+ - ["Jose Donizetti", "https://github.com/josedonizetti"]
translators:
- ["Nuno Antunes", "https://github.com/ntns"]
---
@@ -74,7 +75,7 @@ func learnTypes() {
pode incluir quebras de linha.` // mesmo tipo string
// literal não-ASCII. A linguagem Go utiliza de raiz a codificação UTF-8.
- g := 'Σ' // tipo rune, um alias para uint32, que contém um código unicode
+ g := 'Σ' // tipo rune, um alias para int32, que contém um código unicode
f := 3.14195 // float64, número de vírgula flutuante de 64bit (IEEE-754)
c := 3 + 4i // complex128, representado internamente com dois float64s
@@ -306,3 +307,6 @@ a melhor demonstração de código fácil de ler e de perceber, do estilo Go, e
sua escrita idiomática. Ou então clique no nome de uma função na [documentação]
(http://golang.org/pkg/) e veja o código fonte aparecer!
+Outra ótima fonte para aprender Go é o [Go by example](https://gobyexample.com/).
+Apesar de ser em inglês, é possível recodificar os exemplos para aprender sobre
+a linguagem.
diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
index 55f90bd6..788dc1d2 100644
--- a/pt-br/haskell-pt.html.markdown
+++ b/pt-br/haskell-pt.html.markdown
@@ -1,5 +1,5 @@
---
-language: haskell
+language: Haskell
contributors:
- ["Adit Bhargava", "http://adit.io"]
translators:
diff --git a/pt-br/json-pt.html.markdown b/pt-br/json-pt.html.markdown
new file mode 100644
index 00000000..fc63b126
--- /dev/null
+++ b/pt-br/json-pt.html.markdown
@@ -0,0 +1,62 @@
+---
+language: json
+contributors:
+ - ["Anna Harren", "https://github.com/iirelu"]
+ - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+ - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br
+filename: learnjson-pt.json
+---
+
+Como JSON é um formato de intercâmbio de dados, este será, muito provavelmente, o
+"Learn X in Y minutes" mais simples existente.
+
+JSON na sua forma mais pura não tem comentários em reais, mas a maioria dos analisadores
+aceitarão comentários no estilo C (//, /\* \*/). Para os fins do presente, no entanto,
+tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si.
+
+
+```json
+{
+ "chave": "valor",
+
+ "chaves": "deve ser sempre entre aspas (junto ou separado)",
+ "números": 0,
+ "strings": "Olá, mundo. Todo o padrão UNICODE é permitido, junto com \"escapando\".",
+ "possui booleano?": true,
+ "nada": null,
+
+ "número grande": 1.2e+100,
+
+ "objetos": {
+ "comentário": "A maior parte da sua estrutura virá de objetos.",
+
+ "array": [0, 1, 2, 3, "Arrays podem ter qualquer coisa em si.", 5],
+
+ "outro objeto": {
+ "ccomentário": "Estas coisas podem ser aninhadas, muito úteis."
+ }
+ },
+
+ "tolice": [
+ {
+ "fonte de potássio": ["bananas"]
+ },
+ [
+ [1, 0, 0, 0],
+ [0, 1, 0, 0],
+ [0, 0, 1, "neo"],
+ [0, 0, 0, 1]
+ ]
+ ],
+
+ "estilo alternativo": {
+ "comentário": "verificar isso!"
+ , "posição da vírgula": "não importa - enquanto é antes do valor, então é válido"
+ , "outro comentário": "que bom"
+ },
+
+ "que foi curto": "E, você está feito. Você já sabe tudo que JSON tem para oferecer.".
+}
+```
diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
new file mode 100644
index 00000000..4030ce3c
--- /dev/null
+++ b/pt-br/markdown-pt.html.markdown
@@ -0,0 +1,251 @@
+---
+language: markdown
+contributors:
+ - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+ - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+lang: pt-br
+filename: learnmarkdown-pt.md
+---
+
+Markdown foi criado por John Gruber in 2004. Originado para ser fácil de ler e
+escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos também).
+
+Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e
+puxar o projeto (pull request)
+
+```markdown
+<!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é
+um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML
+em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
+de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você
+não pode usar sintaxe remarcação dentro desse conteúdo do elemento.-->
+
+<!--Markdown também varia de implementação de um analisador para uma próxima.
+Este guia vai tentar esclarecer quando as características são universais, ou quando eles são
+específico para um determinado parser -->
+
+<!-- Cabeçalhos -->
+<!-- Você pode criar elementos HTML <h1> até <h6> facilmente antecedendo o texto
+que deseja estar nesse elemento por um número de hashes (#) -->
+# Isto é um cabeçalho <h1>
+## Isto é um cabeçalho <h2>
+### Isto é um cabeçalho <h3>
+#### Isto é um cabeçalho <h4>
+##### Isto é um cabeçalho <h5>
+###### Isto é um cabeçalho <h6>
+
+<!-- Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2 -->
+Isto é um cabeçalho h1
+======================
+
+Isto é um cabeçalho h2
+----------------------
+
+<!-- Estilos de texto simples -->
+<!-- O texto pode ser facilmente denominado como remarcação itálico, negrito ou tachado usando -->
+
+*Este texto está em itálico*
+_E este também está._
+
+**Este texto está em negrito**
+__E este também está._
+
+***Este texto está em negrito e itálico.***
+**_E este também está_**
+*--Danouse! Este também__*
+
+<!-- Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown
+Github, nós também temos: -->
+
+~~Este texto é processado com tachado.~~
+
+<!-- Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por
+uma ou múltiplas linhas em branco. -->
+
+Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal?
+
+Agora, eu estou no parágrado 2.
+... Ainda continuo no parágrafo 2! :)
+
+Eu estou no parágrafo três.
+
+<!-- Se você quiser inserir uma tag HTML <br />, você pode acabar com um parágrafo
+com dois ou mais espaços e, em seguida, começar um novo parágrafo -->
+
+Termino com dois espaços (destacar-me para vê-los).
+
+Há um <br /> acima de mim!
+
+<!-- Bloco de citações são fáceis e feito com o caractere >. -->
+
+> Este é um bloco de citação. Você pode
+> Enrolar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
+> deixar suas linhas ficarem muito longas e enrolar por conta própria. Não faz diferença,
+> desde que eles começam com um `>`.
+
+> Você também pode usar mais de um nível
+>> De recuo?
+> Como pura é isso?
+
+<!-- Listas -->
+<!-- As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens -->
+
+* Item
+* Item
+* Outro item
+
+ou
+
++ Item
++ Item
++ Outro item
+
+ou
+
+- Item
+- Item
+- Um último item
+
+<!-- Listas ordenadas são feitas com um número seguido por um ponto -->
+
+1. Item um
+2. Item dois
+3. Tem três
+
+<!-- Você não tem poder para rotular os itens corretamente e a remarcação será ainda
+tornar os números em ordem, mas isso pode não ser uma boa idéia -->
+
+1. Item um
+1. Item dois
+1. Item três
+<!-- (Isto é processado da mesma forma que o exemplo acima) -->
+
+<!-- Você também pode usar subtítulos -->
+
+1. Item um
+2. Item dois
+3. Item três
+ * Sub-item
+ * Sub-item
+4. Item quatro
+
+<!-- blocos de código -->
+<!-- Você pode indicar um bloco de código (que utiliza o elemento <code>) pelo recuo
+uma linha com quatro espaços ou uma guia -->
+
+ Isto é código
+ É assim, sacou?
+
+<!-- Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo
+dentro do seu código -->
+
+ my_array.each do |item|
+ puts item
+ end
+
+<!-- Código embutido pode ser criada usando o caractere de crase ` -->
+
+John não sabia nem o que o função 'goto()' fazia!
+
+<!-- Em Github Flavored Markdown, você pode usar uma sintaxe especial para o código -->
+
+\`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ```
+ruby! -->
+def foobar
+ puts "Hello world!"
+end
+\`\`\` <!-- Aqui também, não barras invertidas, apenas ``` -->
+
+<-- O texto acima não requer recuo, mas o Github vai usar a sintaxe
+destacando do idioma que você especificar após a ``` -->
+
+<!-- Regra Horizontal (<hr />) -->
+<!-- Regras horizontais são facilmente adicionados com três ou mais asteriscos ou hífens,
+com ou sem espaços. -->
+
+***
+---
+- - -
+****************
+
+<!-- Links -->
+<!-- Uma das melhores coisas sobre a remarcação é o quão fácil é fazer ligações. Colocar
+o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses () -->
+
+[Click aqui!](http://test.com/)
+
+<!-- Você também pode adicionar um título link usando aspas dentro dos parênteses -->
+
+[Click aqui!](http://test.com/ "Link para Test.com")
+
+<!-- Caminhos relativos funcionam também. -->
+
+[Ir para música](/música/).
+
+<!-- Markdown também suporta ligações de estilo de referência -->
+
+[Clique neste link] [link1] para mais informações sobre isso!
+[Além disso, verifique este link] [foobar] se você quiser.
+
+[link1]: http://test.com/ "Legal!"
+[foobar]: http://foobar.biz/ "OK!"
+
+<!-- O título também pode estar entre aspas simples ou entre parênteses, ou omitido
+inteiramente. As referências podem estar em qualquer lugar no documento e os IDs de referência
+pode ser qualquer um, desde que eles são únicos. -->
+
+<!-- Existe também o "nomear implícita", que permite que você use o texto do link como o id -->
+
+[Este] [] é um link.
+
+[este]: http://thisisalink.com/
+
+<!-- Mas não são usados normalmente-->
+
+<!-- Imagens -->
+<!-- As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente! -->
+
+![Este é pairar-texto (texto alternativo) para minha imagem](http://imgur.com/myimage.jpg "Um título opcional")
+
+<!-- E estilo de referência funciona como esperado -->
+
+![Este é o pairar-texto.][Myimage]
+
+[myimage]: relative/urls/legal/image.jpg "se você precisa de um título, é aqui"
+
+<!-- Miscelânea -->
+<!-- Auto-links -->
+
+<http://testwebsite.com/> é equivalente a
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Auto-links para e-mails -->
+
+<foo@bar.com>
+
+<!-- Escapando caracteres -->
+
+Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja
+em itálico, então eu faço o seguinte: \*Este texto entre asteriscos \*.
+
+<!-- Tabelas -->
+<!-- Tabelas estão disponíveis apenas no Github Flavored Markdown e são ligeiramente
+complicadas, mas se você realmente quer: -->
+
+| Col1 | Col2 | Col3 |
+| :----------- | :------: | ------------: |
+| esquerda-alin| Centrado | direita-alinh |
+| blah | blah | blah |
+
+<!-- Ou, para os mesmos resultados -->
+
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Ugh isso é tão feio | faça isto | parar
+
+<!-- O fim! -->
+
+```
+Para mais informações, confira o post oficial de John Gruber de sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax)
+e de Adam Pritchard grande cheatsheet [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
index 344df43a..0e710742 100644
--- a/pt-br/php-pt.html.markdown
+++ b/pt-br/php-pt.html.markdown
@@ -1,5 +1,5 @@
---
-language: php
+language: PHP
contributors:
- ["Malcolm Fell", "http://emarref.net/"]
- ["Trismegiste", "https://github.com/Trismegiste"]