Apresentando o PHP 7.4: Desempenho, Recursos, Descontinuações

O que o PHP 7.4 significa para você?

O PHP evolui continuamente e eles lançaram sua última atualização do PHP 7.4, cheia de novos recursos. Como já provamos nas versões anteriores do PHP 7 - o desempenho e a velocidade continuam avançando. Um dos novos recursos mais interessantes é o pré - carregamento . Ele acelera a execução do script e introduz a capacidade de ter um código mais rápido e limpo, devido às linhas comuns de código simplificadas.

Os responsáveis ​​pelo PHP levaram em consideração os comentários e solicitações da audiência e os responderam perfeitamente. Desde então, eles mudam continuamente o código para serem mais intuitivos e mais confortáveis ​​para alternar entre linguagens de programação.

O PHP é usado em mais de 78,9% de todos os sites. Segundo a W3techs , os sites mais populares que usam PHP são Wikipedia, Pinterest e Facebook, para citar alguns.

Se olharmos explicitamente para sites WordPress executando PHP, comparando o PHP 5 e 7, podemos ver um aumento de velocidade dupla. Os sites com WordPress ganham mais ao usar a versão mais recente do PHP.



Este gráfico ilustra a verdade sobre sites que usam ativamente PHP. São 40 mln. sites ao vivo o suficiente para chamar sua atenção? É assim que muitos estão usando PHP no momento. Além disso, o PHP 7.4 já está apresentando melhores resultados de teste que o PHP 7.3, com melhor desempenho e outras atualizações de qualidade de vida.

O gráfico abaixo mostra o teste de benchmark geral nas versões novas e antigas do PHP. Alguns dos critérios testados foram facilidade de uso, velocidade e desempenho, entre outros.

O que há de novo no PHP 7.4?

Desde 2016, o PHP7 lança atualizações anuais sem falhas. A cada ano, eles oferecem novos recursos, adições e a possibilidade de escrever um código mais limpo, que torna o idioma mais confiável e fácil de usar para quem o executa em seus sites.

Vamos nos aprofundar e dar uma olhada em algumas das mudanças que foram feitas com a adição do PHP 7.4. Para uma lista completa, confira o changelog aqui .

Pré-carregamento

Vamos falar sobre código. Ao usar uma estrutura ou bibliotecas, seus arquivos precisam ser carregados e vinculados a cada solicitação. O pré-carregamento é quando você pode carregar estruturas e bibliotecas no OPCache. Ele permite que o servidor carregue os arquivos PHP e os armazene na memória durante a inicialização e os disponibilize para solicitações futuras. Fale sobre fazer as coisas correrem rápido!

O pré-carregamento é executado por uma diretiva php.ini específica: opcache.preload . Este possui o compilador de scripts PHP e é executado quando o servidor é iniciado. Também pode ser usado para pré-carregar mais arquivos e optar por incluí-los ou compilá-los.

Isso é demais. No entanto, se a origem dos arquivos pré-carregados for alterada, o servidor deverá ser reiniciado. Os arquivos pré-carregados também permanecem em cache na memória do OPCache para sempre.
No entanto, esses arquivos pré-carregados continuarão disponíveis para solicitações futuras, caso você precise usá-los novamente.

Operador de propagação em expressões de matriz

Quando o PHP 5.6 foi lançado, o PHP começou a suportar a descompactação de argumentos (operador de propagação), mas agora, com a 7.4, podemos usar esse recurso com uma expressão de matriz. A descompactação de argumentos é uma sintaxe para descompactar matrizes e Traversables em listas de argumentos. E, para fazer isso, ele só precisa ser precedido por ... (3 pontos). É isso.

Vejamos este exemplo:

$animals = ['dog', 'cat']; $animalkingdom = ['lion', 'elephant', ...$animals, 'giraffe']; // ['lion', 'elephant', 'dog', 'cat', 'giraffe']; 

Agora podemos expandir uma matriz de qualquer lugar que desejemos em outra matriz, simplesmente usando a sintaxe do operador de propagação.

Aqui está um exemplo mais longo:

 $num1 = [1, 2, 3]; $num2 = [...$num1]; // [1, 2, 3] $num3 = [0, ...$num1]; // [0, 1, 2, 3] $num4 = array(...$num1, ...$num2, 111); // [1, 2, 3, 1, 2, 3, 111] $num5 = [...$num1, ...$num1]; // [1, 2, 3, 1, 2, 3] 

Não apenas isso, mas você também pode usá-lo em uma função. Confira este exemplo:

 function getNum() { return ['a', 'b']; } $num6 = [...getNum(), 'c']; // ['a', 'b', 'c'] $num7 = [...new NumIterator(['a', 'b', 'c'])]; // ['a', 'b', 'c'] function arrGen() { for($i = 11; $i < 15; $i++) { yield $i; } } $num8 = [...arrGen()]; // [11, 12, 13, 14] 

Além disso, agora você pode descompactar matrizes e geradores retornados por uma função diretamente em uma nova matriz.

Um exemplo de código ficaria assim:

 function getAnimals(){ return ['dog', 'cat', 'elephant']; } $num1 = [...getAnimals(), 'lion', 'tiger', 'giraffe']; 

E com o PHP 7.4, ele imprimiria:

 array(6) { [0]=> string(3) "dog" [1]=> string(3) "cat" [2]=> string(8) "elephant" [3]=> string(4) "lion" [4]=> string(5) "tiger" [5]=> string(7) "giraffe" } 

Com essa nova expressão de matriz, os operadores de spread devem ter um desempenho muito melhor em relação ao 7.3 array_merge. Isso ocorre porque o operador spread é uma estrutura de linguagem, enquanto array_merge é uma função. Também porque o operador spread suporta objetos implementando traversable e array_merge suporta apenas matrizes.

Algumas coisas importantes a serem observadas, você só pode usar matrizes indexadas, pois as chaves de sequência não são suportadas. Se usado, um erro recuperável será exibido na tela, assim que uma chave de cadeia for encontrada.
Outro benefício glorioso para o 7.4 é a remoção do array_merge. Diga adeus à temida mudança de índice!

Por exemplo, vejamos essa longa matriz de mesclagem abaixo:

 $array = ['banana, 'orange']; $array[2] = 'orange'; $array[1] = 'apple'; //shifting var_dump($array); // prints array(3) { [0]=> string(6) "banana" [1]=> string(5) "apple" [2]=> string(6) "orange" 

Outro benefício do 7.4 é usar a função de gerador. Uma função de gerador funciona exatamente como uma função normal, exceto que, em vez de retornar um valor, uma função de gerador gera tantos valores quanto necessário.

Confira o código de exemplo abaixo:

 function generator() { for ($i = 3; $i <= 5; $i++) { yield $i; } } $num1 = [0, 1, 2, ...generator()]; 

Referências fracas

Agora, o PHP 7.4 tem uma classe WeakReference, que não deve ser confundida com a classe WeakRed ou a extensão Weakref .

As WeakReferences permitem que o programador recupere uma referência a um objeto. Isso é útil porque não impede que o objeto seja destruído. Eles são úteis para implementar o cache como estruturas.

 WeakReference { /* Methods */ public __construct ( void ) public static create ( object $referent ) : WeakReference public get ( void ) : ?object } 

Parâmetros Contravariantes e Devoluções Covariantes

Atualmente, o PHP usa principalmente tipos de parâmetros invariantes e tipos de retorno. Ou seja, se um método tiver um parâmetro ou tipo de retorno X, o parâmetro de subtipo ou tipo de retorno também deverá ser do tipo X.

Agora, com o PHP 7.4, ele propõe permitir covariância (ordenada de específica para genérica) e contravariante (reverter a ordem) nos tipos de parâmetro e retorno.

Aqui está um exemplo de ambos:

Exemplo de tipo de retorno covariável:

 interface Factory { function make(): object; } class UserFactory implements Factory { function make(): User; } 

Exemplo de tipo de parâmetro contravariante:

 interface Concatable { function concat(Iterator $input); } class Collection implements Concatable { // accepts all iterables, not just Iterator function concat(iterable $input) {/* . . . */} } 

Propriedades digitadas 2.0

Desde o PHP 5, as dicas de tipo têm sido um recurso disponível, permitindo que você especifique o tipo de variável que deve ser passado para uma função ou classe. Nas migrações do PHP 7.2, a adição do tipo de dados do objeto deu esperanças de que mais estivessem disponíveis no futuro. O futuro é agora.

No novo 7.4, o PHP é capaz de suportar a seguinte lista de tipos:

 bool, int, float, string, array, object, iterable, self, parent any class or interface name ?type // where "type" may be any of the above 

Observe que o tipo pai pode ser usado em classes e não precisa ter um pai consistente com o parâmetro e o tipo de retorno.

Além disso, observe que o cancelamento e a chamada não são suportados. O vácuo foi removido porque não era útil e tinha semântica pouco clara; Pode ser chamado , porque seu comportamento depende do contexto.

Vamos conferir mais alguns exemplos.

Aqui está uma classe, escrita para o PHP 7.3:

 class User { /** @var int $id */ private $id; /** @var string $name */ private $name; public function __construct(int $id, string $name) { $this->id = $id; $this->name = $name; } public function getId(): int { return $this->id; } public function setId(int $id): void { $this->id = $id; } public function getName(): string { return $this->name; } public function setName(string $name): void { $this->name = $name; } } 

No PHP 7.4, sem sacrificar nenhuma segurança de tipo, uma classe agora pode ser escrita tão simples quanto:

 class User { public int $id; public string $name; public function __construct(int $id, string $name) { $this->id = $id; $this->name = $name; } } 

Aqui estão alguns exemplos de todos os tipos que o 7.4 suporta agora:

 class Example { public int $scalarType; protected ClassName $classType; private ?ClassName $nullableClassType; // Types are also legal on static properties public static iterable $staticProp; // Types can also be used with the "var" notation var bool $flag; // Typed properties may have default values (more below) public string $str = "foo"; public ?string $nullableStr = null; // The type applies to all properties in one declaration public float $x, $y; // equivalent to: public float $x; public float $y; } 

Funções de seta 2.0

Funções anônimas no PHP tendem a ser longas e extensas, mesmo quando estão executando apenas operações simples. Isso ocorre parcialmente devido a uma grande quantidade de clichê sintático e parcialmente devido à necessidade de importar manualmente as variáveis ​​usadas.

Isso torna o código que usa fechamentos simples confuso para ler e ainda mais difícil de entender.

Vamos dar uma olhada em algum código que você usaria no PHP 7.3:

 function array_values_from_keys($arr, $keys) { return array_map(function ($x) use ($arr) { return $arr[$x]; }, $keys); } 

Agora, aqui está a sintaxe mais concisa do PHP 7.4:

 function array_values_from_keys($arr, $keys) { return array_map(fn($x) => $arr[$x], $keys); } 

Portanto, as funções de seta agora têm este formato simples:

 fn(parameter_list) => expr 

Abaixo você pode ver um exemplo de duas funções $ fn1 (7.3) e $ fn2 (7.4) lado a lado. Eles têm o mesmo resultado, mas parecem diferentes:

 $y = 1; $fn1 = fn($x) => $x + $y; $fn2 = function ($x) use ($y) { return $x + $y; }; 

Isso também funcionará se as funções de seta estiverem aninhadas:

 $z = 1; $fn = fn($x) => fn($y) => $x * $y + $z; 

Aqui, a função externa captura $ z . Então, a função interna também captura $ z da função externa. Com 7.4, o escopo externo pode se tornar disponível na função interna. Isso é algo que 7.3 não foi capaz de fazer.

A sintaxe da função de seta permite uma variedade de funções, como variáveis, valores padrão, parâmetros e tipos de retorno, bem como passagem e retorno por referência. Tudo isso mantendo um visual limpo e legível. Abaixo estão todas as funções de seta válidas agora disponíveis:

 fn(array $x) => $x; fn(): int => $x; fn($x = 42) => $x; fn(&$x) => $x; fn&($x) => $x; fn($x, ...$rest) => $rest; 

Uma coisa a notar é que as funções de seta têm a menor precedência. Veja o exemplo:

 fn($x) => $x + $y // is fn($x) => ($x + $y) // not (fn($x) => $x) + $y 

Deprecações

Há muitas obsoletas acontecendo com a mesclagem para 7.4. A lista a seguir é uma breve visão geral das funções direcionadas à depreciação. Você pode encontrar uma explicação mais detalhada aqui :

• O tipo real
• Legendas de citações mágicas
• array_key_exists () com objetos
• Filtro FILTER_SANITIZE_MAGIC_QUOTES
• Métodos de exportação de reflexão ()
• mb_strrpos () com codificação como terceiro argumento
• mix de ordem dos parâmetros implode ()
• Desvinculando $ this de fechamentos não estáticos
• Função hebrevc ()
• função convert_cyr_string ()
• função money_format ()
• função ezmlm_hash ()
• r função estore_include_path ()
• allow_url_include ini directiv

Alguns pontos importantes a serem observados são as seguintes deprecações em duas etapas.

Alterando a precedência de um operador de concatenação

Atualmente, a precedência dos operadores '.', '+' And '-' é igual. Qualquer combinação desses operadores será simplesmente resolvida da esquerda para a direita.

Vamos dar uma olhada neste código no PHP 7.3:

 echo "sum: " . $a + $b; // would be evaluated left-to-right echo ("sum: " . $a) + $b; // could also look like this 

No PHP 7.4, '+' e '-' teriam precedência sobre '.' portanto, as adições e subtrações sempre seriam realizadas antes da string. Seria o seguinte:

 echo "sum: " . $a + $b; // would be executed as if the code were as follows. echo "sum :" . ($a + $b); 

Esta proposta em duas etapas visa ser menos propensa a erros e mais instintiva. Atualmente, o PHP 7.4 está no primeiro estágio com um aviso de descontinuação de expressões sem parênteses de '+', '-' e '.' Enquanto aguarda a votação / mudança final acontecendo no PHP 8.

Operador ternário associativo de esquerda

Diferentemente da maioria das outras linguagens, o operador ternário no PHP é associativo à esquerda, em vez de associativo à direita. Além de incomum, também é confuso para programadores que alternam entre idiomas diferentes. O PHP 7.4 propõe remover a associatividade esquerda e requer o uso de parênteses.

Vamos dar uma olhada no código abaixo:

 return $a == 1 ? 'one' : $a == 2 ? 'two' : $a == 3 ? 'three' : $a == 4 ? 'four' : 'other'; 

Na maioria dos outros idiomas, seria interpretado como:

 return $a == 1 ? 'one' : ($a == 2 ? 'two' : ($a == 3 ? 'three' : ($a == 4 ? 'four' : 'other'))) 

Enquanto em PHP, ele é interpretado como:

 return ((($a == 1 ? 'one' : $a == 2) ? 'two' : $a == 3) ? 'three' : $a == 4) ? 'four' : 'other'; 

Isso pode levar a erros, porque geralmente não é o que se pretendia.

Através de uma proposta em duas etapas, o PHP 7.4 implementou o uso explícito de parênteses como um aviso de descontinuação e, esperançosamente, executará um erro de tempo de execução de compilação em versões futuras.

Conclusão

Bem na hora das festas, o PHP 7.4 traz novos recursos e melhorias na qualidade de vida de todos os desenvolvedores de PHP.

Os sites WordPress definitivamente se beneficiarão dessas melhorias e seus usuários podem esperar tempos de execução mais rápidos e menos uso de memória ao usar o PHP 7.4 em comparação com as versões anteriores.

Com a adição de declarações de tipo de propriedade de primeira classe e dicas de tipo, funções de mesclagem de setas e velocidade ridiculamente melhor, o 7.4 certamente melhorará a velocidade e a qualidade do seu fluxo de trabalho.