Beschikbaar!

PHP 8.0 is een omvangrijke update van de PHP programmeertaal.
Het bevat veel nieuwe mogelijkheden en optimalisaties, waaronder argument naamgeving, unie types, attributen, promotie van constructor eigenschappen, expressie vergelijking, null-veilige operator, JIT, en verbeteringen aan het type systeem, foute afhandeling, en consistentie.

Update naar PHP 8!

Argument naamgeving

Geef enkel vereiste parameters op, sla optionele parameters over.
Argumenten hebben een onafhankelijke volgorde en documenteren zichzelf.

htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);

htmlspecialchars($string, double_encode: false);

Attributen

In plaats van met PHPDoc annotaties kan je nu gestructureerde metadata gebruiken in PHP's eigen syntaxis.

class PostsController
{
    /**
     * @Route("/api/posts/{id}", methods={"GET"})
     */
    public function get($id) { /* ... */ }
}

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

Promotie van constructor eigenschappen

Minder standaardcode nodig om eigenschappen te definiëren en initialiseren.

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,
    ) {}
}

Unie types

In plaats van met PHPDoc annotaties kan je de mogelijke types via unie types declareren zodat deze ook gevalideerd worden tijdens de runtime.

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

Expressie vergelijking

De nieuwe match is gelijkaardig aan switch en heeft volgende eigenschappen:

Match is een expressie, dit wil zeggen dat je het in een variabele kan bewaren of teruggeven.
Match aftakkingen zijn expressies van één enkele lijn en bevatten geen break statements.
Match vergelijkingen zijn strikt.

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

Null-veilige operator

In plaats van een controle op null uit te voeren kan je nu een ketting van oproepen vormen met de null-veilige operator. Wanneer één expressie in de ketting faalt, zal de rest van de ketting niet uitgevoerd worden en is het resultaat van de hele ketting null.

$country =  null;

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

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

        if ($address !== null) {
            $country = $address->country;
        }
    }
}

$country = $session?->user?->getAddress()?->country;

Verstandigere tekst met nummer vergelijkingen

Wanneer PHP 8 een vergelijking uitvoert tegen een numerieke tekst zal er een numerieke vergelijking uitgevoerd worden. Anders zal het nummer naar een tekst omgevormd worden en er een tekstuele vergelijking uitgevoerd worden.

0 == 'foobar' // true

0 == 'foobar' // false

Consistente type fouten voor interne functies

De meeste interne functies gooien nu een Error exception als de validatie van parameters faalt.

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

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

Just-In-Time compilatie

PHP 8 introduceert twee systemen voor JIT compilatie. De tracerende JIT is veelbelovend en presteert ongeveer 3 keer beter bij synthetische metingen en kan sommige langlopende applicaties 1.5–2 keer verbeteren. Prestaties van typische web applicaties ligt in lijn met PHP 7.4.

Relatieve JIT bijdrage aan de prestaties van PHP 8

Type systeem en verbeteringen van de fout afhandeling

Strikte type controles bij rekenkundige/bitsgewijze operatoren RFC
Validatie voor abstracte trait methodes RFC
Correcte signatures bij magic methods RFC
Herindeling van de engine warnings RFC
Fatal error bij incompatibele method signatures RFC
De @ operator werkt niet meer bij het onderdrukken van fatale fouten.
Overerving bij private methods RFC
mixed type RFC
static return type RFC
Types voor interne functies Email draadje
Opaque objects in plaats van resources voor Curl, Gd, Sockets, OpenSSL, XMLWriter, and XML extensies

Andere syntaxis aanpassingen en verbeteringen

Sta toe om een komma te plaatsen bij het laatste parameter in een lijst RFC en bij de use in closures RFC
Catches die niets vangen RFC
Variabele Syntaxis Aanpassingen RFC
Namespaced namen worden als één enkel token afgehandeld RFC
throw is nu een expressie RFC
::class werkt bij objecten RFC

Nieuwe Classes, Interfaces, en Functies

Weak Map class
Stringable interface
str_contains(), str_starts_with(), str_ends_with()
fdiv()
get_debug_type()
get_resource_id()
token_get_all() object implementatie
New DOM Traversal and Manipulation APIs

Betere prestaties, betere syntaxis, verbeterd type systeem.

Ga naar de downloads pagina om de PHP 8 code te verkrijgen. Uitvoerbare bestanden voor Windows kan je vinden op de PHP voor Windows website. De volledige lijst met wijzigingen is vastgelegd in een ChangeLog.

De migratie gids is beschikbaar in de PHP Handleiding. Gebruik deze om een gedetailleerde lijst te krijgen van nieuwe opties en neerwaarts incompatibele aanpassingen.