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

O PHP 7.4 finalmente chegou! Esta nova versão, lançada em 28 de novembro de 2019, já está disponível em todos os servidores da Hostinger. Os desenvolvedores podem esperar por melhorias na legibilidade de códigos, manutenção e facilidade de uso. Vamos conferir alguns dos novos recursos, ajustes de desempenho e outros motivos pelos quais você deve migrar para o PHP 7.4.

O Que PHP 7.4 Significa Para Você?

O PHP continua a evoluir, lançando sua mais recente atualização do PHP 7.4, cheia de novos recursos. Como vimos nas versões anteriores do PHP 7 – o desempenho e a velocidade continuam melhorando.

Um dos novos recursos mais interessantes é o pré-carregamento. Ele ajuda a acelerar a execução de scripts, além de apresentar a capacidade de ter um código mais rápido e limpo, graças à simplificação de linhas de código comuns.

Os “anjos” responsáveis pelo PHP ouviram os comentários e solicitações do público e responderam com força total. Desde então, eles mudam continuamente o código para serem mais intuitivos e mais fáceis de alternar entre as 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.

Se olharmos especificamente para sites WordPress que executam PHP, comparando o PHP 5 e 7, podemos ver um aumento de velocidade dobrada. Sites com WordPress definitivamente saem ganhando ao usar a versão mais recente do PHP. Os usuários da Hostinger podem potencializar seus sites WordPress a novos patamares com apenas um clique.

Está vendo todas essas figuras? Este gráfico está divulgando um pouco de verdade sobre sites que usam ativamente PHP. Será que 39,191,714 sites são suficientes para chamar sua atenção? É o total de sites que estão usando PHP no momento. Além disso, o PHP 7.4 já tem sido testado e apresentando melhor desempenho que o PHP 7.3, garantindo uma longevidade ainda maior.

O gráfico abaixo mostra um 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.

Alterando Sua Versão PHP

Está pronto para atualizar, né? Eu sabia. A Hostinger torna tudo mais fácil do que nunca com essas quatro etapas bem simples. Você estará se divertindo com sua nova e aprimorada versão PHP em pouco tempo.

• Faça login na sua conta de hospedagem (qualquer uma compatível ou de hospedagem PHP) e clique em Home.
• Na sua página Home, desça a tela até a seção Hospedagem e clique no ícone Gerenciar.
• No campo de pesquisa, digite Configuração PHP e clique.
• Selecione PHP 7.4 e clique em Salvar.

Parabéns! Agora você tem a melhor e mais atualizada versão PHP do mercado.

Para verificar sua versão PHP atual, tudo o que precisa fazer é acessar a aba Hospedagem e conferir a versão PHP no lado esquerdo do painel. Se for qualquer coisa abaixo de 7.4, é só prosseguir e atualizar.

O Que Há de Novo no PHP 7.4?

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

Vamos nos aprofundar e examinar mais de perto algumas das alterações feitas com a adição do PHP 7.4. Para uma lista completa, confira o relatório de mudanças aqui.

Pré-carregamento

Vamos falar sobre código. Ao usar um framework ou bibliotecas, seus arquivos precisam ser carregados e vinculados a cada solicitação. O pré-carregamento é quando você pode carregar frameworks 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. É sobre fazer as coisas as coisas acontecerem rápido!

O pré-carregamento é executado por uma diretiva específica do php.ini: opache.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 escolher por incluí-los ou compilá-los.

Isso é impressionante. 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.

Spread Operator em Expressões de Array

Quando o PHP 5.6 foi lançado, o PHP começou a suportar argument unpacking (spread operator), mas agora, com a 7.4, podemos usar esse recurso com uma expressão de array. Argument unpacking é uma sintaxe para descompactar arrays e Traversables em listas de argument. E, para fazer isso, ele só precisa ser precedido por … (3 pontos). É isso.

Vamos conferir o exemplo:

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

Agora podemos expandir uma array de qualquer lugar que quisermos em outra array, simplesmente usando a sintaxe do Spread Operator. 

Aqui está um exemplo:

$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 arrays e generators que são retornados por uma função diretamente em uma nova array.

Um exemplo de código seria assim:

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

E com 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 array, os spread operators devem ter um desempenho muito melhor em relação ao 7.3 array_merge. Isso ocorre porque o spread Operator é uma estrutura de linguagem, enquanto array_merge é uma função. Também porque o Spread Operator suporta objetos implementando traversable e o array_merge suporta apenas arrays.

Algumas coisas importantes a serem observadas, você só pode usar arrays indexadas, pois as string keys não são suportadas. Se usado, um erro recuperável será exibido na tela assim que uma string key for encontrada.

Outro benefício glorioso para o 7.4 é a remoção do array_merge. Diga adeus ao temido index shift!

Por exemplo, vamos conferir este array merge 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 function generator. Uma function generator funciona exatamente como uma função normal. Exceto que, em vez de retornar um valor, uma function generator gera tantos valores quanto necessário.

Veja os exemplos de código abaixo:

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

Weak References

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

As WeakReferences permitem que o programador recupere uma reference a um object. Isso é útil porque não impede que o object 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
}

Contravariant Parameters e Covariant Returns

Atualmente, o PHP usa principalmente invariant parameter types e return types. Ou seja, se um método tiver um parameter ou return type X, o subtype parameter ou return type também deverá ser type X.

Agora, com o PHP 7.4, ele propõe permitir covariant (ordenada de específica para genérica) e contravariant (reverter a ordem) em parameter e return types.

Aqui estão exemplos de ambos:

Exemplo de covariant return type:

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

Exemplo de contravariant parameter type:

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

Typed Properties 2.0

Desde o PHP 5, type hints têm sido um recurso disponível, permitindo que você especifique o tipo de variável que se espera que seja passado para uma função ou classe. Nas migrações do PHP 7.2, a adição do object data type deu esperança de que houvesse mais disponíveis no futuro. O futuro é agora.

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

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 parent type pode ser usado em classes e não precisa ter um parent consistente com o parameter e o return type.

Além disso, observe que void and callable não são suportados. O void foi removido porque não era útil e tinha semântica pouco clara; Callable, porque seu comportamento dependia do contexto.

Vamos ver mais alguns exemplos.

Aqui está uma classe, escrita para 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 type-safety, uma classe agora pode ser simplesmente escrita como:

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 types 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;
}

Arrow Functions 2.0

Funções anônimas (anonymous functions) 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 closures simples confuso para ler e ainda mais difícil de entender.

Vamos dar uma olhada em um 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 arrow functions 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 arrow functions estiverem encadeadas:

$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 o 7.3 não foi capaz de fazer.

A sintaxe da arrow function permite uma variedade de funções, variadics, default values, parameter e return types, e também by-reference passing e returning. Tudo isso mantendo um visual limpo e legível. Abaixo estão todas as arrow functions válidas e disponíveis agora:

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 arrow functions têm a menor precedência. Veja o exemplo:

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

Descontinuações

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

• O tipo real 
• Magic quotes legacy
• array_key_exists() com objetos
• Filtro FILTER_SANITIZE_MAGIC_QUOTES 
• Métodos de reflexão export() 
• mb_strrpos() com codificação como 3rd argument
• Mix de ordem de parâmetro implode() 
• Desvincular $this de closures não estáticos 
• Função hebrevc()
• Função convert_cyr_string()
• Função  money_format()
• Função  ezmlm_hash()
• Função  restore_include_path()
• ini directiv allow_url_include

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

Alterando a Precedência do Operador de Concatenação

Atualmente, a precedência dos operadores  ‘.’, ‘+’ e ‘-‘ são todas iguais. Qualquer combinação desses operadores serão simplesmente resolvidas da esquerda para direita.

Vamos conferir este 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

Com o PHP 7.4, ‘+’ e ‘-’ teria precedência sobre ‘.’ então as adições e subtrações sempre serão executadas antes da string. Seria parecido com 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 propenso a erros e mais intuitiva. 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 decisão final/ alteração acontecer no PHP 8.

Operador Ternário Associativo à Esquerda

Diferente da maioria das outras linguagens, o operador ternário do PHP é associativo à esquerda, em vez de associativo à direita.

Além de incomum, também é confuso, é algo confuso para programadores que alternam entre diferentes linguagens. O PHP 7.4 propõe remover a associatividade de esquerda e requer o uso de parênteses no lugar disso.

Veja o código abaixo:

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

Na maioria das outras linguagens, seria interpretado assim:

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

Já no PHP, a interpretação é a seguinte:

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

Isso pode levar a erros pois não foi a intenção. 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 a esperança é que executará um erro de tempo de execução de compilação em versões futuras.

Conclusão

E nessa época de comemorações, o PHP 7.4 traz novos recursos e melhorias na qualidade de vida de todos os desenvolvedores PHP. 

Definitivamente, os sites WordPress terão proveito 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 as novidades de primeira classe quanto a property type declarations e type hinting, a mesclagem das funções de arrow, e a velocidade incrivelmente mais rápida, o 7.4 certamente irá melhorar ambos, a velocidade e a qualidade do fluxo do trabalho. 

O autor

Ariane G.

A Ariane é SEO Team Leader com experiência em conteúdo, localização e SEO. Seu desafio é levar a Hostinger ao topo dos resultados no Brasil, França e Reino Unido. Eventualmente ela compartilha seu conhecimento no blog e nos tutoriais da Hostinger e no tempo livre ela gosta de explorar lugares novos e viver intencionalmente.

Mais publicações de Ariane G.