Parte 1 · Fundamentos · Referência PHP

01

Tipos de dados

PHP tem tipagem dinâmica: o tipo é definido pelo valor atribuído. Os principais escalares são int, float, string e bool; além de array e null. Use var_dump() para inspecionar valor + tipo, e gettype() para só o nome do tipo.

tipos.php

<?php
$inteiro = 42;          // int
$decimal = 3.14;        // float
$texto   = "PHP";       // string
$ligado  = true;        // bool
$lista   = [1, 2, 3]; // array
$nada    = null;        // null (ausência de valor)

var_dump($inteiro); // int(42)
var_dump($decimal); // float(3.14)
var_dump($ligado);  // bool(true)
echo gettype($texto);   // string

02

Verificação de tipo

As funções is_* retornam bool e são úteis para validar entrada. Repare que is_int("42") é false: "42" é uma string, mesmo parecendo número.

verifica.php

<?php
var_dump(is_int(42));        // bool(true)
var_dump(is_string("oi"));   // bool(true)
var_dump(is_bool(true));     // bool(true)
var_dump(is_array([1, 2]));  // bool(true)
var_dump(is_null(null));     // bool(true)
var_dump(is_int("42"));      // bool(false) — string, não int

03

Arrays associativos

Em vez de índices numéricos, o array associativo usa chave => valor. Acesse pelo nome da chave e percorra com foreach capturando chave e valor.

arrays.php

<?php
$pessoa = [
    "nome"  => "Ana",
    "idade" => 28,
];

echo $pessoa["nome"];   // Ana

// foreach capturando chave e valor
foreach ($pessoa as $chave => $valor) {
    echo "$chave: $valor\n";
}
// Saída:
// nome: Ana
// idade: 28

04

Variáveis e referência

Por padrão a atribuição copia o valor. Com & você cria uma referência: dois nomes apontando para o mesmo espaço. Já a variável-variável ($$) usa o valor de uma variável como o nome de outra.

referencia.php

<?php
$a = 10;
$b = &$a;   // $b é referência a $a (mesmo espaço de memória)
$b = 20;
echo $a;       // 20 — mexer em $b alterou $a

// Variável-variável: o VALOR de $campo vira o NOME da nova variável.
$campo = "email";
$$campo = "ana@site.com";   // cria a variável $email
echo $email;                // ana@site.com

⚠️ Cuidado: referências e variável-variável deixam o código difícil de seguir. Use com parcimônia — na prática, raramente são necessárias.

05

Escopo

Cada função tem escopo isolado: variáveis de fora não entram automaticamente. Use global para importar uma variável global, e static para manter o valor entre chamadas da mesma função.

escopo.php

<?php
$total = 100;            // global (escopo do arquivo)

function semGlobal() {
    // Aqui $total NÃO existe — o escopo da função é isolado.
    echo isset($total) ? "existe" : "não existe";
}

function comGlobal() {
    global $total;       // importa a global para dentro
    echo $total;
}

function contador() {
    static $n = 0;       // mantém o valor entre chamadas
    $n++;
    echo $n;
}

semGlobal();  // não existe
comGlobal();  // 100
contador();   // 1
contador();   // 2

06

Operadores aritméticos

Os de sempre, mais dois que costumam pegar quem vem de outras linguagens: módulo (%, o resto da divisão) e exponenciação (**). E lembre: em PHP a concatenação de strings é com ponto (.), não com +.

aritmetica.php

<?php
echo 7 + 3;    // 10
echo 7 - 3;    // 4
echo 7 * 3;    // 21
echo 7 / 2;    // 3.5  (divisão pode resultar em float)
echo 7 % 3;    // 1    (módulo: resto da divisão)
echo 2 ** 10;  // 1024 (2 elevado a 10)

Concatenação com . e .=, e os atalhos de incremento/decremento:

concat-incremento.php

<?php
$nome = "PHP";
echo "Olá " . $nome;   // Olá PHP   (. junta strings)

$msg = "abc";
$msg .= "def";         // .= acrescenta no fim
echo $msg;             // abcdef

$n = 5;
echo $n++;   // 5  (pós-fixo: usa o valor, depois incrementa)
echo $n;     // 6
echo ++$n;   // 7  (pré-fixo: incrementa, depois usa)
echo --$n;   // 6

07

Comparação e igualdade

O == compara só o valor (com coerção de tipo); o === compara valor e tipo. Na prática, prefira sempre === para evitar surpresas. O <=> (spaceship) retorna -1, 0 ou 1 — útil em ordenação.

comparacao.php

<?php
var_dump(5 == "5");     // bool(true)  — compara só valor (com coerção)
var_dump(5 === "5");    // bool(false) — compara valor E tipo
var_dump(5 != "5");     // bool(false)
var_dump(5 !== "5");    // bool(true)
var_dump(0 == "texto");  // bool(false) — PHP 8! (em PHP 7 era true)
var_dump(10 <=> 20);   // int(-1) — spaceship: -1, 0 ou 1

⚠️ Mudança no PHP 8: ao comparar número com string, se a string não for numérica, o número é convertido para string antes de comparar. Por isso 0 == "texto" agora é false (no PHP 7 era true). Mais um motivo para usar ===.

Operador	Significado	Exemplo	Resultado
`==`	Igual (só valor)	`5 == "5"`	`true`
`===`	Idêntico (valor + tipo)	`5 === "5"`	`false`
`!=`	Diferente (só valor)	`5 != "5"`	`false`
`!==`	Não idêntico	`5 !== "5"`	`true`
`<=>`	Spaceship (ordenação)	`10 <=> 20`	`-1`

08

Condicionais

O if/elseif/else testa condições em ordem; a primeira verdadeira executa. O switch compara um valor contra vários case — não esqueça o break, ou a execução "cai" para o próximo case.

if-else.php

<?php
$nota = 7;

if ($nota >= 9) {
    echo "Excelente";
} elseif ($nota >= 6) {
    echo "Aprovado";       // <- esta roda
} else {
    echo "Reprovado";
}
// Saída: Aprovado

switch.php

<?php
$dia = 3;

switch ($dia) {
    case 1:
        echo "Domingo";
        break;
    case 3:
        echo "Terça";      // <- esta roda
        break;             // break impede "cair" no próximo case
    default:
        echo "Outro dia";
}
// Saída: Terça

09

Loops

Quatro formas de repetir. O while testa antes; o do...while roda ao menos uma vez (testa no fim); o for tem contador embutido; e o foreach percorre arrays.

loops.php

<?php
// while — testa a condição ANTES de cada volta
$i = 1;
while ($i <= 3) {
    echo $i;   // 123
    $i++;
}

// do...while — roda ao menos UMA vez (testa no fim)
$j = 10;
do {
    echo $j;   // 10 — imprime mesmo com a condição já falsa
} while ($j < 5);

// for — inicialização; condição; passo
for ($k = 0; $k < 5; $k++) {
    echo $k;   // 01234
}

// foreach — percorre um array
$cores = ["vermelho", "verde", "azul"];
foreach ($cores as $cor) {
    echo $cor . " ";   // vermelho verde azul 
}

Loop	Quando usar	Testa a condição
`while`	Repetir enquanto algo for verdadeiro	Antes (pode rodar 0 vez)
`do...while`	Garantir ao menos uma execução	No fim (roda ≥ 1 vez)
`for`	Número conhecido de repetições	Antes
`foreach`	Percorrer arrays / coleções	Por item