Adding pt-br version to php

1 files changed, 700 insertions, 0 deletions

diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
new file mode 100644
index 00000000..344df43a
--- /dev/null
+++ b/pt-br/php-pt.html.markdown
@@ -0,0 +1,700 @@
+---
+language: php
+contributors:
+    - ["Malcolm Fell", "http://emarref.net/"]
+    - ["Trismegiste", "https://github.com/Trismegiste"]
+translators:
+    - ["Abdala Cerqueira", "http://abda.la"]
+    - ["Raquel Diniz", "http://twitter.com/raquelrdiniz"]
+lang: pt-br
+filename: learnphp-pt.php
+---
+
+Este documento descreve PHP 5+.
+
+```php
+<?php // O código PHP deve estar incluso na tag <?php
+
+// Se o arquivo PHP só contém código PHP, a melhor prática
+// é omitir a tag de fechamento PHP.
+
+// Duas barras iniciam o comentário de uma linha.
+
+# O hash (aka pound symbol) também inicia, mas // é mais comum
+
+/*
+     O texto envolto por barra-asterisco e asterisco-barra
+     faz um comentário de múltiplas linhas
+*/
+
+// Utilize "echo" ou "print" para imprimir a saída
+print('Olá '); // Imprime "Olá " sem quebra de linha
+
+// () são opcionais para print e echo
+echo "Mundo\n"; // Imprime "Mundo" com quebra de linha
+// (Todas as declarações devem terminar com um ponto e vírgula)
+
+// Qualquer coisa fora da tag <?php é impresso automaticamente
+?>
+Olá mundo novamente!
+<?php
+
+
+/************************************
+ * Tipos e variáveis
+ */
+
+// Variáveis começam com o símbolo $.
+// Um nome de variável válido se inicia com uma letra ou sublinhado,
+// seguido por qualquer quantidade de letras, números ou sublinhados.
+
+// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive)
+$boolean = true;  // ou TRUE ou True
+$boolean = false; // ou FALSE ou False
+
+// Inteiros
+$int1 = 12;   // => 12
+$int2 = -12;  // => -12
+$int3 = 012;  // => 10 (um 0 denota um número octal)
+$int4 = 0x0F; // => 15 (um 0x denota um literal hex)
+
+// Flutuantes - Floats (aka doubles)
+$float = 1.234;
+$float = 1.2e3;
+$float = 7E-10;
+
+// Excluir variável
+unset($int1)
+
+// Aritmética
+$soma      = 1 + 1; // 2
+$diferenca = 2 - 1; // 1
+$produto   = 2 * 2; // 4
+$quociente = 2 / 1; // 2
+
+// Taquigrafia aritmética
+$numero = 0;
+$numero += 1;      // Incrementa $number em 1
+echo $numero++;    // Imprime 1 (incrementa após a avaliação)
+echo ++$numero;    // Imprime 3 (incrementa antes da avaliação)
+$numero /= $float; // Divide e atribui o quociente de $numero
+
+// Strings podem ser colocadas entre aspas simples
+$sgl_quotes = '$String'; // => '$String'
+
+// Evite o uso de aspas duplas, exceto para incorporar outras variáveis
+$dbl_quotes = "Esta é uma $sgl_quotes."; // => 'Esta é uma $String.'
+
+// Os caracteres especiais só são escapados entre aspas duplas
+$escapado    = "Este contém um \t caractere tab.";
+$naoescapado = 'Este contém somente a barra e o t: \t';
+
+// Coloque uma variável entre chaves se necessário
+$dinheiro = "Eu tenho $${numero} no banco.";
+
+// Desde o PHP 5.3, nowdocs podem ser usados para múltiplas linhas sem análise
+$nowdoc = <<<'FIM'
+múltiplas linhas
+string
+FIM;
+
+// Heredocs farão a análise
+$heredoc = <<<FIM
+múltiplas linhas
+$sgl_quotes
+FIM;
+
+// Concatenação de string é feita com .
+echo 'Esta string ' . 'é concatenada';
+
+
+/********************************
+ * Constantes
+ */
+
+// Uma constante é definida usando define()
+// e nunca pode ser mudada durante a execução!
+
+// Um nome de constante válida começa com uma letra ou sublinhado,
+// seguido por qualquer quantidade de letras, números ou sublinhados.
+define("FOO",     "alguma coisa");
+
+// Acesso a uma constante é possível usando diretamente o nome escolhido
+echo 'Isto sairá '.FOO;
+
+
+/********************************
+ * Arrays
+ */
+
+// Todos os arrays em PHP são arrays associativos (hashmaps),
+
+// Funciona com todas as versões do PHP
+$associativo = array('Um' => 1, 'Dois' => 2, 'Tres' => 3);
+
+// PHP 5.4 introduziu uma nova sintaxe
+$associativo = ['Um' => 1, 'Dois' => 2, 'Tres' => 3];
+
+echo $associativo['Um']; // imprime 1
+
+// Uma lista de literais atribui chaves inteiras implicitamente
+$array = ['Um', 'Dois', 'Tres'];
+echo $array[0]; // => "Um"
+
+// Adiciona um elemento no final do array
+$array[] = 'Quatro';
+
+// Remove um elemento do array
+unset($array[3]);
+
+/********************************
+ * Saída
+ */
+
+echo('Olá Mundo!');
+// Imprime Olá Mundo! para stdout.
+// Stdout é uma página web se executado em um navegador.
+
+print('Olá Mundo!'); // O mesmo que o echo
+
+// echo é atualmente um construtor de linguagem, então você pode 
+// remover os parênteses.
+echo 'Olá Mundo!';
+print 'Olá Mundo!'; // O print também é
+
+$paragrafo = 'parágrafo';
+
+echo 100;        // Imprime valores escalares diretamente
+echo $paragrafo; // ou variáveis
+
+// Se a abertura de tags curtas está configurada, ou sua versão do PHP é
+// 5.4.0 ou maior, você pode usar a sintaxe de echo curto
+?>
+<p><?= $paragrafo ?></p>
+<?php
+
+$x = 1;
+$y = 2;
+$x = $y; // $x agora contém o mesmo valor de $y
+$z = &$y;
+// $z agora contém uma referência para $y. Mudando o valor de
+// $z irá mudar o valor de $y também, e vice-versa.
+// $x irá permanecer inalterado com o valor original de $y
+
+echo $x; // => 2
+echo $z; // => 2
+$y = 0;
+echo $x; // => 2
+echo $z; // => 0
+
+// Despeja tipos e valores de variável para o stdout
+var_dump($z); // imprime int(0)
+
+// Imprime variáveis para stdout em formato legível para humanos
+print_r($array); // imprime: Array ( [0] => Um [1] => Dois [2] => Tres )
+
+/********************************
+ * Lógica
+ */
+$a = 0;
+$b = '0';
+$c = '1';
+$d = '1';
+
+// assert lança um aviso se o seu argumento não é verdadeiro
+
+// Estas comparações serão sempre verdadeiras, mesmo que os tipos 
+// não sejam os mesmos.
+assert($a == $b); // igualdade
+assert($c != $a); // desigualdade
+assert($c <> $a); // alternativa para desigualdade
+assert($a < $c);
+assert($c > $b);
+assert($a <= $b);
+assert($c >= $d);
+
+// A seguir, só serão verdadeiras se os valores correspondem e são do mesmo tipo.
+assert($c === $d);
+assert($a !== $d);
+assert(1 == '1');
+assert(1 !== '1');
+
+// As variáveis podem ser convertidas entre tipos, dependendo da sua utilização.
+
+$inteiro = 1;
+echo $inteiro + $inteiro; // => 2
+
+$string = '1';
+echo $string + $string; // => 2 (strings são coagidas para inteiros)
+
+$string = 'one';
+echo $string + $string; // => 0
+// Imprime 0 porque o operador + não pode fundir a string 'um' para um número
+
+// Tipo de fundição pode ser utilizado para tratar uma variável 
+// como um outro tipo
+
+$booleano = (boolean) 1; // => true
+
+$zero = 0;
+$booleano = (boolean) $zero; // => false
+
+// Há também funções dedicadas para fundir a maioria dos tipos
+$inteiro = 5;
+$string = strval($inteiro);
+
+$var = null; // valor Null
+
+
+/********************************
+ * Estruturas de controle
+ */
+
+if (true) {
+    print 'Eu fico impresso';
+}
+
+if (false) {
+    print 'Eu não\'t';
+} else {
+    print 'Eu fico impresso';
+}
+
+if (false) {
+    print 'Não fica impresso';
+} elseif(true) {
+    print 'Fica';
+}
+
+// operadores ternários
+print (false ? 'Não fica impresso' : 'Fica');
+
+$x = 0;
+if ($x === '0') {
+    print 'Não imprime';
+} elseif($x == '1') {
+    print 'Não imprime';
+} else {
+    print 'Imprime';
+}
+
+
+
+// Esta sintaxe alternativa é útil para modelos (templates)
+?>
+
+<?php if ($x): ?>
+Isto é exibido se o teste for verdadeiro.
+<?php else: ?>
+Isto é apresentado caso contrário.
+<?php endif; ?>
+
+<?php
+
+// Use switch para salvar alguma lógica.
+switch ($x) {
+    case '0':
+        print 'Switch faz coerção de tipo';
+        break; // Você deve incluir uma pausa, ou você vai cair
+               // no caso 'dois' e 'tres'
+    case 'dois':
+    case 'tres':
+        // Faz alguma coisa, se a variável é 'dois' ou 'tres'
+        break;
+    default:
+        // Faz algo por padrão
+}
+
+// While, do...while e for são repetições provavelmente familiares
+$i = 0;
+while ($i < 5) {
+    echo $i++;
+}; // Imprime "01234"
+
+echo "\n";
+
+$i = 0;
+do {
+    echo $i++;
+} while ($i < 5); // Imprime "01234"
+
+echo "\n";
+
+for ($x = 0; $x < 10; $x++) {
+    echo $x;
+} // Imprime "0123456789"
+
+echo "\n";
+
+$rodas = ['bicicleta' => 2, 'carro' => 4];
+
+// Repetições foreach podem iterar sobre arrays
+foreach ($rodas as $contador_rodas) {
+    echo $contador_rodas;
+} // Imprime "24"
+
+echo "\n";
+
+// Você pode iterar sobre as chaves, bem como os valores
+foreach ($rodas as $veiculo => $contador_rodas) {
+    echo "O $veiculo tem $contador_rodas rodas";
+}
+
+echo "\n";
+
+$i = 0;
+while ($i < 5) {
+    if ($i === 3) {
+        break; // Sai da repetição
+    }
+    echo $i++;
+} // Imprime "012"
+
+for ($i = 0; $i < 5; $i++) {
+    if ($i === 3) {
+        continue; // Ignora esta iteração da repetição
+    }
+    echo $i;
+} // Imprime "0124"
+
+
+/********************************
+ * Functions
+ */
+
+// Define a função com "function":
+function minha_funcao () {
+  return 'Olá';
+}
+
+echo minha_funcao(); // => "Olá"
+
+// Um nome de função válido começa com uma letra ou sublinhado,
+// seguido por qualquer quantidade de letras, números ou sublinhados.
+
+function adicionar($x, $y = 1) { // $y é opcional e o valor padrão é 1
+  $resultado = $x + $y;
+  return $resultado;
+}
+
+echo adicionar(4); // => 5
+echo adicionar(4, 2); // => 6
+
+// $resultado não é acessível fora da função
+// print $resultado; // Dá uma aviso.
+
+// Desde o PHP 5.3 você pode declarar funções anônimas
+$inc = function ($x) {
+  return $x + 1;
+};
+
+echo $inc(2); // => 3
+
+function foo ($x, $y, $z) {
+  echo "$x - $y - $z";
+}
+
+// Funções podem retornar funções
+function bar ($x, $y) {
+  // Utilize 'use' para trazer variáveis de fora
+  return function ($z) use ($x, $y) {
+    foo($x, $y, $z);
+  };
+}
+
+$bar = bar('A', 'B');
+$bar('C'); // Imprime "A - B - C"
+
+// Você pode chamar funções nomeadas usando strings
+$nome_funcao = 'add';
+echo $nome_funcao(1, 2); // => 3
+// Útil para dinamicamente determinar qual função será executada.
+// Ou utilize call_user_func(callable $callback [, $parameter [, ... ]]);
+
+/********************************
+ * Includes (Incluir)
+ */
+
+<?php
+// PHP dentro de arquivos incluídos também deve começar com uma tag 
+// de abertura do PHP.
+
+include 'meu-arquivo.php';
+// O código meu-arquivo.php já está disponível no escopo atual.
+// Se o arquivo não pode ser incluído (por exemplo, arquivo não encontrado), 
+//um aviso é emitido.
+
+include_once 'meu-arquivo.php';
+// Se o código no meu-arquivo.php foi incluído em outro lugar, ele não vai
+// ser incluído novamente. Isso evita vários erros de declaração de classe
+
+require 'meu-arquivo.php';
+require_once 'meu-arquivo.php';
+// Faz o mesmo que o include(), exceto que o require() irá causar um erro fatal
+// se o arquivo não puder ser incluído
+
+// Conteúdo de meu-include.php:
+<?php
+
+return 'Qualquer coisa que você quiser.';
+// Fim do arquivo
+
+// Includes e requires também podem retornar um valor.
+$valor = include 'meu-include.php';
+
+// Arquivos são incluídos com base no caminho determinado ou,
+// se este não for passado, com base na diretiva de configuração include_path.
+// Se o arquivo não é encontrado no include_path, o include vai finalmente
+// verificar no próprio diretório do script chamado e no diretório
+// de trabalho atual antes de falhar.
+/* */
+
+/********************************
+ * Classes
+ */
+
+// As classes são definidas com a palavra-chave class
+
+class MinhaClasse
+{
+    const MINHA_CONST      = 'valor'; // Uma constante
+
+    static $valorEstatico   = 'estatico';
+
+    // Variáveis estáticas e sua visibilidade
+    public static $valorEstaticoPublico = 'estaticoPublico';
+    // Acessível somente dentro da classe
+    private static $valorEstaticoPrivado = 'estaticoPrivado';
+    // Acessível a partir da classe e subclasses
+    protected static $valorEstaticoProtegido = 'estaticoProtegido';
+
+    // Propriedades devem declarar a sua visibilidade
+    public $propriedade    = 'publica';
+    public $propInstancia;
+    protected $prot = 'protegida'; // Acessível a partir da classe e subclasses
+    private $priv   = 'privada';   // Acessível somente dentro da classe
+
+    // Criar um construtor com o __construct
+    public function __construct($propInstancia) {
+        // Acesse variável de instância utilizando $this
+        $this->propInstancia = $propInstancia;
+    }
+
+    // Métodos são declarados como funções dentro de uma classe
+    public function meuMetodo()
+    {
+        print 'MinhaClasse';
+    }
+
+    //palavra-chave final faz uma função não poder ser sobrescrita
+    final function voceNaoPodeMeSobrescrever()
+    {
+    }
+
+/*
+ * Declarando propriedades ou métodos de classe como estáticos faz deles 
+ * acessíveis sem precisar instanciar a classe. A propriedade declarada
+ * como estática não pode ser acessada com um objeto
+ * instanciado da classe (embora métodos estáticos possam).
+*/
+
+    public static function meuMetodoEstatico()
+    {
+        print 'Eu sou estatico';
+    }
+}
+
+echo MinhaClasse::MINHA_CONST;    // Imprime 'valor';
+echo MinhaClasse::$valorEstatico; // Imprime 'estatico';
+MinhaClasse::meuMetodoEstatico(); // Imprime 'Eu sou estatico';
+
+// Instantiate classes using new
+$minha_classe = new MinhaClasse('Uma propriedade de instância');
+// Os parênteses são opcionais, se não passar algum argumento.
+
+// Acesse membros da classe utilizando ->
+echo $minha_classe->propriedade;  // => "publica"
+echo $minha_classe->instanceProp; // => "Uma propriedade de instância"
+$minha_classe->meuMetodo();       // => "MinhaClasse"
+
+
+// Estender classes usando "extends"
+class MinhaOutraClasse extends MinhaClasse
+{
+    function imprimePropriedadeProtegida()
+    {
+        echo $this->prot;
+    }
+
+    // Sobrescrever um método
+    function meuMetodo()
+    {
+        parent::meuMetodo();
+        print ' > MinhaOutraClasse';
+    }
+}
+
+$minha_outra_classe = new MinhaOutraClasse('Propriedade de instância');
+$minha_outra_classe->imprimePropriedadeProtegida(); // => Prints "protegida"
+$minha_outra_classe->myMethod(); // Prints "MinhaClasse > MinhaOutraClasse"
+
+final class VoceNaoPodeMeEstender
+{
+}
+
+// Você pode usar "métodos mágicos" para criar getters e setters
+class MinhaClasseMapa
+{
+    private $propriedade;
+
+    public function __get($chave)
+    {
+        return $this->$chave;
+    }
+
+    public function __set($chave, $valor)
+    {
+        $this->$chave = $valor;
+    }
+}
+
+$x = new MinhaClasseMapa();
+echo $x->propriedade; // Irá usar o método __get()
+$x->propriedade = 'Algo'; // Irá usar o método __set()
+
+// Classes podem ser abstratas (usando a palavra-chave abstract) ou
+// implementar interfaces (usando a palavra-chave implements).
+// Uma interface é declarada com a palavra-chave interface.
+
+interface InterfaceUm
+{
+    public function fazAlgo();
+}
+
+interface InterfaceDois
+{
+    public function fazOutraCoisa();
+}
+
+// interfaces podem ser estendidas
+interface InterfaceTres extends InterfaceDois
+{
+    public function fazOutroContrato();
+}
+
+abstract class MinhaClasseAbstrata implements InterfaceUm
+{
+    public $x = 'fazAlgo';
+}
+
+class MinhaClasseConcreta extends MinhaClasseAbstrata implements InterfaceDois
+{
+    public function fazAlgo()
+    {
+        echo $x;
+    }
+
+    public function fazOutraCoisa()
+    {
+        echo 'fazOutraCoisa';
+    }
+}
+
+
+// Classes podem implementar mais de uma interface
+class UmaOutraClasse implements InterfaceUm, InterfaceDois
+{
+    public function fazAlgo()
+    {
+        echo 'fazAlgo';
+    }
+
+    public function fazOutraCoisa()
+    {
+        echo 'fazOutraCoisa';
+    }
+}
+
+
+/********************************
+ * Traits (Traços)
+ */
+
+// Traits estão disponíveis a partir de PHP 5.4.0 e 
+// são declarados usando "trait"
+
+trait MeuTraco
+{
+    public function meuMetodoDeTraco()
+    {
+        print 'Eu tenho MeuTraco';
+    }
+}
+
+class MinhaClasseTracada
+{
+    use MeuTraco;
+}
+
+$cls = new MinhaClasseTracada();
+$cls->meuMetodoDeTraco(); // Imprime "Eu tenho MeuTraco"
+
+
+/********************************
+ * Namespaces (Espaço nominal)
+ */
+
+// Esta seção é separada porque a declaração de espaços nominais
+// deve ser a primeira instrução em um arquivo. Vamos fingir, aqui não é o caso
+
+<?php
+
+// Por padrão, as classes existem no espaço nominal global e podem
+// ser explicitamente chamadas com uma barra invertida.
+
+$cls = new \MinhaClasse();
+
+
+
+// Definir o espaço nominal para o arquivo
+namespace Meu\Espaconominal;
+
+class MinhaClasse
+{
+}
+
+// (de outro arquivo)
+$cls = new Meu\Espaconominal\MinhaClasse;
+
+//Ou de dentro de outro espaço nominal.
+namespace Meu\Outro\Espaconominal;
+
+use My\Espaconominal\MinhaClasse;
+
+$cls = new MinhaClasse();
+
+//Ou você pode usar como apelido de espaço nominal;
+
+namespace Meu\Outro\Espaconominal;
+
+use Meu\Espaconominal as OutroEspaconominal;
+
+$cls = new OutroEspaconominal\MinhaClasse();
+
+*/
+
+```
+
+## Mais informações
+
+Visite a [documentação oficial do PHP](http://www.php.net/manual/) 
+para referência e participação da comunidade.
+
+Se você estiver interessado em melhores práticas atualizadas, visite
+[PHP The Right Way](http://www.phptherightway.com/).
+
+Se você está vindo de uma linguagem com bom gerenciamento de pacotes, confira
+[Composer](http://getcomposer.org/).
+
+Para os padrões comuns, visite o Grupo de Interoperabilidade de Framework PHP
+[PSR standards](https://github.com/php-fig/fig-standards).