Variáveis, tipos e o sistema de tipos do PHP 8

1. Introdução às variáveis no PHP

No PHP, toda variável é precedida pelo cifrão ($), seguido por um nome que pode conter letras, números e underscores, mas não pode começar com número. O sistema é case-sensitive, ou seja, $nome e $Nome são variáveis distintas.

$nome = "João";
$Nome = "Maria";
echo $nome; // João
echo $Nome; // Maria

Escopo de variáveis

O PHP possui regras claras de escopo:

  • Local: variáveis dentro de funções são locais por padrão.
  • Global: para acessar uma variável global dentro de uma função, use global $var ou o array $GLOBALS.
  • Estático: variáveis estáticas mantêm seu valor entre chamadas de função.
  • Superglobais: arrays como $_GET, $_POST, $_SERVER, $_SESSION, $_COOKIE, $_REQUEST, $_FILES e $GLOBALS estão disponíveis em todos os escopos.
$contador = 0;

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

echo incrementar(); // 1
echo incrementar(); // 2

Variáveis variáveis ($$var)

Permitem usar o valor de uma variável como nome de outra variável. Use com moderação para evitar código confuso.

$nomeVariavel = "mensagem";
$$nomeVariavel = "Olá, mundo!";
echo $mensagem; // Olá, mundo!

2. Tipos primitivos escalares

int e float

O PHP suporta inteiros (int) e números de ponto flutuante (float). O limite para inteiros depende da arquitetura (32 ou 64 bits), e operações que excedem esses limites são automaticamente convertidas para float.

$inteiro = 42;
$float = 3.14159;

echo PHP_INT_MAX; // 9223372036854775807 (64 bits)
echo PHP_FLOAT_MAX; // 1.7976931348623E+308

string

Strings podem ser definidas com aspas simples, aspas duplas, heredoc ou nowdoc. Aspas duplas interpretam variáveis e caracteres especiais; aspas simples não.

$nome = "Maria";

// Heredoc (interpreta variáveis)
$texto = <<<TEXTO
Olá, $nome! Bem-vindo ao PHP 8.
TEXTO;

// Nowdoc (não interpreta variáveis)
$codigo = <<<'CODIGO'
O nome é $nome (literalmente).
CODIGO;

bool

Booleanos representam verdadeiro (true) ou falso (false). Valores considerados "falsy" incluem: 0, 0.0, "", "0", null, array() e objetos vazios.

$verdadeiro = true;
$falso = false;

var_dump((bool) "");     // false
var_dump((bool) "texto"); // true
var_dump((bool) 0);      // false
var_dump((bool) 1);      // true

3. Tipos compostos e especiais

array

Arrays podem ser indexados numericamente ou associativos (chave => valor). São estruturas flexíveis e poderosas.

// Array indexado
$frutas = ["maçã", "banana", "laranja"];
array_push($frutas, "uva");
echo count($frutas); // 4

// Array associativo
$pessoa = [
    "nome" => "João",
    "idade" => 30,
    "cidade" => "São Paulo"
];

object

Objetos são instâncias de classes. No PHP 8, a sintaxe para criação de objetos foi simplificada com named arguments.

class Usuario {
    public function __construct(
        public string $nome,
        public int $idade
    ) {}
}

$usuario = new Usuario(nome: "Ana", idade: 25);
echo $usuario->nome; // Ana

null, resource e callable

  • null: representa ausência de valor.
  • resource: variável que referencia um recurso externo (arquivo, conexão de banco).
  • callable: qualquer função ou método que pode ser chamado.
$nulo = null;
$arquivo = fopen("exemplo.txt", "r"); // resource
$callable = function($x) { return $x * 2; };

4. Sistema de tipos do PHP 8: tipagem dinâmica vs. estática

Type Juggling

O PHP converte automaticamente tipos conforme necessário. Isso é prático, mas pode causar bugs inesperados.

$soma = "10" + 5; // 15 (string convertida para int)
$concatenacao = "10" . 5; // "105" (int convertido para string)

Strict Types

Com declare(strict_types=1), você força a verificação estrita de tipos, evitando coerções automáticas em chamadas de função.

declare(strict_types=1);

function somar(int $a, int $b): int {
    return $a + $b;
}

echo somar(5, 10); // 15
// echo somar("5", 10); // Erro: TypeError

Quando usar strict mode?

Use strict mode em projetos que exigem previsibilidade e segurança de tipos, especialmente em APIs e bibliotecas. Para scripts rápidos, a tipagem dinâmica pode ser mais produtiva.

5. Declaração de tipos (Type Hints) no PHP 8

Tipos em parâmetros e retornos

O PHP 8 permite declarar tipos para parâmetros e valores de retorno, incluindo tipos nulos e unions.

function processar(?int $id, string $nome): string|int {
    if ($id === null) {
        return "ID não informado";
    }
    return $id;
}

// Tipos union
function formatarValor(int|float $valor): string {
    return number_format($valor, 2);
}

Mixed type e never

  • mixed: aceita qualquer tipo (inclui null implicitamente).
  • never: indica que a função nunca retorna (exceção ou loop infinito).
function log(mixed $dado): void {
    var_dump($dado);
}

function abortar(string $mensagem): never {
    throw new \RuntimeException($mensagem);
}

6. Novidades do PHP 8 no sistema de tipos

Named Arguments

Permitem passar argumentos pelo nome do parâmetro, melhorando a legibilidade e flexibilidade.

function criarUsuario(string $nome, int $idade, string $email): array {
    return compact('nome', 'idade', 'email');
}

$usuario = criarUsuario(
    email: "joao@exemplo.com",
    nome: "João",
    idade: 30
);

Match Expression

Substitui switch com verificação de tipos mais segura e sem coerção automática.

$valor = 2;

$resultado = match ($valor) {
    1 => "Um",
    2, 3 => "Dois ou três",
    default => "Outro valor"
};

echo $resultado; // Dois ou três

Atributos (Annotations)

Atributos permitem adicionar metadados a classes, métodos e propriedades, incluindo informações de tipo.

#[Attribute]
class Validacao {
    public function __construct(
        public string $tipo,
        public string $mensagem
    ) {}
}

class Usuario {
    #[Validacao(tipo: "email", mensagem: "Email inválido")]
    public string $email;
}

7. Boas práticas e armadilhas comuns

Verificação de tipos

Prefira is_*() funções em vez de gettype() para verificar tipos de forma segura.

$valor = "42";

// Recomendado
if (is_string($valor)) {
    echo "É string";
}

// Evite
if (gettype($valor) === "string") {
    echo "É string";
}

Comparações frouxas vs. estritas

Use === (identidade) em vez de == (igualdade) para evitar conversões inesperadas.

var_dump(0 == "0");   // true (conversão automática)
var_dump(0 === "0");  // false (tipos diferentes)
var_dump(false == 0); // true (cuidado!)
var_dump(false === 0); // false

Integração com IDEs e PHPDoc

Documente tipos com PHPDoc para melhorar a experiência em IDEs e ferramentas de análise estática.

/**
 * Calcula a média de um array de números.
 *
 * @param int[] $valores Array de inteiros
 * @return float Média calculada
 */
function media(array $valores): float {
    return array_sum($valores) / count($valores);
}

Referências

  • PHP Manual: Variáveis — Documentação oficial sobre sintaxe, escopo e variáveis variáveis no PHP.
  • PHP Manual: Tipos — Referência completa sobre todos os tipos suportados pelo PHP.
  • PHP 8.0: Novas features — Página oficial de lançamento do PHP 8.0 com detalhes sobre named arguments, match expression e atributos.
  • Strict Types no PHP — Documentação sobre declare(strict_types=1) e como usar type hints.
  • PHP The Right Way: Tipos — Guia prático com boas práticas sobre tipos e sistema de tipos no PHP moderno.