Lançado PHP 8.2 veja as novidades

O PHP 8.2 é uma grande atualização da linguagem PHP. Ela contém muitos recursos novos, incluindo classes somente leitura, null, false e true como tipos autônomos, propriedades dinâmicas obsoletas, melhorias de desempenho e muito mais.

Vamos ao novo PHP 8.2

Classes somente leitura

<?php

// PHP < 8.2
class BlogData
{
    public readonly string $title;

    public readonly Status $status;

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

// PHP 8.2
readonly class BlogData
{
    public string $title;

    public Status $status;

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

Funcionalmente, tornar uma classe somente leitura é o mesmo que tornar todas as propriedades somente leitura; mas também impedirá que propriedades dinâmicas sejam adicionadas a uma classe.

Observe que você só pode estender de classes somente leitura se a classe filha também for somente leitura.

O PHP mudou bastante e as classes somente leitura são uma adição bem-vinda. Você também pode dar uma olhada no meu vídeo sobre a evolução do PHP.

Tipos de forma normal disjuntiva – DNF

<?php

// PHP < 8.2
class Foo {
    public function bar(mixed $entity) {
        if ((($entity instanceof A) && ($entity instanceof B)) || ($entity === null)) {
            return $entity;
        }

        throw new Exception('Invalid entity');
    }
}

// PHP 8.2
class Foo {
    public function bar((A&B)|null $entity) {
        return $entity;
    }
}

O Disjunctive Normal Form (DNF) é uma forma padronizada de organizar expressões booleanas. Ela consiste em uma disjunção de conjunções – em termos booleanos, que é um OR de AND.

Os tipos DNF permitem combinar os tipos união e interseção, seguindo uma regra estrita: ao combinar os tipos união e interseção, os tipos de interseção devem ser agrupados entre colchetes. Na prática, fica assim:

<?php

// Veja mais um exemplo

function generateSlug((HasTitle&HasId)|null $post) 
{
    if ($post === null) {
        return '';
    }

    return 
        strtolower($post->getTitle()) 
        . $post->getId();
}

Neste caso, é o tipo DNF.(HasTitle&HasId)|null

É uma boa adição, especialmente porque significa que agora podemos ter tipos de interseção anuláveis, que provavelmente é o caso de uso mais importante para esse recurso.

O PHP 8.2 aborda várias deficiências e restrições do sistema de tipo do PHP, permitindo que os aplicativos PHP desfrutem de melhor segurança de tipo. Isso inclui adicionar suporte para truetype e permitir que tipos nulle falsesejam usados ​​como tipos autônomos e suporte para tipos DNF.

O PHP 8.2 suporta tipos Disjoint Normal Form (DNF) — Agora é possível combinar tipos de união (PHP 8.0) e tipos de interseção (PHP 8.1) , tornando possível declarar parâmetros precisos e expressivos, retorno e tipos de propriedade.

Permitir null, false e true como tipos autônomos

<?php

// PHP < 8.2

class Falsy
{
    public function almostFalse(): bool { /* ... */ *}

    public function almostTrue(): bool { /* ... */ *}

    public function almostNull(): string|null { /* ... */ *}
}

// PHP 8.2

class Falsy
{
    public function alwaysFalse(): false { /* ... */ *}

    public function alwaysTrue(): true { /* ... */ *}

    public function alwaysNull(): null { /* ... */ *}
}

Com o PHP 8.0, os usuários receberam suporte para Union Types. Você pode declarar um tipo como uma união de dois ou mais tipos. Mesmo que você pudesse usar false e null como tipos possíveis, não era permitido usá-los como tipos autônomos.

Com o PHP 8.2, será possível usar false e null como tipos autônomos. Com esta adição, o sistema de tipos do PHP será mais descritivo, pois você poderá declarar com mais precisão os tipos de retorno, parâmetro e propriedade.

Exemplos comuns são as funções internas do PHP, onde false é usado como o tipo de retorno para quando ocorre um erro. Por exemplo em file_get_contents:

<?php

file_get_contents(/* … */): string|false

Antes do PHP 8.2, você já podia usar false junto com outros tipos como uma união; mas agora também pode ser usado como um tipo autônomo:

<?php

function alwaysFalse(): false
{
    return false;
}

O mesmo agora vale para true e null.

Nova extensão aleatória

O PHP 8.2 adiciona um novo gerador de números aleatórios que corrige muitos problemas com o anterior: é mais eficiente, mais seguro, mais fácil de manter e não depende do estado global; eliminando uma série de bugs difíceis de detectar ao usar as funções aleatórias do PHP.

Há uma nova classe chamada Randomizer, que aceita um mecanismo aleatório. Agora você pode mudar esse motor, dependendo de suas necessidades. Por exemplo, para diferenciar entre um ambiente de produção e de teste.

<?php

$rng = $is_production
    ? new Random\Engine\Secure()
    : new Random\Engine\Mt19937(1234);
 
$randomizer = new Random\Randomizer($rng);
$randomizer->shuffleString('foobar');

Ao longo da história do PHP, ele suportou vários Geradores de Números Aleatórios (RNG) com vários graus de desempenho, casos de uso e ajuste para aplicativos seguros. O PHP 8.2 dá um passo adiante ao refatorar todas as funcionalidades relacionadas ao RNG para uma nova extensão chamada random.

A random extensão fornece a mesma funcionalidade sem interromper nenhuma API, portanto, as funções , rand, e existentes continuam a funcionar sem alterações. Ele também fornece uma nova API OOP para gerar números aleatórios com uma arquitetura conectável, portanto, agora é fácil zombar do RNG e fornecer novos RNGs, tornando os aplicativos PHP seguros e fáceis de testar. mt_rand , random_bytes , random_int

Constantes em traços

<?php

// PHP 8.2

trait Foo
{
    public const CONSTANT = 1;
}

class Bar
{
    use Foo;
}

var_dump(Bar::CONSTANT); // 1
var_dump(Foo::CONSTANT); // Error

Você não pode acessar a constante pelo nome da constante, mas pode acessar a constante pela classe que usa a constante.

No PHP 8.2, agora é possível declarar constantes em traits . As características não podem ser acessadas diretamente, mas essas constantes tornam-se constantes de classe quando uma classe usa a constante.

<?php

trait FooBar {
    const FOO = 'foo';
    private const BAR = 'bar';
    final const BAZ = 'baz';
    final protected const QUX = 'qux';
}

class Test {
    use FooBar;
}

echo Test::BAZ; // 'bar'

Isso não era permitido no PHP 8.1 e anteriores. Constantes não podem ser acessadas diretamente (ou FooBar::FOO seja, não são permitidas). As constantes de trait também não devem colidir com outros trait ou com a classe imediata que os usa.

Reduzindo parâmetros sensíveis em Back-Trace

Como quase qualquer linguagem de programação, o PHP permite rastrear sua pilha de chamadas em qualquer ponto da execução do código. O rastreamento da pilha facilita a depuração do código para corrigir erros e gargalos de desempenho.

A execução de um rastreamento de pilha não impede a execução do programa. Normalmente, a maioria dos traços de pilha são executados em segundo plano e são registrados silenciosamente – para inspeção posterior, se necessário.

Entretanto, alguns desses traços detalhados da pilha PHP podem ser um inconveniente se você os compartilhar com serviços de terceiros – geralmente para análise de registros de erros, rastreamento de erros, etc. Esses traços de pilha podem incluir informações sensíveis, como nomes de usuário, senhas e variáveis de ambiente.

O PHP 8.2 permite que você marque esses parâmetros sensíveis com um novo atributo \SensitiveParameter. Qualquer parâmetro marcado como sensível não será listado no seu backtraces. Assim, você pode compartilhá-los sem preocupações com qualquer serviço de terceiros.

Aqui está um exemplo simples com um único parâmetro sensível:

<?php

function example(
    $ham,
    #[\SensitiveParameter] $eggs,
    $butter
) {
    throw new \Exception('Error');
}

example('ham', 'eggs', 'butter');

/*
Fatal error: Uncaught Exception: Error in test.php:8
Stack trace:
#0 test.php(11): test('ham', Object(SensitiveParameterValue), 'butter')
#1 {main}
thrown in test.php on line 8
*/

Quando você gera um backtrace, qualquer parâmetro com o atributo \SensitiveParameter será substituído por um objeto \SensitiveParameterValue, e seu valor real nunca será armazenado no traço. O objeto SensitiveParameterValue encapsula o valor real do parâmetro – se você precisar dele por qualquer razão.

Outro exemplo:

<?php

function login(
    string $user,
    #[\SensitiveParameter] string $password
) {
    // …
    
    throw new Exception('Error');
}
 
login('root', 'root');

/* 
Fatal error: Uncaught Exception: Error in login.php:8
Stack trace:
#0 login.php(11): login('root', Object(SensitiveParameterValue))
#1 {main} thrown in login.php on line 8
*/

Com a marcação de “parâmetros sensíveis” com um atributo, você não precise se preocupar com eles sendo listados em seus rastreamentos de pilha quando algo der errado.

Melhorias nos enums

Quando os enums foram introduzidos, era impossível buscar as propriedades name e value de um enum em uma expressão constante. Resumimos alguns casos de expressões constantes em que esse foi o caso:

<?php

class Post
{
    #[DefaultValue(Status::Draft->name)]
    public string $status = Status::Draft->name;

    public function updateStatus(string $status = Status::Draft->name): void
    {
        /** … */
    }
}

const STATUS = Status::Draft->name;

Esta RFC propõe permitir que o operador -> / ?-> busque enum propriedades nas expressões const.

A principal razão para este novo recurso é que você não pode usar enum objetos em alguns lugares, como chaves de array. Em tal caso, você terá que repetir o valor do caso enum apenas para usá-lo.

Permitir a busca de propriedades enum em lugares onde enum objetos não são permitidos pode simplificar este procedimento.

<?php

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

E só por segurança, este RFC também inclui suporte para o operador nullsafe ?->

Depreciações no PHP 8.2

O PHP 8.2 também traz uma boa quantidade de depreciações. Quando uma sintaxe, função ou recurso é obsoleto, o PHP emite um aviso de descontinuação que não deve interromper ou configurar corretamente os aplicativos PHP, mas é registrado no log de erros.

Observe que, desde o PHP 8.0, a configuração de relatório de erros padrão do PHP é definida comoE_ALL.

Propriedades dinâmicas obsoletas

Uma das reprovações mais notáveis ​​no PHP 8.2 é que ele descontinua propriedades de classe que são declaradas dinamicamente . Existe uma opção de exclusão, mas a abordagem recomendada é declarar as propriedades de classe na declaração de classe, de preferência com uma declaração de tipo também.

// PHP 8.2

class User {
    public int $uid;
}

$user = new User();
$user->name = 'Foo';

// Saída:
// Deprecated: Creation of dynamic property User::$name is deprecated in ... on

É provável que muitos aplicativos PHP herdados sejam afetados por essa mudança, porque os aplicativos legados tendem a não declarar propriedades de classe quando são estendidos ou evoluídos ao longo dos anos com alterações.

A correção recomendada é declarar as propriedades na classe:

// PHP 8.2

class User {
   public int $uid;
   public string $name; 
}

$user = new User();
$user->name = 'Foo';

utf8_encode e utf8_decode funções obsoletas

O PHP 8.2 finalmente deprecia as funções utf8_encode e utf8_decode que infelizmente foram nomeadas sem notar que elas apenas codificam/decodificam de Latin 1(ISO-8859-1).

A maioria dos aplicativos PHP que usam essas funções tende a não estar ciente dessa deficiência. As substituições recomendadas incluem a melhor funcionalidade fornecida por extensões: mbstring, iconv e intl.

${var} Interpolação de string obsoleta

O PHP sempre deu suporte à interpolação de variável de string com ” foo {$bar} “ padrão e junto com uma sintaxe alternativa em que o cifrão é colocado fora das chaves (por exemplo ” foo ${bar} “ , ).

No PHP 8.2, a sintaxe alternativa de colocar o cifrão fora das chaves é obsoleta.

As funções strtolower e strtoupper não são mais sensíveis à localidade

Ambos strtolower() e strtoupper() não são mais sensíveis à localidade.

Você pode usar mb_strtolower() se quiser conversão de maiúsculas e minúsculas.

Para acessar todas a novidades na integra acesse https://www.php.net/ChangeLog-8.php#PHP_8_2