diff options
| -rw-r--r-- | pt-br/php-pt.html.markdown | 700 |
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). |