Novidades do PHP 8.6: o que muda no seu código e o que pode quebrar no upgrade

Novidades do PHP 8.6: o que muda no seu código e o que pode quebrar no upgrade

Novembro chegou e, como manda a tradição, trouxe mais uma versão do PHP: o PHP 8.6 foi lançado hoje, 19 de novembro de 2026. E dessa vez a lista de novidades está bem mais interessante do que eu esperava.

Tu vai encontrar por aí um monte de tradução da página de lançamento. Não é isso que eu quero fazer aqui. Neste artigo eu vou te mostrar a minha leitura do PHP 8.6: o que muda no código que a gente escreve todo dia, o que pode quebrar no upgrade e onde eu acho que vale (ou não) se empolgar.

Tudo o que está aqui vem da página oficial de lançamento do PHP 8.6 e das RFCs linkadas nela. Os exemplos de código também saíram de lá, então se algo parecer estranho, a culpa é da sintaxe nova e não minha 😉

TL;DR

  • Partial Function Application é a estrela da versão: version_compare(?, '8.6', '>=') vira uma Closure. Adeus a um monte de fn que só repassava argumento.
  • Time\Duration, clamp() e o enum SortDirection parecem pequenos, mas mexem em código de produção de verdade.
  • Propriedades readonly agora aceitam valor padrão.
  • Streams podem finalmente lançar exceção com erro estruturado, em vez do combo warning + @ + error_get_last().
  • No upgrade, fique de olho principalmente nos novos padrões de sessão, no trim() removendo \f, no novo retorno de fclose(), file_put_contents() e copy(), e numa lista generosa de deprecações.

Conteúdos deste artigo

Partial Function Application: o fim do fn que só repassa argumento

Se tu escreve PHP moderno, aposto que já escreveu algo assim um tempão de vezes:

$versions = ['8.4', '8.5', '8.6', '8.7', '9.0'];
$supportsPfa = array_filter(
    $versions,
    fn ($version) => version_compare($version, '8.6', '>='),
);

Repare que a arrow function não faz NADINHA além de repassar $version pra version_compare(). É cerimônia pura. No PHP 8.6 dá pra escrever assim:

$versions = ['8.4', '8.5', '8.6', '8.7', '9.0'];
$supportsPfa = array_filter(
    $versions,
    version_compare(?, '8.6', '>='),
);

O ? é um marcador de posição (placeholder): ele diz "esse argumento eu passo depois". Em vez de chamar version_compare() na hora, o PHP te devolve uma Closure que recebe só os argumentos que ficaram faltando. A função original só é chamada de verdade quando tu passa o resto.

Segundo a RFC de Partial Function Application, existem dois marcadores:

  • ? significa "exatamente um argumento nesta posição";
  • ... significa "zero ou mais argumentos", ou seja, todo o resto.

Se esse ... te parece familiar, não é coincidência. A sintaxe de first-class callable do PHP 8.1 (strlen(...)) é, nas palavras da própria RFC, o caso degenerado da partial application. O PHP 8.6 só terminou o trabalho que começou lá atrás.

Um detalhe que eu gostei MUITO: a Closure gerada herda nome, tipo, opcionalidade e valor padrão dos parâmetros da função original. Ou seja, Reflection e as ferramentas de análise estática enxergam a assinatura completa, coisa que a gente normalmente perde (ou tem que redigitar) com a arrow function. Dá pra usar placeholder nomeado também, e tu vai ver um (attempt: ?) lá na seção da Duration.

Cuidado: os argumentos são avaliados na hora

Tem uma diferença sutil que a RFC faz questão de documentar, e eu aposto que ela vai gerar bug por aí. Vê só:

function getArg() {
  print __FUNCTION__ . PHP_EOL;
  return 'hi';
}

function speak(string $who, string $msg) {
  printf("%s: %s\n", $who, $msg);
}

$arrow = static fn($who) => speak($who, getArg());
print "Arnaud\n";
$arrow('Larry');

/* Prints:
Arnaud
getArg
Larry: hi
*/

$partial = speak(?, getArg());
print "Arnaud\n";
$partial('Larry');

/* Prints:
getArg
Arnaud
Larry: hi
*/

Na arrow function, getArg() só roda quando a closure é chamada. Na partial application, os argumentos que tu já forneceu são avaliados e guardados no momento em que a closure é criada. Se esse argumento for algo caro (uma query, uma chamada HTTP) ou algo que depende do momento em que roda (um new DateTimeImmutable(), por exemplo), o comportamento muda.

👉 Lembre-se: partial application congela valores, arrow function adia expressões.

Outra pegadinha: new não pode ser parcialmente aplicado. $e = new E(1, ?); gera erro de compilação ("Cannot create Closure for new expression."). Se tu precisa de uma fábrica, um método estático resolve: E::make(1, ?) funciona normalmente.

E de bônus, a página de lançamento diz que array_map() com callback de first-class callable ou de partial application agora é compilado para loops. Eu ainda não medi isso, então não vou te prometer número nenhum. Quando eu rodar benchmark, eu publico com o ambiente descrito, como sempre.

Minha opinião? Esse é o recurso que mais vai mudar o código do dia a dia nesta versão. Mas a RFC mostra que coisas como stuff(1, ?, p: ?, f: 3.14, ...) são válidas, e eu te peço encarecidamente: não faça isso. Código complexo é diferente de código complicado! Se a pessoa que vai ler precisa de papel e caneta pra descobrir a assinatura da closure, a arrow function explícita ganha.

Time\Duration: chega de comentário dizendo "em microssegundos"

Me diz se tu nunca viu (ou escreveu) um docblock assim:

/**
 * All delays are in microseconds.
 */
function backoff(
    int $baseDelay,
    int $step,
    int $attempt,
): void {
    $delay = $baseDelay + ($step * (2 ** $attempt));
    // Wait at most 30 seconds.
    usleep(min($delay, 30_000_000));
}

// 1 second base delay, plus 100 milliseconds
// doubling with each attempt.
backoff(1_000_000, 100_000, $attempt);

Esse código funciona. O problema é que a correção dele inteira depende de um comentário. Um int não carrega unidade, então basta alguém passar milissegundos achando que são segundos e pronto: o seu retry espera mil vezes menos (ou mais) do que deveria. É o caso clássico de um primitivo que carrega regra e está implorando por um value object.

Agora o PHP traz esse value object de fábrica:

use Time\Duration;

function backoff(
    Duration $baseDelay,
    Duration $step,
    int $attempt,
): void {
    $delay = $baseDelay->add($step->multiplyBy(2 ** $attempt));
    // Durations are comparable, so min() works directly.
    $delay = min($delay, Duration::fromSeconds(30));
    time_nanosleep($delay->seconds, $delay->nanoseconds);
}

backoff(
    Duration::fromSeconds(1),
    Duration::fromMilliseconds(100),
    $attempt,
);

// Preconfigure the delays using Partial Function Application.
$waitBeforeRetry = backoff(
    Duration::fromSeconds(1),
    Duration::fromMilliseconds(100),
    attempt: ?,
);
$waitBeforeRetry($attempt);

Reparou? A unidade agora está no nome do método (fromSeconds(), fromMilliseconds()) e não num comentário que ninguém atualiza. E como durações são comparáveis, min() funciona direto. No fim do exemplo ainda tem o placeholder nomeado attempt: ? que eu prometi lá em cima.

De acordo com a página de lançamento, a Duration representa tempo decorrido "como medido por um cronômetro", independente de data e fuso horário, com precisão de nanossegundos e alcance de mais de 250 anos. Ou seja, ela é pra timeouts, retries e medição de benchmark. Pra coisas de calendário, continua sendo trabalho do DateTimeImmutable.

Na escala em que eu estou acostumado a trabalhar, timeout mal configurado é uma das formas mais baratas de derrubar um sistema. Qualquer coisa que torne esse tipo de valor mais difícil de errar é muito bem-vinda.

clamp(): finalmente!

Quantas vezes tu já escreveu max(0, min($valor, 100)) e parou dois segundos pra ter certeza de que não inverteu a ordem? Pois é. O jeito antigo:

var_dump(max(0, min(-10, 100)));
// int(0)
var_dump(max(0, min(50, 100)));
// int(50)
var_dump(max(0, min(110, 100)));
// int(100)

E o jeito novo:

var_dump(clamp(-10, 0, 100));
// int(0)
var_dump(clamp(50, 0, 100));
// int(50)
var_dump(clamp(110, 0, 100));
// int(100)

// Any comparable value works with clamp(). This
// includes the new Duration class.
var_dump(clamp(
    \Time\Duration::fromSeconds(30),
    min: \Time\Duration::fromMinutes(1),
    max: \Time\Duration::fromMinutes(10),
)->seconds);
// int(60)

A RFC do clamp() traz duas coisas que o max(min()) nunca te deu: se $min for maior que $max, ou se algum dos limites for NAN, a função lança ValueError. Falhar cedo em vez de devolver lixo silenciosamente. Do jeito que a gente gosta!

clamp(4, 8, 6)
// Throws ValueError: clamp(): Argument #2 ($min) must be smaller than or equal to argument #3 ($max)

Dois avisos. Primeiro: a assinatura é mixed e segue as regras normais de comparação do PHP, então a própria RFC recomenda usar $value, $min e $max do mesmo tipo. Segundo, e esse é de upgrade: se o seu projeto declara uma função global chamada clamp(), ela vai colidir com a função nativa. Dá uma olhadinha nos seus helpers antes de subir a versão.

SortDirection: um enum pra parar a bagunça do SORT_ASC

Esse aqui é o meu exemplo favorito da página de lançamento, porque ele mostra um bug que eu já vi em code review mais vezes do que gostaria de admitir:

class QueryBuilder
{
    private array $orderBy = [];

    public function orderBy(
        string $column,
        int $direction = SORT_ASC,
    ): static {
        $this->orderBy[] = $column . ' ' . match ($direction) {
            SORT_ASC => 'ASC',
            SORT_DESC => 'DESC',
        };
        return $this;
    }
}

$qb->orderBy('name', SORT_DESC);
$qb->orderBy('name', SORT_STRING);
// Accepted by the signature, then fails inside the method:
// UnhandledMatchError: Unhandled match case 2

O int aceita qualquer constante SORT_*, inclusive as que não fazem sentido nenhum ali. O erro só aparece lá dentro do método, longe de quem errou. Com o enum nativo:

class QueryBuilder
{
    private array $orderBy = [];

    public function orderBy(
        string $column,
        SortDirection $direction = SortDirection::Ascending,
    ): static {
        $this->orderBy[] = $column . ' ' . match ($direction) {
            SortDirection::Ascending => 'ASC',
            SortDirection::Descending => 'DESC',
        };
        return $this;
    }
}

$qb->orderBy('name', SortDirection::Descending);
$qb->orderBy('name', SORT_STRING);
// TypeError: QueryBuilder::orderBy(): Argument #2 ($direction)
// must be of type SortDirection, int given

Agora o erro estoura na fronteira, na chamada, com uma mensagem que diz exatamente o que está errado. É o princípio do Samurai aplicado pelo próprio sistema de tipos.

Mas o que me empolga de verdade aqui não é o enum em si (qualquer pessoa escreve um enum com dois cases). É ele ser nativo: hoje cada biblioteca tem o seu jeito de representar direção de ordenação, entre inteiros, strings, booleanos e enums próprios. Com um tipo compartilhado, ORM, query builder e coleção podem conversar sem código adaptador. A PHP Foundation escreveu sobre esse investimento na biblioteca padrão no blog dela, vale a leitura.

Propriedades readonly com valor padrão

Desde o PHP 8.4 dá pra declarar propriedade em interface. Só que, se tu quisesse implementar uma propriedade só-leitura com valor fixo, precisava de um construtor só pra isso:

interface Rule
{
    public string $parser { get; }
}

final readonly class SlugRule implements Rule
{
    public string $parser;

    public function __construct()
    {
        $this->parser = SlugParser::class;
    }
}

No PHP 8.6, propriedades readonly de instância (inclusive as de classes readonly) podem ter valor padrão:

interface Rule
{
    public string $parser { get; }
}

final readonly class SlugRule implements Rule
{
    public string $parser = SlugParser::class;
}

Simples assim. Só tem um detalhe importante, descrito na RFC de Readonly Property Defaults: o valor padrão conta como a inicialização da propriedade. Então o construtor não pode sobrescrever:

final readonly class Rule
{
    public string $className = SomeParser::class;

    public function __construct(string $className) {
        $this->className = $className; // Error: Cannot modify readonly property Rule::$className
    }
}

Ou seja: isso NÃO é um "valor padrão que o construtor pode trocar se quiser". Se o valor precisa variar, continue usando promoção de propriedade no construtor com parâmetro opcional. Pela mesma razão, unset() numa propriedade readonly com valor padrão também lança erro, e aquele padrão de inicialização preguiçosa via __get() não funciona com ela.

Erros de stream que dá pra tratar de verdade

Se tu já precisou tratar erro de file_get_contents() em produção, conhece esse código. E provavelmente não tem saudade dele:

$config = @file_get_contents('/etc/app/config.json');
if ($config === false) {
    // Only an unstructured message string is available
    $error = error_get_last();
    log_error($error['message']);
}

O @ silencia o warning, e tudo o que sobra é uma string sem estrutura nenhuma. No PHP 8.6 tu pode configurar o contexto do stream pra lançar exceção:

$context = stream_context_create([
    'stream' => [
        'error_mode' => StreamErrorMode::Exception,
    ],
]);

try {
    $config = file_get_contents(
        '/etc/app/config.json',
        context: $context,
    );
} catch (StreamException $e) {
    foreach ($e->getErrors() as $error) {
        // $error->code is a StreamErrorCode enum case
        log_error(
            $error->code->name,
            $error->message,
            $error->wrapperName,
        );
    }
}

Cada erro vira um objeto StreamError com um case do enum StreamErrorCode, o nome do wrapper e o caminho ou URL afetado. Segundo a RFC de Stream Error Handling, são três modos: StreamErrorMode::Error (o padrão, que mantém os warnings de sempre), StreamErrorMode::Exception e StreamErrorMode::Silent. Também dá pra recuperar os erros depois com stream_last_errors().

Uma decisão de design que eu achei bem pensada: essas opções não podem ser definidas no contexto padrão via stream_context_set_default() (isso lança ValueError). O motivo, segundo a RFC, é não quebrar bibliotecas que contam com os warnings no comportamento padrão. Então nada de ligar exceção global e sair quebrando dependência dos outros: tu precisa criar o contexto explicitamente. Dá um pouquinho mais de trabalho, mas é o tipo de coexistência entre o velho e o novo que torna um upgrade seguro.

Io\Poll: a base pros event loops

Esse aqui é mais nichado, mas é importante pro ecossistema. A nova API Io\Poll monitora vários streams ao mesmo tempo usando o melhor mecanismo de cada plataforma (epoll, kqueue, event ports ou WSAPoll), sem os limites de escala do stream_select(). O exemplo da página de lançamento é um servidor de eco simplão:

use Io\Poll\{Context, Event};

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

// Automatically uses epoll, kqueue, event ports, or WSAPoll
$poll = new Context();
$poll->add(new StreamPollHandle($server), [Event::Read]);

while (true) {
    foreach ($poll->wait() as $watcher) {
        $stream = $watcher->getHandle()->getStream();

        if ($stream === $server) {
            $client = stream_socket_accept($server);
            $poll->add(
                new StreamPollHandle($client),
                [Event::Read],
            );
            continue;
        }

        $data = fread($stream, 8192);
        if ($data === '' || $data === false) {
            $watcher->remove();
            fclose($stream);
        } else {
            fwrite($stream, $data);
        }
    }
}

Na versão antiga, baseada em select(), o próprio comentário da página avisa que tipicamente não dá pra passar de 1024 conexões. Na real, eu não espero que a maioria das pessoas use Io\Poll direto no código da aplicação. Ela foi desenhada como fundação comum pra bibliotecas de event loop como ReactPHP e AMPHP. Se tu usa alguma delas, o ganho deve chegar de tabela quando elas adotarem a API nova.

Reflection: DocComment em parâmetro, isReadable() e isWritable()

Duas novidades pra quem escreve framework, ORM, serializador ou ferramenta de análise. A primeira: parâmetros agora podem ter o próprio DocComment, lido com ReflectionParameter::getDocComment():

class DB
{
    /**
     * Returns up to $limit items matching the $query.
     */
    public function search(
        /** Terms to search */
        string $query,
        /** Maximum number of results */
        int $limit = 10,
    ): array {
        return [];
    }
}

var_dump(
    new ReflectionParameter([DB::class, 'search'], 'query')
        ->getDocComment(),
);
// string(22) "/** Terms to search */"

Acabou a repetição de nome e tipo no @param. Eu gosto, porque a documentação fica do lado da declaração e tem menos chance de ficar desatualizada.

A segunda: ReflectionProperty::isReadable() e ReflectionProperty::isWritable(). Com readonly, visibilidade assimétrica e property hooks, saber se a propriedade é public já não diz se dá pra ler ou escrever nela. Os métodos novos respondem isso pra um escopo (e opcionalmente pra um objeto específico), levando em conta visibilidade, estado de inicialização, hooks e métodos mágicos. Quem mantém hydrator e serializador vai apagar um bocado de código com isso.

Menções honrosas

A página de lançamento lista mais uma porção de melhorias. As que eu acho que valem o seu tempo:

  • O atributo #[\Override] agora pode ser usado em constantes de classe e cases de enum.
  • Enums podem implementar __debugInfo().
  • Propriedades de objetos guardados em constantes podem ser modificadas diretamente, por exemplo Config::DEFAULTS->timeout = 30.
  • Novo método mysqli::quote_string(), que escapa a string e coloca as aspas, igual ao PDO::quote().
  • Mensagens de erro de JSON agora incluem a posição do erro na entrada. Quem já debugou JSON de 2 MB numa linha só sabe o valor disso.
  • Nova configuração INI error_include_args, que inclui de forma consistente os argumentos das funções nas mensagens de erro.
  • pack() e unpack() aceitam os modificadores de endianness < e > em códigos de inteiro e float. Pra quem, como eu, gosta de mexer com binário no PHP, isso é ótimo.
  • ZipArchive::openString() e ZipArchive::closeString() pra trabalhar com zip em memória.
  • Novas classes Uri\Rfc3986\UriBuilder e Uri\WhatWg\UrlBuilder, além da função Uri\WhatWg\url_percent_encode().
  • A extensão Sodium ganhou encapsulamento de chave pós-quântico (X-Wing e ML-KEM-768), criptografia de endereço IP e as funções SHAKE e TurboSHAKE.
  • Streams TLS suportam retomada de sessão, chaves pré-compartilhadas externas e early data do TLS 1.3 (0-RTT).
  • grapheme_strrev() e a classe IntlNumberRangeFormatter na extensão intl.
  • Melhorias de performance: além do array_map() que eu já citei, chamadas de printf() mais rápidas, cache de closures sem estado e codificação de JSON mais rápida.

Sobre performance, o mesmo aviso de sempre: a página não traz números, eu ainda não medi, e a maior parte das aplicações PHP passa a vida esperando E/S (I/O). Não espere que o upgrade, sozinho, salve o seu tempo de resposta.

O que pode quebrar no upgrade?

Agora a parte que importa pra quem cuida de sistema em produção. Eu separei em dois grupos, porque eles pedem atenções diferentes.

Mudanças de comportamento: essas não avisam

Deprecação gera aviso no log. Mudança de comportamento simplesmente acontece. Por isso eu começaria por aqui:

  • Sessões mais seguras por padrão. session.use_strict_mode e session.cookie_httponly passam a vir habilitados, e session.cookie_samesite passa a ser Lax. Eu acho a mudança corretíssima, mas ela pode pegar quem dependia do contrário sem saber: JavaScript lendo o cookie de sessão, ou fluxos em que o cookie de sessão precisa ir junto numa requisição vinda de outro site. Se o seu php.ini já define esses valores explicitamente, nada muda pra você.
  • trim(), ltrim() e rtrim() agora também removem form feed (\f) por padrão. Raramente vai importar, mas se tu tem teste comparando string com \f, é aqui que ele vai quebrar.
  • fclose(), file_put_contents() e copy() retornam false quando o flush ou o fechamento do stream falha, em vez de ignorar a falha silenciosamente. Isso é correção de bug, mas código que tratava qualquer coisa diferente de false como sucesso pode começar a entrar no caminho de erro. Ótimo, na real: provavelmente era um erro que já existia e ninguém via.
  • Muitas funções agora lançam ValueError pra valores fora do intervalo, flags inválidas ou strings com bytes NUL, em vez de truncar ou ignorar.

O que vai quebrar depois do 8.6

Essas não quebram nada hoje, mas são a lista de tarefas do seu próximo upgrade. As que eu acho que mais vão aparecer em código real:

  • return dentro de finally. A página explica o motivo: ele descarta exceções silenciosamente e sobrescreve o valor retornado pelo try ou pelo catch. Se tu tem isso no código, provavelmente já tinha um bug escondido.
  • Retornar valor de __construct() ou __destruct(), ou transformá-los em generator. Declarar retorno nullable em __debugInfo() também foi descontinuado.
  • Usar let ou is como nome de classe, função ou constante. Também _ como nome de constante, namespace como nome de constante de classe e readonly como nome de função.
  • As funções de regex do mbstring (mb_ereg(), mb_split() e companhia), porque a biblioteca Oniguruma não é mais mantida. A troca é usar PCRE com o modificador u.
  • Os aliases is_double(), is_long(), is_integer() e doubleval(). Use is_float(), is_int() e floatval().
  • spl_object_hash() (use spl_object_id()) e spl_classes() (use ReflectionExtension::getClassNames()).
  • Passar objeto onde se espera array pra array_walk(), array_walk_recursive(), http_build_query(), mb_convert_variables() e funções e filtros de compressão. Converta antes com get_object_vars().
  • strcoll() e a flag SORT_LOCALE_STRING. A recomendação é usar a classe Collator da extensão intl.
  • Terceiro argumento de define(), e chamar is_a() ou is_subclass_of() com nome de classe em string quando $allow_string é false.
  • Mais de 16 filtros numa URL php://filter sem configurar a opção de contexto filter.max_filter_count.
  • Handlers de sessão customizados que não implementam create_sid() e validateId().
  • metaphone(), mysqli_get_charset(), mysqli_stmt_init(), os métodos de CSV do SplFileObject e os métodos de ordenação, flags e serialização do ArrayIterator.

Só pra ilustrar o primeiro item, que é o que eu mais espero encontrar em código legado. Este é o tipo de código que agora gera aviso de depreciação:

function carregaConfig(): array
{
    try {
        return lerArquivoDeConfig();
    } finally {
        // Se lerArquivoDeConfig() lançar uma exceção,
        // este return engole a exceção sem ninguém ficar sabendo
        return [];
    }
}

Se a intenção era ter um valor de fallback, o lugar dele é num catch explícito, de preferência com log. O finally é pra limpeza, não pra decidir o retorno.

Como eu faria o upgrade

Não existe receita universal, porque quase tudo depende. Mas se fosse um sistema sob a minha responsabilidade, eu faria mais ou menos assim:

  1. Leia o guia de migração oficial. Este post é a minha leitura do que importa, não a lista completa. A lista completa está no guia e no ChangeLog.
  2. Coloque o PHP 8.6 na matriz do CI e rode os testes. Sério mesmo, rode os testes. É de graça. Se não tem teste cobrindo leitura de arquivo, sessão e manipulação de string, esse é um ótimo momento pra escrever alguns.
  3. Ligue E_DEPRECATED no log de um ambiente de homologação e conte as ocorrências. Deprecação ignorada vira a dor de cabeça do próximo upgrade.
  4. Faça um grep pelos suspeitos de sempre: return dentro de finally, mb_ereg, is_double, spl_object_hash, strcoll e qualquer function clamp global.
  5. Decida as configurações de sessão conscientemente. Teste os fluxos de login e qualquer integração que envolva outro domínio antes de virar a chave.
  6. Suba aos poucos. Uma parte dos servidores primeiro, com monitoramento olhando taxa de erro e logs, e um caminho de rollback que não dependa de um redeploy inteiro. É a mesma lógica que eu defendo pras feature flags: separar a mudança do risco dela.

E aí, vale a pena?

Vale. Na minha leitura, o PHP 8.6 é uma versão que olha pro código que a gente escreve de verdade. Partial Function Application é açúcar sintático, sim, mas é o açúcar que remove ruído de um monte de callback. Duration, clamp() e SortDirection são pequenos, mas cada um deles transforma um bug clássico de "passei o número errado" em erro de tipo. E as mudanças de sessão e de fclose() deixam o padrão mais seguro, mesmo custando um pouco de atenção no upgrade.

O que eu ainda quero ver: benchmarks reais do array_map() compilado pra loop, e quanto tempo as bibliotecas de event loop vão levar pra adotar o Io\Poll. Quando eu tiver dado, eu volto aqui.

Se tu quiser comparar com versões anteriores, eu também escrevi sobre as novidades do PHP 8.0, do PHP 8.1 e do PHP 8.2. É curioso ver como cada versão vai preparando o terreno da próxima.

Não esquece de compartilhar com a galera do seu time, principalmente com quem vai fazer o upgrade. E se eu deixei passar alguma coisa importante, me dá um toque lá no LinkedIn.

Até a próxima! 👋

Comentários