learnxinyminutes-docs/php-pt.html.markdown at e9112f32fe250515ce9469791c5f65795a8aed2d

<?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 (conhecido como "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 para referência e participação da comunidade.
Se você estiver interessado em melhores práticas atualizadas, visite PHP The Right Way.
Se você está vindo de uma linguagem com bom gerenciamento de pacotes, confira Composer.
Para os padrões comuns, visite o Grupo de Interoperabilidade de Framework PHP PSR standards.
17 KiB Raw Blame History

Mais informações

17 KiB

Raw Blame History
