PHP

Explorando as novidades do PHP 8.2: Recursos e melhorias

Carlos Eduardo Dias

• 8 min read
Explorando as novidades do PHP 8.2: Recursos e melhorias

Dando continuidade ao artigo anterior sobre as atualizações do PHP, vamos aprofundar nossa análise nas novidades e melhorias da versão 8.2, a qual foi lançada em 8 de Dezembro de 2022.

Essa nova versão traz consigo uma série de inovações e funcionalidades, notáveis entre elas estão as classes somente leitura, a introdução de null, false e true como tipos independentes, e a depreciação das propriedades dinâmicas, além de muitas outras melhorias significativas.

É importante também enfatizar a importância que a performance tem para os usuários no uso da linguagem PHP para a criação de sistemas.

Como sempre, a performance é uma área que recebeu atenção especial nesta nova versão, e você pode conferir os resultados do benchmark neste link.

Convido você a aproveitar a leitura para se manter atualizado sobre as novas funcionalidades e aprimoramentos trazidos pela versão 8.2 do PHP.


Novos recursos

Readonly classes

Na nova versão, uma classe pode ser marcada com o modificador readonly, introduzindo um recurso significativo no PHP.

Ao marcar uma classe como readonly, o modificador readonly é aplicado a todas as propriedades declaradas dentro dessa classe, o que, por sua vez, impede a criação de propriedades dinâmicas.

O uso do modificador readonly é particularmente útil quando a imutabilidade é necessária.

Isso significa que, uma vez que os valores das propriedades são definidos, eles não podem ser alterados posteriormente. Isso adiciona uma camada de segurança e integridade aos dados contidos na classe.

Uma característica importante a ser observada é que, ao marcar uma classe como readonly, é impossível adicionar suporte para propriedades dinâmicas usando o atributo AllowDynamicProperties. Isso garante que a imutabilidade seja mantida e que as propriedades não possam ser modificadas ou adicionadas aleatoriamente durante a execução do programa.

A utilização de classes read-only no PHP pode ser vantajosa em várias situações.

Algumas das razões pelas quais você pode considerar o uso de uma classe read-only incluem:

  1. Imutabilidade de Dados: Quando se deseja garantir que os dados contidos na classe permaneçam inalterados após a inicialização.
  2. Segurança e Integridade: Para evitar modificações acidentais ou maliciosas nas propriedades da classe, garantindo a integridade dos dados.
  3. Facilidade de Rastreamento: Para simplificar o rastreamento e depuração de erros, uma vez que as propriedades não mudam durante a execução.
  4. Padrões de Design: Em conformidade com padrões de design que requerem imutabilidade, como o Princípio da Responsabilidade Única (SRP - uma classe deve ter somente uma responsabilidade, ou seja, deve ser responsável por executar apenas uma tarefa) e o Princípio da Substituição de Liskov (LSP - as subclasses devem poder ser usadas de forma intercambiável com suas superclasses sem comprometer a integridade).

Em resumo, a capacidade de marcar uma classe como readonly no PHP oferece uma solução valiosa para garantir a imutabilidade de dados e reforçar a segurança e a integridade do código. Isso pode ser particularmente útil em cenários nos quais a modificação dos dados deve ser estritamente controlada e monitorada.

Sintaxe da classe Read-only

Em versões anteriores, uma classe poderia ser definida como no código que segue:

class BlogData
{
    public readonly string $title;

    public readonly Status $status;

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

Definindo a mesma classe como read-only é fácil na nova versão:

readonly class BlogData
{
    public string $title;

    public Status $status;

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


Disjunctive Normal Form (DNF) Types

A adição dos tipos DNF (Disjunctive Normal Form) representa um avanço importante na flexibilidade da linguagem. Esses tipos permitem a combinação de tipos de união e interseção, proporcionando uma abordagem dinâmica e poderosa para a definição de parâmetros de função.

Ao incorporar tipos DNF em suas assinaturas de função, agora ganhamos a capacidade de tornar essas assinaturas mais dinâmicas e adaptáveis. A flexibilidade resultante é muito importante em um contexto de linguagem de programação com tipagem dinâmica como o PHP, onde a definição estrita dos tipos pode ser menos utilizada.

Essa funcionalidade oferece a oportunidade de especificar uma variedade de tipos de dados que um parâmetro pode aceitar, o que, por sua vez, aprimora a modularidade do código e facilita a reutilização de funções em diferentes contextos.

A capacidade de utilizar tipos DNF em PHP proporciona uma maior expressividade nas assinaturas de função, tornando o código mais claro e conciso. Além disso, ela contribui para a legibilidade do código, refletindo de forma precisa os requisitos do programa.

Portanto, a incorporação de tipos DNF no PHP não apenas aprimora a flexibilidade da linguagem, mas também fortalece a adaptabilidade do código, proporcionando aos desenvolvedores uma ferramenta poderosa para criar funções mais dinâmicas e versáteis.

Em versões anteriores, se fosse preciso permitir parâmetros de vários tipos de variável ao mesmo tempo, era necessário algo como segue:

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

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


Agora, é possível determinar diretamente no parâmetro quais são os tipos aceitos:

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


Assim, definimos que o parâmetro $entity pode ser dos tipos A e B ou do tipo null.

Essa é uma ótima forma de aumentar a flexibilidade e reutilização do código.

Allow null, false, and true as stand-alone types

Uma mudança significativa na nova versão do PHP diz respeito à definição do retorno de métodos. Anteriormente, era necessário especificar o retorno como bool ou opcional null.

Agora, com a atualização, foi adicionada a possibilidade de definir o retorno diretamente como null, false ou true. Essa alteração simplifica a definição de retornos de métodos, tornando o código mais legível e conciso.

Essas melhorias contribuem para a adaptabilidade do PHP e aprimoram a experiência de desenvolvimento. Ao permitir que os desenvolvedores expressem suas intenções de forma mais clara e concisa, o PHP se torna uma linguagem mais flexível e poderosa para a criação de aplicativos dinâmicos e eficazes. Portanto, a incorporação de tipos DNF e as melhorias na definição de retornos de métodos representam avanços significativos na evolução do PHP.

Versões anteriores à 8.2:

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

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

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


Na versão atual podemos fazer como segue:

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

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

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


Assim, o código fonte torna-se mais legível e mais claro, aproveite a nova funcionalidade!

Constants in traits

Traits são tipos especiais de classes introduzidos na versão 5.4.

São amplamente reconhecidas por sua capacidade de promover a reutilização de código fonte entre classes que não compartilham uma relação hierárquica direta. Isso se traduz em uma abordagem eficaz para manter o código fonte conciso e altamente reutilizável, aprimorando a modularidade e a manutenção do código.

Uma inovação importante na versão mais recente é a capacidade de incorporar constantes dentro das Traits. Isso é importante, pois permite que informações imutáveis e críticas sejam registradas diretamente no contexto da Trait.

Constantes podem ser usadas para definir valores que não devem ser alterados durante a execução do programa, o que contribui para a clareza do código e a garantia de integridade dos dados.

É importante ressaltar que a acessibilidade dessas constantes tem uma particularidade. Elas não podem ser acessadas diretamente pelo nome da Trait em si. Em vez disso, a referência a essas constantes deve ser feita através de uma classe que incorpora a Trait em questão. Esse design ajuda a evitar conflitos de nomes e a garantir que as constantes sejam utilizadas de forma adequada e contextualmente correta.

Essa adição de constantes em Traits oferece uma maneira mais organizada e segura de armazenar informações essenciais e não modificáveis, contribuindo para um código mais robusto e de fácil manutenção.

trait Foo
{
    public const CONSTANT = 1;
}

class Bar
{
    use Foo;
}

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



Deprecate dynamic properties

A depreciação de recursos em uma linguagem de programação desempenha um papel fundamental na melhoria da qualidade do código e na orientação dos desenvolvedores para boas práticas. Ela é uma estratégia crucial para fazer com que os desenvolvedores planejem e projetem de maneira mais cuidadosa a estrutura do sistema em desenvolvimento.

Em versões mais recentes, como na nova versão, um exemplo de depreciação importante diz respeito à tentativa de criar uma nova propriedade que não foi previamente definida na classe. Agora, quando os desenvolvedores tentam criar uma propriedade não declarada na classe, um warning de depreciação é emitido. Esse aviso tem o propósito de sinalizar que a prática de adicionar propriedades dinamicamente está se tornando obsoleta, incentivando os desenvolvedores a adotar uma abordagem mais estruturada e cuidadosa ao projetar suas classes.

A importância dessa depreciação está ligada à promoção de melhores práticas de programação e à prevenção de erros que podem surgir quando se criam propriedades dinamicamente sem planejamento prévio. Essa mudança ajuda a fortalecer a qualidade do código, tornando-o mais seguro, legível e fácil de dar manutenção.

Em resumo, a introdução de avisos de depreciação, como no caso da criação de propriedades não definidas em classes, é uma abordagem eficaz para orientar os desenvolvedores em direção à escrita de código mais estruturado e robusto, contribuindo para a evolução contínua da linguagem de programação e para a melhoria da qualidade do software.

class User
{
    public $name;
}

$user = new User();
$user->last_name = 'Doe'; // Deprecated notice

$user = new stdClass();
$user->last_name = 'Doe'; // Still allowed


Essa atualização não afeta o uso de getters e setters.

Ainda é possível utilizar propriedades dinâmicas utilizando a anotação #[\AllowDynamicProperties].

Novas classes, interfaces e funções

Foram incluídas novas classes, interfaces e funções que você pode conferir abaixo:

  1. Nova função mysqli_execute_query e método mysqli::execute_query.
  2. Novos atributos #[\AllowDynamicProperties] e #[\SensitiveParameter].
  3. Novos métodos ZipArchive::getStreamIndex, ZipArchive::getStreamName e ZipArchive::clearError.
  4. Novos métodos ReflectionFunction::isAnonymous e ReflectionMethod::hasPrototype.
  5. Novas funções curl_upkeep, memory_reset_peak_usage, ini_parse_quantity, libxml_get_external_entity_loader, sodium_crypto_stream_xchacha20_xor_ic, openssl_cipher_key_length.


Depreciações e quebras de compatibilidade retroativa

Seguem algumas depreciações e quebras de compatibilidade dessa versão:

  1. Descontinuado a interpolação de string ${}.
  2. Funções utf8_encode e utf8_decode foram descontinuadas.
  3. Os métodos DateTime::createFromImmutable e DateTimeImmutable::createFromMutable têm um tipo de retorno tentativo como estático.
  4. As extensões ODBC e PDO_ODBC agora escapam o nome de usuário e senha.
  5. As funções strtolower e strtoupper não são mais sensíveis ao local.
  6. Os métodos SplFileObject::getCsvControl, SplFileObject::fflush, SplFileObject::ftell, SplFileObject::fgetc e SplFileObject::fpassthru agora impõem sua assinatura.
  7. O método SplFileObject::hasChildren tem um tipo de retorno tentativo de false.
  8. O método SplFileObject::getChildren tem um tipo de retorno tentativo de null.
  9. O método interno SplFileInfo::_bad_state_ex foi descontinuado.

Conclusão

A nova atualização representa um marco significativo no aprimoramento do PHP, oferecendo melhorias substanciais em termos de desempenho e funcionalidades que beneficiam tanto os desenvolvedores quanto os projetos em desenvolvimento.

Essas mudanças não apenas otimizam a execução de códigos existentes, mas também promovem práticas de programação mais estruturadas e a reutilização eficiente de código.

As melhorias de performance ajudam a acelerar a execução de scripts e aplicativos, tornando o PHP ainda mais eficiente em seu processamento. Isso se traduz em tempos de resposta mais rápidos e uma experiência mais ágil para os usuários finais.

Além disso, as novas funcionalidades, como a capacidade de adicionar tipos DNF (Disjunctive Normal Form) e os avisos de depreciação, facilitam a escrita de código de alta qualidade. Elas incentivam os desenvolvedores a planejarem e estruturarem suas classes e funções de forma mais cuidadosa, promovendo a coesão, a modularidade e a reutilização de código.

Se você deseja obter uma visão mais detalhada das modificações específicas da nova versão, recomendo visitar o site oficial da release. Lá, você encontrará documentação detalhada e notas de lançamento que aprofundam cada alteração e funcionalidade introduzida.

Espero que este resumo tenha sido informativo e útil.

A atualização do PHP é uma ótima oportunidade para melhorar a qualidade e o desempenho do seu código.

Obrigado por acompanhar este artigo e até a próxima!

💡
As opiniões e comentários expressos neste artigo são de propriedade exclusiva de seu autor e não representam necessariamente o ponto de vista da Revelo.

A Revelo Content Network acolhe todas as raças, etnias, nacionalidades, credos, gêneros, orientações, pontos de vista e ideologias, desde que promovam diversidade, equidade, inclusão e crescimento na carreira dos profissionais de tecnologia.