O que há de novo no PHP 8.2: uma visão geral abrangente

PHP, a linguagem de script do lado do servidor amplamente utilizada, está em constante evolução para atender às demandas em constante mudança do desenvolvimento web. O lançamento do PHP 8.2 em novembro de 2022 traz consigo uma série de recursos interessantes, descontinuações importantes e correções de bugs cruciais. Neste artigo, vamos nos aprofundar nos aspectos notáveis ​​do que há de novo no PHP 8.2, esclarecendo o que os desenvolvedores podem esperar desta versão mais recente.

Novas características

1. Enums: Apresentando Segurança de Tipo

Talvez uma das adições mais aguardadas ao PHP, a versão 8.2 finalmente introduz suporte nativo para enumerações (enums). Enums permitem que os desenvolvedores definam um conjunto de valores nomeados com tipos explícitos, adicionando uma camada significativa de segurança de tipo ao PHP.

Aqui está um exemplo simples de como as enums funcionam:

 enum Color { case RED; case GREEN; case BLUE; }

Enums também podem ter valores associados, tornando-os versáteis para vários casos de uso. Esse recurso é particularmente benéfico para garantir que seu código permaneça legível, passível de manutenção e menos sujeito a bugs decorrentes do uso indevido de constantes ou números mágicos.

2. Promoção do Construtor: Reduzindo o Código Padrão

O PHP 8.2 introduz a promoção de construtores, um recurso que visa simplificar as definições de classe e reduzir o código padrão. Com a promoção do construtor, você pode declarar e inicializar propriedades da classe diretamente na lista de parâmetros do construtor. Isso elimina a necessidade de declarações de propriedades separadas, tornando seu código mais conciso e mais fácil de manter.

 class User { public function __construct( public string $name, public string $email, public ?string $bio = null ) {} }

A promoção do construtor é especialmente valiosa ao lidar com classes que possuem muitas propriedades, pois reduz a confusão em sua base de código.

3. Aulas somente leitura

No PHP 8.2, as classes somente leitura permitem que os desenvolvedores definam classes com propriedades que só podem ser definidas uma vez, normalmente durante a criação do objeto. Isso garante que as propriedades permaneçam constantes durante toda a vida útil do objeto. As propriedades somente leitura são declaradas usando o modificador readonly e devem ser inicializadas no construtor da classe.

Com o PHP 8.2, o processo fica totalmente simplificado:

 class ReadOnlyClass $publicpassword , #[\SensitiveParameter] $secretpassword ) { throw new \Exception('Error'); } passwords('publicpassword', 'secretpassword');

4. Argumentos nomeados nas declarações "include" e "require"

No PHP 8.2, argumentos nomeados agora podem ser usados ​​ao incluir ou solicitar arquivos. Esse recurso melhora a legibilidade do código, especialmente ao lidar com funções que aceitam múltiplos argumentos.

 include filename: 'my_file.php', once: true;

Ao fornecer nomes para esses argumentos, você torna seu código mais autoexplicativo e reduz a probabilidade de introdução de erros devido à ordem incorreta dos argumentos.

5. Avisos de descontinuação para parênteses implícitos

Para promover consistência e legibilidade do código, o PHP 8.2 introduz avisos de descontinuação para funções e métodos que são chamados sem parênteses. Embora ainda não seja um erro, isso serve como um aviso aos desenvolvedores para adotarem a prática recomendada de usar parênteses consistentemente ao chamar funções.

 // Deprecated usage myFunction; // Recommended usage myFunction();

Ao desencorajar parênteses implícitos, o PHP visa aumentar a clareza e a capacidade de manutenção do código.

6. Suporte para ocultar valores de parâmetros sensíveis

O PHP fornece a capacidade de monitorar a pilha de chamadas em qualquer estado do programa, o que se mostra especialmente valioso na solução de problemas de aplicativos. No entanto, em certos casos, os rastreamentos de pilha podem conter detalhes confidenciais que justificam a ocultação.

No PHP 8.2, um novo atributo chamado "SensitiveParameter" será introduzido. Este atributo serve para impedir que dados confidenciais sejam exibidos ou registrados quando um aplicativo encontra erros. Em termos práticos, a sua utilização aparecerá da seguinte forma:

 function passwords( $publicpassword , #[\SensitiveParameter] $secretpassword ) { throw new \Exception('Error'); } passwords('publicpassword', 'secretpassword');

7. Introdução da função mysqli_execute_query e do método mysqli::execute_query

PHP, a versátil linguagem de script para desenvolvimento web, evolui continuamente para aprimorar seus recursos e facilidade de uso. No PHP 8.2, os desenvolvedores podem antecipar a introdução de dois novos recursos: a função mysqli_execute_query e o método mysqli::execute_query. Essas adições foram projetadas para agilizar e simplificar as interações com bancos de dados, tornando ainda mais conveniente trabalhar com bancos de dados MySQL.

Função mysqli_execute_query

A função mysqli_execute_query é uma adição poderosa à extensão MySQLi do PHP. Ele é especificamente adaptado para executar consultas SQL em um banco de dados MySQL. Esta função oferece uma maneira simples e eficiente de enviar consultas SQL e recuperar resultados. Aqui está um breve exemplo de seu uso:

 $mysqli = new mysqli("localhost", "username", "password", "database"); $sql = "SELECT * FROM users WHERE status = ?"; $stmt = $mysqli->prepare($sql); $status = "active"; $stmt->bind_param("s", $status); $result = mysqli_execute_query($stmt); while ($row = $result->fetch_assoc()) { } $stmt->close(); $mysqli->close();

A função mysqli_execute_query agiliza o processo de preparação e execução de consultas, mantendo a segurança por meio da ligação de parâmetros.

Método mysqli::execute_query

Além da nova função, o PHP 8.2 introduz o método mysqli::execute_query como parte da classe MySQLi. Este método simplifica a execução de consultas para desenvolvedores que preferem programação orientada a objetos. Aqui está um exemplo de seu uso:

 $mysqli = new mysqli("localhost", "username", "password", "database"); $sql = "SELECT * FROM products WHERE category = ?"; $stmt = $mysqli->prepare($sql); $category = "electronics"; $stmt->bind_param("s", $category); $result = $stmt->execute_query(); while ($row = $result->fetch_assoc()) {} $stmt->close(); $mysqli->close();

O método mysqli::execute_query oferece uma abordagem orientada a objetos para executar consultas de banco de dados, proporcionando uma experiência mais intuitiva para desenvolvedores que preferem esse estilo de codificação.

8. Permitir constantes em características: aprimorando a capacidade de reutilização e manutenção do código

As características são um recurso valioso em linguagens de programação modernas, incluindo PHP, permitindo que os desenvolvedores reutilizem código em diferentes classes sem a necessidade de herança. As características do PHP fornecem principalmente métodos, mas no PHP 8.2, uma melhoria notável é introduzida: a capacidade de definir constantes dentro das características. Este recurso visa melhorar a organização, reutilização e manutenção do código, oferecendo aos desenvolvedores mais flexibilidade no design de seu código.

O papel das características em PHP

Antes de nos aprofundarmos na adição de constantes em traits, vamos revisitar brevemente o papel dos traits no PHP. Traits são um mecanismo para reutilização de código em linguagens de herança única como PHP. Eles permitem definir um conjunto de métodos que podem ser reutilizados em várias classes. Quando uma classe usa uma característica, ela herda os métodos definidos nessa característica, melhorando a modularidade do código e reduzindo a redundância.

 trait Loggable { public function log($message) { }} class User { use Loggable; public function register() { $this->log('User registered.'); }}

Neste exemplo, a característica Loggable fornece um método de log que pode ser usado por qualquer classe que incorpore a característica, melhorando a capacidade de manutenção e organização do código.

Constantes em características: um novo recurso

Com o PHP 8.2, os desenvolvedores agora podem definir constantes dentro de traits, o que não era possível nas versões anteriores do PHP. As constantes nas características funcionam de maneira semelhante às constantes nas classes, mas são acessíveis nas classes que usam a característica.

 trait Configuration {
 const MAX_CONNECTIONS = 10;
 }class Database {
 use Configuration;
 public function connect() { $maxConnections = self::MAX_CONNECTIONS; } }

Neste exemplo, o atributo Configuração define uma constante MAX_CONNECTIONS, que pode ser acessada na classe Database que usa o atributo. Isso permite a centralização das constantes de configuração e promove uma estrutura de código mais organizada e de fácil manutenção.

9. Apresentando novos tipos de forma normal disjuntiva (DNF) no PHP 8.2

PHP, uma linguagem de script dinâmica e versátil, continua a evoluir para atender às crescentes demandas de desenvolvimento web. Com o lançamento do PHP 8.2, os desenvolvedores terão uma surpresa com a introdução de novos tipos de Forma Normal Disjuntiva (DNF). Esta adição à linguagem aumenta a expressividade e flexibilidade do PHP, permitindo que os desenvolvedores trabalhem com expressões lógicas complexas de forma mais eficaz.

Compreendendo a forma normal disjuntiva (DNF)

Antes de nos aprofundarmos nos novos tipos de DNF no PHP 8.2, é essencial entender o que a Forma Normal Disjuntiva (DNF) representa na lógica. DNF é uma forma canônica de representação de expressões lógicas onde cada expressão é uma disjunção (OR) de conjunções (AND). Em termos mais simples, é uma forma de dividir declarações lógicas complexas em uma série de condições simples unidas por operadores OR.

Por exemplo, a expressão lógica (A AND B) OR (C AND D) está em DNF porque é uma disjunção de duas conjunções.

Novos tipos DNF no PHP 8.2

O PHP 8.2 introduz novos tipos DNF como uma forma de trabalhar e manipular expressões lógicas de forma mais intuitiva. Esses tipos DNF fornecem uma abstração de nível superior para lidar com lógica complexa, tornando mais fácil para os desenvolvedores gerenciarem condições complexas em seu código.

Aqui está uma visão geral dos novos tipos de DNF e como eles podem ser usados:

1. DisjuntivoNormalForma

O tipo DisjunctiveNormalForm representa expressões lógicas em DNF. Você pode criar instâncias DisjunctiveNormalForm para encapsular condições complexas:

 $dnfExpression = new DisjunctiveNormalForm(
 new Conjunction('A', 'B'),
 new Conjunction('C', 'D')
 );

Neste exemplo, $dnfExpression representa a expressão DNF (A AND B) OR (C AND D).

2. Conjunção

O tipo Conjunção representa a conjunção (AND) de uma ou mais condições. Você pode criar instâncias de Conjunção para construir conjunções complexas:

 $conjunction = new Conjunction('A', 'B', 'C');

Aqui, $conjunction representa a conjunção (A AND B AND C).

3. Valor Lógico

O tipo LogicalValue representa valores lógicos simples, que podem ser verdadeiros, falsos ou uma variável. Pode ser usado em conjunto com outros tipos de DNF para construir expressões mais complexas:

 $value = new LogicalValue('A');

Aqui, $value representa a variável lógica A.

10. Apresentando o atributo AllowDynamicProperties: Expandindo a flexibilidade em PHP

O atributo “AllowDynamicProperties” é uma adição notável ao PHP, especialmente para desenvolvedores que valorizam a natureza dinâmica da linguagem. Com este atributo, você pode permitir que um objeto aceite e manipule propriedades que não foram explicitamente definidas em sua classe.

Aqui está um exemplo simples de como o atributo "AllowDynamicProperties" pode ser aplicado:

 class DynamicObject {
 }
 $dynamicObj = new DynamicObject();
 $dynamicObj->newProperty = "This is a dynamic property.";
 echo $dynamicObj->newProperty;

Neste exemplo, a classe "DynamicObject" é marcada com o atributo "AllowDynamicProperties", que permite que propriedades sejam adicionadas e acessadas dinamicamente. Este comportamento dinâmico pode ser particularmente útil ao lidar com objetos que precisam se adaptar a diversas estruturas de dados ou ao trabalhar com dados de fontes externas, como APIs.

Depreciações e remoções no PHP 8.2

• Extensões: O PHP 8.2 se despediu de diversas extensões desatualizadas e sem manutenção, incluindo “oci8”, “mysql”, “mcrypt” e “interbase”. Os desenvolvedores que dependem dessas extensões são fortemente incentivados a migrar para alternativas modernas para garantir a segurança e a estabilidade de seus aplicativos.

• Função each() : A função each() agora está oficialmente obsoleta no PHP 8.2. Esta função foi usada para iterar arrays avançando o ponteiro interno e retornando o par chave-valor atual. No entanto, ele teve vários problemas e foi amplamente substituído por loops foreach, que oferecem melhor legibilidade e facilidade de manutenção.
• Função create_function() : A função create_function() está marcada como obsoleta. Esta função foi usada para criar funções anônimas dinamicamente, mas não foi recomendada devido a questões de segurança e melhores alternativas, como encerramentos.
• Sinalizador de filtro FILTER_SANITIZE_MAGIC_QUOTES : O sinalizador de filtro FILTER_SANITIZE_MAGIC_QUOTES está obsoleto. Este sinalizador foi usado com filter_var() para limpar a entrada adicionando barras antes de caracteres como aspas simples e aspas duplas. As práticas recomendadas modernas sugerem o uso de instruções preparadas e consultas parametrizadas para lidar com a entrada do banco de dados, tornando esse sinalizador obsoleto.
• Função stristr() : A função stristr(), que executa uma pesquisa sem distinção entre maiúsculas e minúsculas por uma substring em uma string, está obsoleta. Embora ainda esteja funcional, os desenvolvedores são incentivados a usar a versão que não diferencia maiúsculas de minúsculas, stripos(), ou alternativas str_contains() para melhor clareza.
• define() com argumentos de array : O uso de define() para definir constantes com arrays como valores agora está obsoleto. Embora fosse possível definir constantes com matrizes como valores, esta prática é considerada não convencional e as constantes normalmente devem ter valores escalares.
• Sinalizadores SORT_NUMERIC e SORT_REGULAR : Os sinalizadores SORT_NUMERIC e SORT_REGULAR para funções de classificação como sort() e usort() estão obsoletos. Esses sinalizadores não são mais necessários, pois o PHP detecta automaticamente o tipo de dados dos elementos e os classifica de acordo.

Melhorias de desempenho

O PHP 8.2 traz vários aprimoramentos e otimizações de desempenho subjacentes. Embora a extensão dessas melhorias possa variar dependendo do seu caso de uso específico, a atualização para o PHP 8.2 provavelmente trará alguns benefícios notáveis ​​de desempenho. Essas melhorias podem ter um impacto significativo em aplicativos com alto tráfego ou que executam tarefas que consomem muitos recursos, tornando-os mais responsivos e eficientes.

Correções de bugs e estabilidade

Como acontece com qualquer nova versão do PHP, o PHP 8.2 aborda vários bugs e problemas de estabilidade. Essas correções são cruciais para manter a confiabilidade geral da linguagem e garantir que o PHP continue a ser uma escolha robusta para desenvolvimento web.

Perguntas frequentes - Novo no PHP 8.2

Conclusão

Concluindo, o PHP 8.2 surge como um marco fundamental no cenário em constante evolução do desenvolvimento web. Com uma ampla gama de recursos inovadores, maior flexibilidade e otimizações de desempenho, ele atende às crescentes demandas de desenvolvedores em todo o mundo.

A introdução de enums, promoção de construtor, classes somente leitura, argumentos nomeados e o atributo AllowDynamicProperties capacita os desenvolvedores a escrever código mais limpo e de fácil manutenção. Além disso, os novos tipos de Forma Normal Disjuntiva (DNF) trazem recursos avançados de manipulação lógica para o PHP, expandindo ainda mais sua versatilidade. No entanto, à medida que o PHP avança, ele também se despede de extensões e funções desatualizadas, ao mesmo tempo em que aborda bugs de forma diligente, garantindo que continue sendo uma escolha confiável e segura para desenvolvimento web.

Conteúdo Relacionado:

Como corrigir o erro “WordPress Disable PHP Update Required” (2 métodos)

Logs de consulta lenta do MySQL