PHP 8.2: O que há de novo?

PHP 8.2 está prestes a ser lançada. Talvez seja a versão que fará com que uma atualização para o PHP 8 pareça apelativa para todos. Vamos falar sobre o que os desenvolvedores podem esperar com o PHP 8.2 e preparar-se para a sua última versão. Mas primeiro, vamos passar rapidamente por todas as versões e alterações do PHP ao longo dos anos.

Visão geral das versões anteriores

PHP 7.4

Propriedades tipificadas

<?php
classe Utilizador {
    public int $id;
    public string $name;
}
?>

Funções de seta

<?php
$factor = 10;
$nums = array_map(fn($n) => $n * $factor, [1, 2, 3, 4]);
// $nums = array(10, 20, 30, 40);
?>

Covariância limitada do tipo de retorno e contravariância do tipo de argumento

<?php
class A {}
classe B extends A {}

class Produtor {
    public function method(): A {}
}
class ChildProducer extends Producer {
    public function method(): B {}
}
?>

Operador de atribuição de coalescência nula

<?php
$array['key'] ??= computeDefault();
// é aproximadamente equivalente a
se (!isset($array['key'])) {
    $array['key'] = computeDefault();
}
?>

Desempacotamento dentro de matrizes

<?php
$partes = ["maçã", "pera"];
$fruits = ['banana', 'laranja', ...$parts, 'melancia'];
// ['banana', 'laranja', 'maçã', 'pera', 'melancia'];
?>

Serialização de objectos personalizada

<?php
// Retorna um array contendo todo o estado necessário do objeto.
public function __serialize(): array;

// Restaura o estado do objeto a partir do array de dados fornecido.
public function __unserialize(array $data): void;
?>

PHP 8.0

Lançado em novembro de 2020, o PHP 8.0 trouxe nós as melhores funcionalidades até à data, que incluem:

Argumentos nomeados

htmlspecialchars($string, double_encode: false); 

Atributos

classe PostsController
{
    #[Route("/api/posts/{id}", methods: ["GET"])]
    public function get($id) { /* ... */ }
}

Promoção da propriedade do construtor

classe Ponto {
  public function __construct(
    public float $x = 0.0,
    public float $y = 0.0,
    public float $z = 0.0,
  ) {}
}

Tipos de União

classe Número {
  public function __construct(
    private int|float $number
  ) {}
}

new Number('NaN'); // TypeError

Expressão de correspondência

echo match (8.0) {
  '8.0' => "Oh não!",
  8.0 => "Isto é o que eu estava à espera",
};
//> Isto é o que eu estava à espera

Operador de segurança nula

$country = $session?->user?->getAddress()?->country;

PHP 8.1

Enumerações

enum Status
{
    case Rascunho;
    case Publicado;
    case Arquivado;
}
function acceptStatus(Status $status) {...}

Propriedades só de leitura

classe BlogData
{
    public readonly Status $status;

    public function __construct(Status $status)
    {
        $this->status = $status;
    }
}

Sintaxe de primeira classe de chamáveis

$foo = $this->foo(...);

$fn = strlen(...);

Novo em inicializadores

classe Serviço
{
    private Logger $logger;

    função pública __construct(
        Logger $logger = new NullLogger(),
    ) {
        $this->logger = $logger;
    }
}

Tipos de intersecções puras

function count_and_iterate(Iterator&Countable $value) {
    foreach ($value as $val) {
        echo $val;
    }

    count($value);
}

Fibras

$response = $httpClient->request('https://example.com/');
print json_decode($response->getBody()->buffer())['code'];

PHP 8.2

PHP 8.2 introduz novas alterações destinadas a facilitar a vida do programador e a otimizar ainda mais o seu trabalho. Segue-se a lista das novas funcionalidades.

Classes só de leitura

Uma das maiores melhorias na nova versão do PHP é a possibilidade de criar diretamente um só de leitura classe. Uma classe descrita com esta caraterística propagá-la-á automaticamente para as suas variáveis. As classes DTO terão agora um aspeto limpo e organizado!

readonly class FacturaDTO
{
    public function __construct(
        public UUID $uuid,
        public Issuer $issuer,
        public DateTime $issuedAt,
    ) {}
}

Eliminar as propriedades dinâmicas

A segunda grande mudança é a depreciação de variáveis dinâmicas em classes. A implementação a seguir lançará uma depreciação em PHP 8.2 e ErroExcepção na futura versão do PHP.

classe MeuUsuário
{
    public string $name;
}
(...)
$euUsuario->nome = 'Nome'; // OK
$myUser->surname = 'Surname'; // depreciado / errorexception

Vale a pena mencionar que as classes que implementam __get e __set métodos e classes que herdam diretamente de stdClass pode ainda implementar métodos mágicos sem quaisquer obstáculos.

Neste ponto, remeto-vos também para um discussão interessante no GitHubonde os programadores do PHP-CS discutem esta alteração e a necessidade de modificar a sua popular ferramenta para a nova versão da linguagem.

Por último, mas não menos importante, pode desativar este comportamento através da Anotação.

#[AllowDynamicProperties]
classe MyUser
{
    public string $name;
}

$myUser->surname = 'Surname'; // OK

Novos tipos autónomos: nulo, verdadeiroe falso

Até agora, as funções que sempre retornavam um verdadeiro ou falso valor tinha de ser descrito com um bool tipo.

function alwaysTrue(): bool { return true; }

A partir de agora, podemos utilizar verdadeiro e falso como tipos simples nos valores devolvidos das funções.

function alwaysTrue(): true { return true; }

Tipos de formas normais disjuntivas

(DNF) é uma forma normalizada de organizar expressões booleanas. Especificamente, significa estruturar uma expressão booleana numa série de ANDs com OR. Quando aplicado a declarações de tipo, permite uma forma padrão de escrever tipos combinados de União e Intersecção que o analisador pode tratar.

É uma grande mudança, pois agora podemos ter tipos de intersecção anuláveis, por exemplo:

function getFullName((HasName&HasSurname)|null $user) { ... }

Constantes em caraterísticas

Não sou um grande defensor da utilização de Traits e essa alteração é puramente cosmética para mim, especialmente porque não permite utilizar valores de Trait sem inicializar o objeto.

trait Foo {
    public const FLAG_1 = 1;
    protected const FLAG_2 = 2;
    private const FLAG_3 = 2;

    public function doFoo(int $flags): void {
        if ($flags & self::FLAG_1) {
            echo 'Apanhei a bandeira 1';
        }
        if ($flags & self::FLAG_2) {
            echo 'Apanhei a bandeira 2';
        }
        if ($flags & self::FLAG_3) {
            echo 'Apanhei a bandeira 3';
        }
    }
}

Redigir parâmetros em registos anteriores

Uma das alterações mais importantes que estou a aguardar com expetativa. Na última versão do PHP, poderemos marcar variáveis como SensitiveParameterValue. Porquê?

Os traços de pilha do PHP nas excepções são muito úteis para a depuração, no entanto, permitem-lhe pré-visualizar os valores dos parâmetros. Por exemplo, imaginemos que o PDO código utilizado para ligar a uma base de dados. O traço de depuração teria o seguinte aspeto:

PDOException: SQLSTATE[HY000] [2002] Não existe tal ficheiro ou diretório em /var/www/html/test.php:3
Stack trace:
#0 /var/www/html/test.php(3): PDO->__construct('mysql:host=loca...', 'root', 'password')
#1 {main}

Depois de utilizar a Anotação #[SensitiveParameter] nosso rastreamento de pilha não mostrará mais o valor da variável.

função test(
    $foo,
    #[SensitiveParameter] $bar,
    $baz
) {
    lançar nova Exceção('Erro');
}

teste('foo', 'bar', 'baz');

/*
Erro fatal: Exceção não detectada: Erro em test.php:8
Rastreamento de pilha:
#0 test.php(11): test('foo', Object(SensitiveParameterValue), 'baz')
#1 {main}
  lançado em test.php na linha 8
*/

Obter propriedades de enums em expressões const

Como o autor diz
A principal motivação para essa mudança é permitir a busca de propriedades de nome e valor em lugares onde objetos enum não são permitidos, como chaves de array. Nós poderíamos trabalhar em arrays para que eles pudessem ser estendidos para permitir enums ou todos os objetos como chaves, mas permitir buscar propriedades de enums é mais simples.

enum A: string {
    case B = 'B';
    const C = [self::B->valor => self::B];
}

Tipos de retorno de funções de data

Anteriormente, os métodos estáticos funcionavam da seguinte forma:

DateTime::createFromImmutable(): DateTime
DateTimeImmutable::createFromMutable(): DateTimeImmutable 

Em PHP 8.2 vai ser alterado para:

DateTime::createFromImmutable(): estático
DateTimeImmutable::criaFromMutable(): estático

Esta é uma alteração de rutura para os criadores de bibliotecas e/ou todas as implementações personalizadas de DateTime.

Depreciar e remover `utf8_encode` e `utf8_decode`

Eram duas funções que não serviam para o efeito, pois apenas convertiam entre ISO-8859-1 e UTF-8. O Manual do PHP sugere a utilização de mb_convert_encoding em vez disso.

Conversão de casos independente da localidade

A sensibilidade da localidade é melhor descrita pelo autor do RFC:

Antes do PHP 8.0, o locale do PHP era definido a partir do ambiente. Quando um usuário instala o Linux, ele pergunta em que idioma você quer que ele esteja. O utilizador pode não apreciar totalmente as consequências desta decisão. Não só define o idioma da interface do utilizador para os comandos integrados, como também altera a forma como a biblioteca C trabalha com as strings. Por exemplo, um utilizador que seleccionasse "Turco" ao instalar o Linux descobriria que as aplicações que chamassem toupper('i') obteriam o I maiúsculo pontilhado (U+0130, "İ").

Em uma era de protocolos padronizados baseados em texto, a linguagem natural é uma aplicação minoritária para a conversão de maiúsculas e minúsculas. Mas mesmo que o utilizador quisesse a conversão de maiúsculas e minúsculas em linguagem natural, seria improvável que obtivesse sucesso com strtolower(). Isso ocorre porque ele processa a string um byte de cada vez, alimentando cada byte para a função tolower() da biblioteca C. Se a entrada for UTF-8, de longe a escolha moderna mais popular, strtolower() vai alterar a string, tipicamente produzindo UTF-8 inválido como saída.

PHP 8.0 parou de respeitar as variáveis de ambiente locale. Assim, o locale é sempre "C" a menos que o utilizador chame explicitamente setlocale(). Isso significa que a maior parte da mudança de compatibilidade com versões anteriores já ficou para trás. Quaisquer aplicações que dependam do locale do sistema para fazer a conversão de maiúsculas e minúsculas de conjuntos de caracteres de 8 bits legados terão sido quebradas pelo PHP 8.0.

Isso significa que todas as funções abaixo farão a conversão de maiúsculas e minúsculas ASCII a partir de PHP.8.2:
strtolower, estrupador, stristr, stripos, strripos, primeiro, ucfirst, ucwords, str_ireplace

Preterir a interpolação de cadeia ${}

No PHP, temos muitas formas de inserir variáveis em cadeias de caracteres:
- Incorporação direta de variáveis ("$foo")
- Chaves fora da variável ("{$foo}")
- Parênteses após o sinal de dólar ("${foo}")
- Variáveis variáveis ("${expr}", equivalente a (string) ${expr})

Para evitar confusões e utilizações incorrectas, estas não funcionarão mais:

"Olá ${world}";
Depreciado: A utilização de ${} em cadeias de caracteres está obsoleta

"Olá ${(mundo)}";
Depreciado: O uso de ${} (variáveis variáveis) em strings está obsoleto

Resumo

Estas não são todas as alterações que PHP 8.2 nos oferecerá. Infelizmente, ainda não conseguimos suporte para tipos genéricos, de acordo com o que Nikita disse, os genéricos monomorfizados adicionariam muita sobrecarga de desempenho, e os genéricos reificados exigem muitas mudanças em toda a base de código. O que é notável, no entanto, é a disciplina e a visão do produto. As alterações introduzidas nas sucessivas versões da língua estão a tornar-se mais claras, e os interessados poderão constatar que PHP está a avançar na direção certa, tanto na área da simplificação da sintaxe como no apoio às novidades. Espero que, já no próximo ano, possamos ver exigível como um tipo válido.