Descubra as principais novidades do PHP 8.6

Marcos Marcolin • 17 de agosto de 2026 • 7 min de leitura

PHP PHP 8.6 PHP RFC

Novidades do PHP 8.6 🐘

O PHP 8.6 ainda está em fase de desenvolvimento e testes, com previsão de lançamento para a segunda metade de novembro de 2026. As informações deste post podem mudar até lá, conforme as RFCs forem votadas e implementadas.

Se você acompanha este blog ou meu LinkedIn, provavelmente já viu algumas das novidades, pois costumo comentar as RFCs e mudanças mais importantes ao longo do ano.

Neste post, trago um resumo das principais melhorias do 8.6, com base nas RFCs já aceitas. Separei o que mais faz diferença no dia a dia, já que muita coisa foi desenvolvida ao longo do ano para deixar a linguagem mais simples, mais rápida e mais consistente. Vou seguir atualizando este post conforme novas RFCs forem votadas e implementadas.

Sumário

Polling API: uma base nativa para I/O assíncrono - RFC

O PHP 8.6 traz o novo namespace Io\Poll, com uma API nativa de polling para multiplexação de I/O, prometendo melhor desempenho que o tradicional stream_select(). A ideia é oferecer uma base comum que bibliotecas de baixo nível, como ReactPHP e Amp, possam usar para gerenciar múltiplos streams, sockets e outros recursos que suportam polling.

PHP 8.5 e anteriores

$read = [$server];
$write = $except = [];

stream_select($read, $write, $except, 1);

foreach ($read as $stream) {
    // trata o evento de leitura
}

PHP 8.6

use Io\Poll\{Context, Event};

$server = stream_socket_server('tcp://0.0.0.0:8080');
stream_set_blocking($server, false);

$poll = new Context();
$poll->add(new StreamPollHandle($server), [Event::Read], ['type' => 'server']);

while (true) {
    foreach ($poll->wait(timeoutSeconds: 1) as $watcher) {
        if ($watcher->getData()['type'] === 'server' && $watcher->hasTriggered(Event::Read)) {
            $client = stream_socket_accept($server);
            $poll->add(new StreamPollHandle($client), [Event::Read], ['type' => 'client']);
        }
    }
}

Por enquanto, o PHP 8.6 lança a base da API. Handles mais específicos, como SocketPollHandle, CurlPollHandle, TimerHandle e SignalHandle, ficam para versões futuras.

Partial Function Application: aplicação parcial de funções - RFC principal - RFC complementar

O PHP 8.6 introduz a aplicação parcial de funções, permitindo criar closures a partir de uma chamada de função, preenchendo alguns argumentos e deixando outros para depois. Isso é feito com os placeholders ? (um argumento) e ... (os argumentos restantes, de forma variádica). Uma RFC complementar ainda deixou o comportamento mais previsível: todo placeholder ? sempre gera um parâmetro obrigatório na closure resultante.

Esse recurso é uma extensão natural das first-class callable syntax, adicionadas no PHP 8.1, e combina muito bem com o pipe operator introduzido no PHP 8.5.

PHP 8.5 e anteriores

function converterMoeda(float $valor, string $de, string $para): float { /* ... */ }

$paraReal = fn (float $valor, string $de): float => converterMoeda($valor, $de, 'BRL');

PHP 8.6

function converterMoeda(float $valor, string $de, string $para): float { /* ... */ }

$paraReal = converterMoeda(?, ?, 'BRL');
$paraReal(100.0, 'USD');
// Equivalente a: fn(float $valor, string $de): float => converterMoeda($valor, $de, 'BRL');

$precos = [19.90, 249.00, 5.50];
$precosEmReal = array_map(converterMoeda(?, 'USD', 'BRL'), $precos);

Vale lembrar que construtores não são suportados: não é possível criar uma closure parcial a partir de new. O motivo, segundo a própria RFC, é que construtores são invocados de forma indireta pela engine, o que tornaria o suporte bem mais custoso, e os casos de uso para isso são raros, ainda mais com os lazy objects do PHP 8.4.

Função clamp(): restringindo valores dentro de um intervalo - RFC

O PHP 8.6 ganha a função nativa clamp(), que restringe um valor dentro de um intervalo mínimo e máximo. Se o valor estiver fora do intervalo, ela retorna o limite mais próximo; caso contrário, retorna o próprio valor. É um caso tão comum que sempre acabava virando uma combinação de min() e max() espalhada pelo código.

PHP 8.5 e anteriores

$zoom = max(50, min(200, $zoom));

PHP 8.6

$zoom = clamp($zoom, min: 50, max: 200);

clamp(30, min: 50, max: 200); // 50
clamp(120, min: 50, max: 200); // 120
clamp(250, min: 50, max: 200); // 200

Sessões mais seguras por padrão - RFC

Três diretivas do ext/session tinham implicações de segurança, mas vinham com valores padrão que deixavam aplicações desnecessariamente expostas. O PHP 8.6 muda esses padrões para que novas instalações já nasçam mais seguras, sem exigir nenhuma mudança de código para o caso comum.

Recursos e melhorias adicionais

Além dos principais recursos do PHP 8.6, várias melhorias menores foram adicionadas para tornar o desenvolvimento mais seguro, consistente e previsível.

Valores padrão em propriedades readonly

Propriedades readonly agora podem ter um valor padrão, o que é especialmente útil combinado com as propriedades de interface introduzidas no PHP 8.4, permitindo declarar metadados fixos sem precisar de um construtor:

final readonly class InvoiceExporter implements ExporterBlueprint
{
    public string $name = 'Invoice Exporter';
    public string $format = 'pdf';
}

Nova classe Time\Duration

Classe que representa um intervalo de tempo fixo e livre de contexto (diferente do DateInterval), útil para timeouts, delays e medições. Vem com métodos como Duration::fromSeconds(), add() e divideBy().

#[\Override] também para constantes de classe - RFC

O atributo #[\Override], que já funcionava em métodos e propriedades, agora também pode ser usado em constantes de classe, ajudando a garantir que uma constante realmente esteja sobrescrevendo outra da classe pai.

Escrita em propriedades de objetos referenciados por constantes - RFC

Agora é possível alterar propriedades de um objeto guardado em uma constante de classe, mantendo a própria constante imutável (ou seja, a referência ao objeto não pode ser trocada, só o estado interno dele):

const BACKING = new stdClass();

class C
{
    const O = BACKING;
}

C::O->prop = 42;
var_dump(C::O->prop);
// int(42)

Enums mais expressivos: SortDirection e depuração personalizada - RFC - RFC

O PHP 8.6 traz um enum nativo SortDirection, com os casos Ascending e Descending, pensado para frameworks e bibliotecas usarem no lugar de strings soltas ao ordenar dados:

$query->orderBy('created_at', SortDirection::Descending);

Enums também passam a poder implementar __debugInfo(), assim como classes comuns, personalizando a saída do var_dump():

enum StatusPedido: string
{
    case Pago = 'pago';

    public function __debugInfo(): array
    {
        return [self::class . '::' . $this->name => $this->value];
    }
}

var_dump(StatusPedido::Pago);
// enum(StatusPedido::Pago) (1) {
//   ["StatusPedido::Pago"]=>
//   string(4) "pago"
// }

Novidades em Reflection, enums e funções

Descontinuações e quebras de compatibilidade

Sintaxe e palavras reservadas

Form Feed agora é whitespace em trim()

As funções trim(), ltrim() e rtrim() passam a remover também o caractere form feed (\f, ASCII 12) por padrão, junto com espaço, tab, quebra de linha, retorno de carro e NUL. É uma quebra de compatibilidade: código que dependia de preservar esse caractere nas pontas de uma string precisa ser revisado.

Objetos em funções que esperam arrays

Passar objetos para funções que esperam um array, como array_walk(), array_walk_recursive(), deflate_init(), inflate_init(), os filtros de stream zlib e bzip2, mb_convert_variables() e http_build_query(), agora é descontinuado. Use get_object_vars() para converter o objeto antes de passá-lo.

Funções e métodos descontinuados

Considerações finais

Na minha visão, o PHP 8.6 reforça o quanto a linguagem continua evoluindo de forma consistente. Os novos recursos são úteis no dia a dia, resolvem problemas reais e deixam o código mais claro e moderno.

Este post vai continuar sendo atualizado conforme novas RFCs forem votadas e aprovadas até o lançamento oficial. Você pode acompanhar o cronograma e todas as RFCs no site oficial do PHP.

Até a próxima!

Compartilhar: