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 defnque só repassava argumento. Time\Duration,clamp()e o enumSortDirectionparecem pequenos, mas mexem em código de produção de verdade.- Propriedades
readonlyagora 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 defclose(),file_put_contents()ecopy(), e numa lista generosa de deprecações.
Conteúdos deste artigo
- Partial Function Application: o fim do fn que só repassa argumento
- Time\Duration: chega de comentário dizendo "em microssegundos"
- clamp(): finalmente!
- SortDirection: um enum pra parar a bagunça do SORT_ASC
- Propriedades readonly com valor padrão
- Erros de stream que dá pra tratar de verdade
- Io\Poll: a base pros event loops
- Reflection: DocComment em parâmetro, isReadable() e isWritable()
- Menções honrosas
- O que pode quebrar no upgrade?
- Como eu faria o upgrade
- E aí, vale a pena?
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 aoPDO::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()eunpack()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()eZipArchive::closeString()pra trabalhar com zip em memória.- Novas classes
Uri\Rfc3986\UriBuildereUri\WhatWg\UrlBuilder, além da funçãoUri\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 classeIntlNumberRangeFormatterna extensão intl.- Melhorias de performance: além do
array_map()que eu já citei, chamadas deprintf()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_modeesession.cookie_httponlypassam a vir habilitados, esession.cookie_samesitepassa a serLax. 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()ertrim()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()ecopy()retornamfalsequando 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 defalsecomo 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
ValueErrorpra 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:
returndentro definally. A página explica o motivo: ele descarta exceções silenciosamente e sobrescreve o valor retornado pelotryou pelocatch. 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
letouiscomo nome de classe, função ou constante. Também_como nome de constante,namespacecomo nome de constante de classe ereadonlycomo 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 modificadoru. - Os aliases
is_double(),is_long(),is_integer()edoubleval(). Useis_float(),is_int()efloatval(). spl_object_hash()(usespl_object_id()) espl_classes()(useReflectionExtension::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 comget_object_vars(). strcoll()e a flagSORT_LOCALE_STRING. A recomendação é usar a classeCollatorda extensão intl.- Terceiro argumento de
define(), e chamaris_a()ouis_subclass_of()com nome de classe em string quando$allow_stringéfalse. - Mais de 16 filtros numa URL
php://filtersem configurar a opção de contextofilter.max_filter_count. - Handlers de sessão customizados que não implementam
create_sid()evalidateId(). metaphone(),mysqli_get_charset(),mysqli_stmt_init(), os métodos de CSV doSplFileObjecte os métodos de ordenação, flags e serialização doArrayIterator.
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:
- 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.
- 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.
- Ligue
E_DEPRECATEDno 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. - Faça um grep pelos suspeitos de sempre:
returndentro definally,mb_ereg,is_double,spl_object_hash,strcolle qualquerfunction clampglobal. - 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.
- 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