# PHP 8.0 a 8.5: as principais novidades

> Novidades do PHP 8 de 8.0 a 8.5: funcionalidades por versão, exemplos de código, descontinuações com risco de upgrade e impacto na segurança.

Fonte: https://phpsos.de/pt/php/php-8-neuerungen/  
Atualizado em: 25/10/2026  
Prestador: PHP SOS, Assistência de emergência PHP e segurança de servidores. Ajuda imediata por WhatsApp: https://wa.me/491736494914?text=Ol%C3%A1%2C%20PHP%20SOS%2C%20precisamos%20de%20ajuda%20com%20o%20nosso%20servidor%20PHP.%20Empresa%3A%20%E2%80%A6%20Site%3A%20%E2%80%A6

**Em resumo:** O PHP 8.0 (novembro de 2020) trouxe argumentos nomeados, atributos, tipos união, `match`, o operador nullsafe e um compilador JIT. Seguiram-se anualmente: a 8.1 com enums e fibers, a 8.2 com classes readonly, a 8.3 com constantes de classe tipadas, a 8.4 com property hooks e a 8.5 com operador pipe e extensão URI. Cada versão também descontinua coisas antigas. No upgrade, por isso, contam os testes e, para a segurança, conta sobretudo operar um ramo suportado com o nível de patches atual.

## As novidades do PHP 8 em resumo

A tabela resume os pontos principais das páginas de lançamento do php.net. Datas da primeira publicação segundo o php.net.

| Versão | Lançada | Principais novidades | Seleção de descontinuações e quebras |
|---|---|---|---|
| 8.0 | 26/11/2020 | argumentos nomeados, atributos, constructor property promotion, tipos união, `match`, `?->`, JIT | `0 == 'foobar'` é agora `false`, erros de tipo em vez de avisos |
| 8.1 | 25/11/2021 | enums, propriedades readonly, first-class callables `strlen(...)`, `new` em inicializadores, tipos interseção, `never`, fibers | – |
| 8.2 | 08/12/2022 | classes readonly, tipos DNF, `null`/`false`/`true` como tipos, extensão Random, constantes em traits, `#[\SensitiveParameter]` | propriedades dinâmicas descontinuadas |
| 8.3 | 23/11/2023 | constantes de classe tipadas, `#[\Override]`, `json_validate()`, `mb_str_pad()`, `php -l` para vários ficheiros | – |
| 8.4 | 21/11/2024 | property hooks, visibilidade assimétrica, `#[\Deprecated]`, nova API DOM com HTML5, `BcMath\Number`, `array_find()`, lazy objects | parâmetros implicitamente nullable descontinuados; IMAP, OCI8, PDO_OCI, pspell para o PECL |
| 8.5 | 20/11/2025 | operador pipe, extensão URI, clone with, `#[\NoDiscard]`, `array_first()`/`array_last()` | operador backtick descontinuado, `disable_classes` removido |

## PHP 8.0 e 8.1: o grande passo

O PHP 8.0 tornou a linguagem claramente mais estrita e expressiva. Segundo a página de lançamento, as funções internas lançam agora de forma consequente `TypeError` ou `ValueError`, em vez de apenas emitirem avisos. As comparações entre números e cadeias de carateres seguem regras mais limpas.

```php
<?php
// PHP 8.0: match compara de forma estrita e não precisa de break
$status = 404;
echo match (true) {
    $status >= 500 => 'Serverfehler',
    $status >= 400 => 'Anfragefehler',
    default        => 'in Ordnung',
};

// PHP 8.0: operador nullsafe
$land = $bestellung?->kunde?->adresse?->land;
```

O PHP 8.1 trouxe enums, ou seja, tipos de enumeração com valores fixos, e propriedades readonly, que só podem ser definidas uma vez:

```php
<?php
enum Rolle: string {
    case Leser = 'leser';
    case Redakteur = 'redakteur';
    case Admin = 'admin';
}

final class Benutzer {
    public function __construct(
        public readonly string $name,
        public readonly Rolle $rolle,
    ) {}
}

$b = new Benutzer('Erika', Rolle::from('redakteur'));
```

`Rolle::from()` lança um erro perante valores desconhecidos. Isto impede que cadeias de carateres arbitrárias de formulários passem como papel. Quem precisa de um valor vazio em vez de um erro usa `Rolle::tryFrom()`, que devolve `null` para valores desconhecidos.

Também novas no 8.1 são as fibers, uma base para fluxos concorrentes sobre a qual assentam bibliotecas de processamento assíncrono. Na operação normal de um site nota-se pouco, mas em frameworks modernos e em filas já se nota.

## PHP 8.2 e 8.3: arrumar e proteger

O PHP 8.2 descontinuou as propriedades dinâmicas. Quem atribui a um objeto uma propriedade não declarada recebe um aviso; com `#[\AllowDynamicProperties]` isso pode ser permitido em classes individuais. Plugins mais antigos geram por isso muitas vezes muitas mensagens no log.

Interessantes para a segurança são a nova extensão Random, cujo randomizer por defeito usa, segundo a página de lançamento, um gerador de números aleatórios criptograficamente seguro, e o atributo `#[\SensitiveParameter]`, que oculta valores como palavras-passe em stack traces. Mais sobre valores aleatórios seguros em [Números aleatórios e tokens seguros em PHP](https://phpsos.de/pt/blog/sichere-tokens-php/).

O PHP 8.3 acrescentou constantes de classe tipadas, o atributo `#[\Override]` contra erros de escrita ao sobrescrever métodos e `json_validate()`, que verifica JSON sem o descodificar por completo.

## PHP 8.4 e 8.5: recursos de linguagem modernos

O PHP 8.4 introduziu property hooks, isto é, lógica diretamente nas propriedades, e visibilidade assimétrica como `public private(set)`. A isso juntaram-se uma nova API DOM com suporte a HTML5 e funções como `array_find()`, `array_any()` e `array_all()`. Segundo a página de lançamento, as extensões IMAP, OCI8, PDO_OCI e pspell foram movidas do núcleo para o PECL. As aplicações que usam, por exemplo, o IMAP precisam então de um pacote separado.

O PHP 8.5 trouxe o operador pipe, que encadeia chamadas da esquerda para a direita:

```php
<?php
$slug = '  Neue Produkte 2026  '
    |> trim(...)
    |> strtolower(...)
    |> (fn(string $s): string => str_replace(' ', '-', $s));
// Resultado: "neue-produkte-2026"
```

Nova é também uma extensão URI que decompõe endereços segundo o RFC 3986 e o padrão WHATWG URL. Isto é relevante para a segurança, porque URL analisados de forma inconsistente são uma causa conhecida de verificações contornadas. O operador backtick, como forma abreviada de `shell_exec()`, está descontinuado e a definição `disable_classes` foi removida. Quem a utilizava deve ajustar o seu reforço.

## Novidades, upgrades e PHP2Shell

As novas funcionalidades de linguagem não fecham falhas no interpretador. Contra o PHP2Shell só ajuda o nível de patches atual do respetivo ramo: 8.5.12, 8.4.27, 8.3.36 ou 8.2.35. Para o PHP 8.1 e 8.0 já não existem atualizações oficiais. Quem aí está preso tem de fazer upgrade e, nisso, as novidades ajudam pouco, as quebras muito.

Um caminho de upgrade seguro em cinco passos:

1. Definir a versão de destino, adequada aos requisitos de sistema do fabricante e ao [ciclo de lançamentos](https://phpsos.de/pt/php/release-zyklus/).
2. Levar as dependências do Composer e os plugins para versões compatíveis.
3. Verificar o código com análise estática e testes contra a versão de destino.
4. Experimentar num ambiente de teste com uma cópia dos dados de produção e avaliar nos logs as descontinuações.
5. Mudar, reiniciar todos os processos PHP e documentar o estado.

Antecedentes sobre tipos fornece [O sistema de tipos do PHP](https://phpsos.de/pt/php/typsystem/).

## Como ajuda concretamente a PHP SOS?

- **Verificar a compatibilidade:** Analisamos o seu código e as suas extensões à procura de quebras relativamente à versão de destino.
- **Executar o upgrade:** Com a [migração para uma versão do PHP suportada](https://phpsos.de/pt/leistungen/php-migration-legacy/) elevamos as aplicações de forma testada.
- **Ajustar o reforço:** Substituímos definições removidas, como `disable_classes`, por alternativas eficazes.
- **Manter o nível de patches:** Depois do upgrade, mantemos o ramo atualizado e comprovamos cada reinício.


## Perguntas frequentes

**Que versão do PHP 8 devo usar hoje?**  
Para novos projetos, PHP 8.4 ou 8.5, porque são as que ficam suportadas durante mais tempo: a 8.4 até ao fim de 2028, a 8.5 até ao fim de 2029. O decisivo é o que a sua aplicação suporta segundo os requisitos de sistema do fabricante. O PHP 8.2 termina a 31 de dezembro de 2026.

**O que costuma falhar mais na passagem do PHP 7.4 para o PHP 8?**  
Muitas vezes são as verificações de tipos mais estritas: no PHP 8, as funções internas lançam TypeError ou ValueError em vez de apenas emitirem avisos. Também se notam as comparações alteradas entre números e cadeias de carateres. A análise estática e os testes revelam a maior parte com antecedência.

**O JIT torna o meu site mais rápido?**  
Na maior parte dos casos, pouco. Segundo a página de lançamento do PHP 8.0, o desempenho de aplicações web típicas fica aproximadamente ao nível do PHP 7.4, enquanto tarefas de cálculo intensivo podem beneficiar claramente. Desde o PHP 8.4, o JIT está desligado por defeito.

**Que novidades ajudam a segurança?**  
Entre outras, a nova extensão Random no PHP 8.2 com um padrão criptograficamente seguro, o atributo SensitiveParameter contra palavras-passe em stack traces, enums e propriedades readonly para dados mais inequívocos, bem como os erros de tipo mais consequentes desde o PHP 8.0.

## Fontes

- [php.net: lançamento do PHP 8.0](https://www.php.net/releases/8.0/en.php)
- [php.net: lançamento do PHP 8.4](https://www.php.net/releases/8.4/en.php)
- [php.net: lançamento do PHP 8.5](https://www.php.net/releases/8.5/en.php)
- [ChangeLog do PHP 8](https://www.php.net/ChangeLog-8.php)
- [php.net: versões suportadas](https://www.php.net/supported-versions.php)