PHP 8.4: o que há de novo e o que ainda falta na linguagem

1. Visão geral do PHP 8.4: o que muda no ecossistema

O PHP 8.4, previsto para lançamento em novembro de 2024, representa mais um passo na evolução da linguagem sob o modelo de releases semestrais adotado desde o PHP 8.0. Diferentemente de versões LTS, cada release traz melhorias incrementais, com foco em desempenho, tipagem e ergonomia. Das RFCs aprovadas, destacam-se property hooks, lazy objects e novas funções de coleção. RFCs rejeitadas, como generics em tempo de execução, indicam que a comunidade ainda debate os rumos da linguagem.

2. Novas funcionalidades de tipagem e segurança

Property Hooks: getters e setters nativos

A maior novidade do PHP 8.4 são os property hooks, que eliminam a necessidade de métodos getX() e setX() para lógica simples:

class Usuario {
    public string $nome {
        get => ucfirst($this->nome);
        set(string $value) {
            if (strlen($value) < 3) {
                throw new \InvalidArgumentException('Nome muito curto');
            }
            $this->nome = $value;
        }
    }
}

Asymmetric Visibility

Controle granular de acesso: uma propriedade pode ser pública para leitura, mas privada para escrita:

class Configuracao {
    public private(set) string $apiKey;

    public function __construct(string $apiKey) {
        $this->apiKey = $apiKey;
    }
}

Lazy Objects

Inicialização sob demanda sem depender de proxies ou frameworks:

$inicializador = new \LazyObjectInitializer(function() {
    return new ServicoPesado();
});

$servico = $inicializador->get(); // Só cria o objeto aqui

Melhorias em tipos union e intersection

Suporte mais flexível a null em tipos compostos:

function processar(null|string|int $dado): void {} // Já existia
function validar((string&Countable)|null $item): void {} // Novo em 8.4

3. Performance e otimizações no motor Zend

O JIT (Just-In-Time) do PHP 8.4 recebeu melhorias na compilação adaptativa, resultando em ganhos de 5-15% em workloads reais de APIs REST e processamento de templates. O Opcache agora suporta arquivos maiores que 2GB e faz cache de classes com herança complexa de forma mais eficiente.

Benchmark comparativo (operações por segundo em um servidor Nginx+PHP-FPM):

Operação            PHP 8.3    PHP 8.4    Ganho
Laço simples        1.200/s    1.350/s    +12.5%
Manipulação array   890/s      1.020/s    +14.6%
Chamada função      2.100/s    2.300/s    +9.5%

4. Novas funções, classes e extensões nativas

Funções de coleção

$usuarios = [
    ['nome' => 'Ana', 'idade' => 25],
    ['nome' => 'João', 'idade' => 30],
];

$primeiroMaiorQue27 = array_find($usuarios, fn($u) => $u['idade'] > 27);
// ['nome' => 'João', 'idade' => 30]

$indice = array_find_key($usuarios, fn($u) => $u['nome'] === 'Ana');
// 0

Suporte multibyte completo

$texto = "  Olá Mundo!  ";
echo mb_trim($texto); // "Olá Mundo!"
echo mb_lcfirst("PHP"); // "pHP"
echo mb_ucfirst("php"); // "PHP"

Extensão bcmath aprimorada

$a = new \BcMath\Number('10.50');
$b = new \BcMath\Number('3.25');
echo $a->compare($b); // 1 (maior)
echo $a->round(1); // 10.5

Melhorias em random

$random = new \Random\Randomizer(new \Random\Engine\Secure());
$bytes = $random->getBytes(16); // 16 bytes criptograficamente seguros

5. Mudanças na sintaxe e ergonomia do dia a dia

Atributos nativos para Deprecated e Override

class Base {
    public function metodo(): void {}
}

class Derivada extends Base {
    #[\Override]
    public function metodo(): void {} // Garante que está sobrescrevendo
}

#[\Deprecated('Use novaFuncao() em vez disso', since: '8.4')]
function antigaFuncao(): void {}

Operador nullsafe estendido

$dados = ['usuario' => ['nome' => 'Maria']];
echo $dados['usuario']?->nome; // Acessa array como objeto

Multi-catch simplificado

try {
    // código
} catch (A | B) { // Variável de exceção opcional
    // Trata ambas
}

Match com expressões encadeadas

$resultado = match (true) {
    $x > 10 => 'grande',
    $x > 5  => 'médio',
    default => 'pequeno',
};

6. O que ainda falta: críticas e lacunas do PHP 8.4

Apesar dos avanços, o PHP 8.4 ainda deixa lacunas importantes:

  • Generics em tempo de execução: continuam apenas como anotações PHPDoc, sem verificação em runtime.
  • Tipos primitivos imutáveis: value objects como Money ou Email ainda exigem classes manuais.
  • Async/await nativo: a concorrência ainda depende de extensões como Swoole, ReactPHP ou Amp. As Fibers introduzidas no PHP 8.1 são subutilizadas por falta de um runtime oficial.
  • Gerenciamento de dependências: o Composer continua sendo externo, sem integração nativa com a linguagem.

7. Impacto na migração de projetos legados

Compatibilidade retroativa

A atualização de PHP 8.1/8.2 para 8.4 quebra principalmente:
- Funções mysql_* (removidas desde 7.0, mas ainda presentes em código legado)
- Comportamento de strtolower() com strings binárias (agora mais restritivo)
- Classes que usavam __get/__set agora podem conflitar com property hooks

Estratégia de adoção gradual

// Antes (PHP 8.2)
class Produto {
    private float $preco;
    public function getPreco(): float { return $this->preco * 1.1; }
    public function setPreco(float $preco): void { $this->preco = $preco; }
}

// Depois (PHP 8.4)
class Produto {
    public float $preco {
        get => $this->preco * 1.1;
        set => $this->preco = $value;
    }
}

Ferramentas como PHPStan e Psalm já oferecem suporte parcial a property hooks e lazy objects, facilitando a análise estática durante a migração.

8. Futuro do PHP: o que esperar para 8.5 e 9.0

RFCs em andamento para próximas versões incluem:
- Typed class constants: constantes com tipos explícitos
- Primary constructors: sintaxe mais enxuta para construtores
- Pattern matching: similar ao match mas com desestruturação

Há discussões sobre a depreciação final de ereg_* e mysql_* (já removidos, mas ainda lembrados). O roadmap para tipos genéricos e imutabilidade nativa ainda é incerto, mas a pressão de concorrentes como Go, Rust e TypeScript mantém o tema na agenda.

O PHP continua relevante para desenvolvimento web (71% dos sites usam PHP, segundo W3Techs), mas precisa evoluir em tipagem e concorrência para competir com linguagens mais modernas em cenários de alta performance.

Referências