From 39ec31efebd0772a86d1c62ca22a9c8bb500fa05 Mon Sep 17 00:00:00 2001 From: Abdala Cerqueira Date: Tue, 29 Oct 2013 11:07:56 -0300 Subject: Adding pt-br version to php --- pt-br/php-pt.html.markdown | 700 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 700 insertions(+) create mode 100644 pt-br/php-pt.html.markdown 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 + +Olá mundo novamente! + 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 = << 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 +?> +

+ 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) +?> + + +Isto é exibido se o teste for verdadeiro. + +Isto é apresentado caso contrário. + + + 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) + */ + +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 + +