PHP 8.5 chegou oficialmente em 20 Nov 2025 e, como sempre, derrubou mais uma rodada de previsões de que a linguagem “vai morrer em breve”. Enquanto muita gente insiste em dizer que PHP está ultrapassado, a nova versão aparece mais rápida, mais limpa, cheia de recursos modernos e ainda alimentando boa parte da web 🌍.
A verdade é simples: a linguagem continua evoluindo, ganhando ferramentas elegantes para desenvolvedores e resolvendo dores antigas com soluções bem pensadas.
Pipe operator: menos gambiarra, mais fluxo 😎
Uma das estrelas do PHP 8.5 é o novo operador pipe |>. A ideia é permitir encadear chamadas de função da esquerda para a direita, sem precisar ficar criando variáveis intermediárias ou aninhando funções até virar um caos visual.
$title = ' PHP 8.5 Released ';
$slug = $title
|> trim(...)
|> (fn($str) => str_replace(' ', '-', $str))
|> (fn($str) => str_replace('.', '', $str))
|> strtolower(...);
O resultado é um código que você lê de cima para baixo, como se estivesse narrando o que acontece com o valor. Fica muito mais fácil de entender e manter.
Extensão URI: adeus regex de 2015 ✂️
Outra grande novidade é a nova extensão nativa de URI, sempre disponível no PHP 8.5. Ela permite analisar, normalizar e manipular URIs e URLs seguindo os padrões RFC 3986 e WHATWG URL.
Em vez de depender de parse_url() e remendos manuais, agora você tem uma API moderna baseada nas bibliotecas uriparser (RFC 3986) e Lexbor (WHATWG URL).
use Uri\Rfc3986\Uri;
$uri = new Uri('https://php.net/releases/8.5/en.php');
var_dump($uri->getHost());
// string(7) "php.net"
Ou seja: menos código esquisito de StackOverflow e mais soluções oficiais, padronizadas e prontas para o futuro.
Clone With: clonando objetos já ajustados 🎨
O clone() ganhou um super upgrade. Agora é possível clonar um objeto e já alterar propriedades na mesma operação, passando um array associativo com os novos valores.
return clone($this, [
'alpha' => $alpha,
]);
Isso simplifica bastante o famoso padrão “with-er”, especialmente em classes readonly. Em vez de reconstruir o objeto manualmente, você apenas clona e modifica o que precisa. Mais direto, mais limpo.
#[\NoDiscard]: PHP te cobrando atenção 🛎️
Quem já esqueceu de usar o valor de retorno de uma função crítica sabe o caos que isso pode causar. Com o atributo #[\NoDiscard], o PHP 8.5 passa a avisar quando o retorno de uma função marcada assim é simplesmente ignorado.
#[\NoDiscard]
function getPhpVersion(): string
{
return 'PHP 8.5';
}getPhpVersion();
// Warning: The return value of function getPhpVersion() should
// either be used or intentionally ignored by casting it as (void)
Se você realmente quiser descartar o valor, basta fazer um cast para (void), deixando claro que é intencional. Isso aumenta a segurança de APIs e ajuda a pegar erros sutis bem mais cedo.
array_first() e array_last(): o óbvio que finalmente chegou 🔚
Quantas vezes você já escreveu manualmente “pegar o primeiro ou o último elemento do array” com ternário, array_key_last() ou algo parecido? Pois é, o PHP 8.5 resolve isso com duas novas funções: array_first() e array_last().
Elas retornam o primeiro ou o último valor de um array, ou null se o array estiver vazio, o que combina perfeitamente com o operador ??.
$lastEvent = array_last($events);
Simples, direto e sem boilerplate.
Closures e first-class callables em expressões constantes 🧠
As closures estáticas e os first-class callables agora podem ser usados em expressões constantes, inclusive em:
- parâmetros de atributos
- valores padrão de propriedades
- parâmetros de funções
- constantes
final class PostsController
{
#[AccessControl(static function (
Request $request,
Post $post,
): bool {
return $request->user === $post->getAuthor();
})]
public function update(
Request $request,
Post $post,
): Response {
// ...
}
}
Isso deixa atributos mais poderosos e expressivos, permitindo lógica diretamente na definição, sem ficar preso a strings mágicas.
cURL persistente: menos custo, mais reaproveitamento 🌐
Para quem trabalha com muitas requisições HTTP, o PHP 8.5 traz os cURL Share Handles Persistentes. Com curl_share_init_persistent(), é possível manter handles compartilhados entre múltiplas requisições PHP.
Se um handle com o mesmo conjunto de opções já existir, ele é reutilizado, evitando o custo de inicializar tudo de novo a cada requisição.
$sh = curl_share_init_persistent([
CURL_LOCK_DATA_DNS,
CURL_LOCK_DATA_CONNECT,
]);$ch = curl_init('https://php.net/');
curl_setopt($ch, CURLOPT_SHARE, $sh);// This may now reuse the connection from an earlier SAPI request
curl_exec($ch);
É um ganho importante para aplicações que fazem muitas chamadas externas, especialmente em ambientes de alta carga.
Backtraces melhores para erros fatais 💥
Quando tudo quebra em produção, qualquer detalhe ajuda. Agora, erros fatais — como tempo máximo de execução excedido — passam a exibir um backtrace mais claro.
Isso não evita o problema, mas torna a depuração muito menos dolorosa, mostrando melhor onde e como a falha aconteceu.
Mais recursos que deixam o PHP 8.5 mais maduro
Além dos grandes destaques, o PHP 8.5 traz uma série de ajustes e incrementos que refinam a linguagem:
- atributos agora podem ter como alvo constantes
- o atributo #[\Override] pode ser aplicado também a propriedades
- o atributo #[\Deprecated] passa a poder ser usado em traits e constantes
- propriedades estáticas agora suportam visibilidade assimétrica
- propriedades promovidas no construtor podem ser marcadas como final
- novo método Closure::getCurrent(), que facilita recursão em funções anônimas
- setcookie() e setrawcookie() ganham suporte à chave "partitioned"
- novas funções get_error_handler() e get_exception_handler()
- novos métodos Dom\Element::getElementsByClassName() e Dom\Element::insertAdjacentHTML()
- nova função grapheme_levenshtein()
- novo atributo #[\DelayedTargetValidation] para suprimir erros de compilação de atributos do core e de extensões aplicados a alvos inválidos, com validação adiada
Descontinuações e quebras de compatibilidade ⚠️
Nem tudo são novos brinquedos. O PHP 8.5 também aproveita para limpar a casa e descontinuar comportamentos antigos que atrapalham a consistência da linguagem.
- o operador backtick como alias de shell_exec() foi descontinuído
- casts não canônicos como (boolean), (integer), (double) e (binary) foram descontinuados; a recomendação é usar (bool), (int), (float) e (string)
- a diretiva INI disable_classes foi removida por quebrar garantias internas do engine
- usar ponto e vírgula para finalizar declarações case, em vez de dois pontos, foi descontinuado
- usar null como índice de array ou ao chamar array_key_exists() agora é descontinuado; a orientação é usar string vazia
- não é mais permitido usar "array" e "callable" como nomes de alias de classe em class_alias()
- os métodos mágicos __sleep() e __wakeup() foram suavemente descontinuados; a alternativa recomendada é __serialize() e __unserialize()
- agora é emitido um aviso ao converter NAN para outros tipos
- desestruturar valores que não sejam arrays (exceto null) usando [] ou list() passa a emitir aviso
- converter floats (ou strings que pareçam floats) para int quando o valor não pode ser representado como inteiro também gera aviso
No conjunto, o recado do PHP 8.5 é claro: a linguagem está mais inteligente, mais rápida, preparada para padrões modernos e focada em desenvolvedores. Mais pipe, mais segurança com atributos, melhor suporte a URLs, menos pegadinhas antigas.
Atualizar para o PHP 8.5 significa entrar em uma versão mais limpa, mais coerente e cheia de recursos pensados para o dia a dia de quem escreve código, madrugada adentro, para a web que segue rodando em cima de PHP 💻.