O PHP 8 foi hoje oficialmente lançado (26 de novembro de 2020) e estamos muito entusiasmados! É uma nova versão major, o que significa que apresentará algumas mudanças importantes, bem como muitos novos recursos e melhorias de desempenho.
Por causa destas mudanças significativas, há uma maior probabilidade de ser necessário fazer algumas mudanças de código para que este corra em PHP 8. No entanto, se se manteve actualizado com os últimos lançamentos, a atualização não deverá ser muito complicada, uma vez que a maioria das alterações importantes foram descontinuadas antes nas versões 7. *.
Além de mudanças significativas, o PHP 8 também traz um bom conjunto de novos recursos, tais como o JIT compiler, union types e atributos, entre outros.
Partilhamos aqui um overall destas novas funcionalidades:
Named arguments
PHP7
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
PHP8
htmlspecialchars($string, double_encode: false);
Especificam-se apenas os parâmetros obrigatórios, ignorando os opcionais.
Os argumentos são independentes da ordem e autodocumentados.
Attributes
PHP7
/**
* @Route("/api/posts/{id}", methods={"GET", "HEAD"})
*/
class User
{
PHP8
#[Route("/api/posts/{id}", methods: ["GET", "HEAD"])]
class User
{
Em vez de anotações PHPDoc, é agpra possível pode utilizar metadados estruturados com a sintaxe nativa do PHP.
Constructor property promotion
PHP7
class Point {
public float $x;
public float $y;
public float $z;
public function __construct(
float $x = 0.0,
float $y = 0.0,
float $z = 0.0,
) {
$this->x = $x;
$this->y = $y;
$this->z = $z;
}
}
PHP8
class Point {
public function __construct(
public float $x = 0.0,
public float $y = 0.0,
public float $z = 0.0,
) {}
}
Menos código “cliché” para definir e inicializar propriedades.
Union types
PHP7
class Number {
/** @var int|float */
private $number;
/**
* @param float|int $number
*/
public function __construct($number) {
$this->number = $number;
}
}
new Number('NaN'); // Ok
PHP8
class Number {
public function __construct(
private int|float $number
) {}
}
new Number('NaN'); // TypeError
Em vez de anotações PHPDoc para uma combinação de tipos, é agora possível utilizar declarações union type nativas que são validadas em runtime.
Match expression
PHP7
switch (8.0) {
case '8.0':
$result = "Oh no!";
break;
case 8.0:
$result = "This is what I expected";
break;
}
echo $result;
//> Oh no!
PHP8
echo match (8.0) {
'8.0' => "Oh no!",
8.0 => "This is what I expected",
};
//> This is what I expected
A nova Match expression é semelhante ao switch e tem as seguintes funcionalidades:
- O Match é uma expressão, o que significa que o resultado pode ser guardado numa variável ou devolvido;
- Os branches do Match suportam somente expressões single-line e não precisam de break;
- Faz comparações estritas.
Nullsafe operator
PHP7
$country = null;
if ($session !== null) {
$user = $session->user;
if ($user !== null) {
$address = $user->getAddress();
if ($address !== null) {
$country = $address->country;
}
}
}
PHP8
$country = $session?->user?->getAddress()?->country;
Em vez de null checks, agora com o novo operador nullsafe é possível efectuar chamadas em cadeia. Quando a avaliação de um elemento da cadeia falha, a execução de toda a cadeia é cancelada e toda a cadeia é avaliada como null.
Comparações string to number
PHP7
0 == 'foobar' // true
PHP8
0 == 'foobar' // false
Ao comparar com uma string numérica, o PHP 8 efectua uma comparação numérica.
Caso contrário, converte o número para string e efectua uma comparação de string.
Type errors consistentes em funções internas
PHP7
strlen([]); // Warning: strlen() expects parameter 1 to be string, array given
array_chunk([], -1); // Warning: array_chunk(): Size parameter expected to be greater than 0
PHP8
strlen([]); // TypeError: strlen(): Argument #1 ($str) must be of type string, array given
array_chunk([], -1); // ValueError: array_chunk(): Argument #2 ($length) must be greater than 0
A maioria das funções internas agora devolve Fatal Error exception se a validação dos parâmetros falhar.
Compilação Just-In-Time
O PHP 8 apresenta dois motores de compilação JIT.
O Tracing JIT, o mais promissor, apresenta um desempenho cerca de 3 vezes superior em benchmarks sintéticos e 1,5 a 2 vezes superior nalgumas aplicações específicos de execução longa.
O desempenho típico da aplicação está ao mesmo nível do PHP 7.4.