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."; 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 = << 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 ?>

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) ?> 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