Released!

    PHP 8.0 é uma atualização importante da linguagem PHP.
    Ela contém muitos novos recursos e otimizações, incluindo argumentos nomeados, união de tipos, atributos, promoção de propriedade do construtor, expressão match, operador nullsafe, JIT e melhorias no sistema de tipos, tratamento de erros e consistência.

    Atualize para o PHP 8!

    Argumentos nomeados

    • Especifique apenas os parâmetros obrigatórios, pulando os opcionais.
    • Os argumentos são independentes da ordem e autodocumentados.

    PHP 7 
    htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
    htmlspecialchars($string, double_encode: false);

    Atributos

    Em vez de anotações PHPDoc, agora você pode usar metadados estruturados com a sintaxe nativa do PHP.

    PHP 7 
    class PostsController
{
    /**
     * @Route("/api/posts/{id}", methods={"GET"})
     */
    public function get($id) { /* ... */ }
}
    class PostsController
{
    #[Route("/api/posts/{id}", methods: ["GET"])]
    public function get($id) { /* ... */ }
}

    Promoção de propriedade de construtor

    Menos código boilerplate para definir e inicializar propriedades.

    PHP 7 
    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;
    }
}
    class Point {
    public function __construct(
        public float $x = 0.0,
        public float $y = 0.0,
        public float $z = 0.0,
    ) {}
}

    União de tipos

    Em vez de anotações PHPDoc para uma combinação de tipos, você pode usar declarações de união de tipos nativa que são validados em tempo de execução

    PHP 7 
    class Number {
    /** @var int|float */
    private $number;

    /**
     * @param float|int $number
     */
    public function __construct($number) {
        $this->number = $number;
    }
}

new Number('NaN'); // Ok
    class Number {
    public function __construct(
        private int|float $number
    ) {}
}

new Number('NaN'); // TypeError

    Expressão match

    A nova expressão match é semelhante ao switch e tem os seguintes recursos:

    • Match é uma expressão, o que significa que seu resultado pode ser armazenado em uma variável ou retornado.
    • Match suporta apenas expressões de uma linha e não precisa de uma declaração break.
    • Match faz comparações estritas.
    PHP 7 
    switch (8.0) {
    case '8.0':
        $result = "Oh no!";
        break;
    case 8.0:
        $result = "This is what I expected";
        break;
}
echo $result;
//> Oh no!
    echo match (8.0) {
    '8.0' => "Oh no!",
    8.0 => "This is what I expected",
};
//> This is what I expected

    Operador nullsafe

    Em vez de verificar condições nulas, agora você pode usar uma cadeia de chamadas com o novo operador nullsafe. Quando a avaliação de um elemento da cadeia falha, a execução de toda a cadeia é abortada e toda a cadeia é avaliada como nula.

    PHP 7 
    $country =  null;

if ($session !== null) {
    $user = $session->user;

    if ($user !== null) {
        $address = $user->getAddress();

        if ($address !== null) {
            $country = $address->country;
        }
    }
}
    PHP 8 RFC ↗ 
    $country = $session?->user?->getAddress()?->country;

    Comparações mais inteligentes entre strings e números

    Ao comparar com uma string numérica, o PHP 8 usa uma comparação numérica. Caso contrário, ele converte o número em uma string e usa uma comparação de string.

    PHP 7 
    0 == 'foobar' // true
    PHP 8 RFC ↗ 
    0 == 'foobar' // false

    Erros consistentes para tipos de dados em funções internas

    A maioria das funções internas agora lançam uma exceção Error se a validação do parâmetro falhar.

    PHP 7 
    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
    PHP 8 RFC ↗ 
    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

    Compilação Just-In-Time

    PHP 8 apresenta dois motores de compilação JIT. Tracing JIT, o mais promissor dos dois, mostra desempenho cerca de 3 vezes melhor em benchmarks sintéticos e melhoria de 1,5 a 2 vezes em alguns aplicativos específicos de longa execução. O desempenho típico das aplicações está no mesmo nível do PHP 7.4.

    Relative JIT contribution to PHP 8 performance

    Just-In-Time compilation

    Melhorias no sistema de tipo e tratamento de erros

    • Verificações de tipo mais rígidas para operadores aritméticos / bit a bit RFC
    • Validação de método abstrato em traits RFC
    • Assinaturas corretas de métodos mágicos RFC
    • Avisos de motor reclassificados RFC
    • Erro fatal para assinaturas de método incompatíveis RFC
    • O operador @ não silencia mais os erros fatais.
    • Herança com métodos privados RFC
    • Tipo mixed RFC
    • Tipo de retorno static RFC
    • Tipagem de funções internas Discussão por email
    • Objetos opacos em vez de recursos para Curl, Gd, Sockets, OpenSSL, XMLWriter, e XML extensões

    Outros ajustes e melhorias de sintaxe

    • Permitir vírgula no final da lista de parâmetros RFC e listas de uso em closures RFC
    • Catches sem variável na captura de exceção RFC
    • Ajustes de sintaxe para variáveis RFC
    • Tratamento de nomes de namespace como token único RFC
    • throw como expressão RFC
    • Permitir ::class em objetos RFC

    Novas classes, interfaces e funções

    Obtenha melhoria de desempenho gratuita. Obtenha melhor sintaxe.
    Obtenha mais segurança de tipos.

    Atualize para o PHP 8!

    Para downloads do código-fonte do PHP 8, visite a página de downloads. Os binários do Windows podem ser encontrados na página PHP para Windows. A lista de mudanças é registrada no ChangeLog.

    O guia de migração está disponível no Manual do PHP. Consulte-o para obter uma lista detalhada de novos recursos e alterações incompatíveis com versões anteriores.

    To Top