--- 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: php-pt.html.markdown --- 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. print 'Olá '; // Não tem a necessidade de utilizar as chaves. // () são opcionais para print e echo echo "Mundo\n"; // Imprime "Mundo" com quebra de linha. echo ("Mundo\n"); // Podemos tambem utilizar com chaves no echo. // (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."; echo $escapado; //Imprime: Este contém um caractere tab. $naoescapado = 'Este contém somente a barra e o t: \t'; echo $naoescapado; //Imprime: 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'; //Imprime: '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; //Imprime: Isto sairá alguma coisa /******************************** * 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]; // Imprime => "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!'; // Imprime: Olá Mundo! print 'Olá Mundo!'; // O print também é - Imprime: Olá Mundo! $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; // Imprime => 2 echo $z; // Imprime => 2 $y = 0; echo $x; // Imprime => 2 echo $z; // Imprime => 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; // Imprime => 2 $string = '1'; echo $string + $string; // Imprime => 2 (strings são coagidas para inteiros) $string = 'one'; echo $string + $string; // Imprime => 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).