Released!

    PHP 8.0 ist ein Major-Update der Sprache PHP.
    Es beinhaltet viele neue Funktionen und Optimierungen wie beispielsweise Named Arguments, Union Types, Attribute, Constructor Property Promotion, Match Ausdrücke, Nullsafe Operator, JIT und Verbesserungen des Typen-Systems, der Fehlerbehandlung und der Konsistenz.

    Wechsle jetzt zu PHP 8!

    Named Arguments

    • Gib nur notwendige Parameter an, überspringe optionale.
    • Parameter sind unabhängig von der Reihenfolge und selbstdokumentierend.

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

    Attribute

    Anstelle von PHPDoc Annotations kannst du nun strukturierte Meta-Daten in nativer PHP Syntax nutzen.

    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) { /* ... */ }
}

    Constructor Property Promotion

    Weniger Codewiederholungen für das Definieren und Initialisieren von Objektattributen.

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

    Union Types

    Anstelle von PHPDoc Annotations für kombinierte Typen kannst du native Union-Type-Deklarationen verwenden, welche zur Laufzeit validiert werden.

    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

    Match Ausdruck

    Der neue match Ausdruck ist ähnlich wie die switch Anweisung und bietet folgende Funktionen:

    • Da Match ein Ausdruck ist, kann sein Ergebnis in einer Variable gespeichert oder ausgegeben werden.
    • Match Zweige unterstützen nur einzeilige Ausdrücke und benötigen keinen break Ausdruck.
    • Match führt strikte Vergleiche durch.
    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

    Nullsafe Operator

    Anstelle von Null-Checks kannst du Funktionsaufrufe nun direkt mit dem neuen Nullsafe Operator aneinanderreihen. Wenn ein Funktionsaufruf innerhalb der Kette Null zurückliefert, wird die weitere Ausführung abgebrochen und die gesamte Kette wird zu Null ausgewertet.

    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;

    Vernünftige String-zu-Zahl Vergleiche

    Wenn eine Zahl mit einem numerischen String verglichen wird, benutzt PHP 8 einen Zahlen-Vergleich. Andernfalls wird die Zahl zu einem String konvertiert und ein String-Vergleich durchgeführt.

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

    Konsistente Typen-Fehler für interne Funktionen

    Die meisten internen Funktionen erzeugen nun eine Error Exception wenn die Typenvalidierung der Parameter fehlschlägt.

    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

    Just-In-Time Compiler

    PHP 8 führt zwei JIT Compiler Engines ein. Tracing-JIT, der vielversprechendere der beiden, zeigt eine bis zu drei mal bessere Performance in synthetischen Benchmarks und eine 1,5 bis zweifache Verbesserung in einigen speziellen, langlaufenden Anwendungen. Die Performance einer typischen Anwendung ist auf dem Niveau von PHP 7.4.

    Relativer Beitrag des JIT Compilers zur Performance von PHP 8

    Just-In-Time compilation

    Verbesserungen am Typen-System und an der Fehlerbehandlung

    • Striktere Typen-Checks für arithmetische/bitweise Operatoren RFC
    • Validierung abstrakter Methoden in einem Trait RFC
    • Korrekte Signaturen magischer Funktionen RFC
    • Neue Klassifizierung von Engine-Warnings RFC
    • Inkompatiblen Methoden-Signaturen erzeugen einen Fatal Error RFC
    • Der @ Operator unterdrückt keine Fatal Errors mehr.
    • Vererbung mit privaten Methoden RFC
    • mixed Typ RFC
    • static als Rückgabetyp RFC
    • Typen für interne Funktionen E-Mail-Thread
    • Objekte ohne Methoden anstelle des resource Typs für Curl, Gd, Sockets, OpenSSL, XMLWriter, und XML Extension

    Weitere Syntax-Anpassungen und Verbesserungen

    • Erlauben eines abschließenden Kommas in Parameter-Listen RFC und Closure Use Listen RFC.
    • Catches ohne Exception-Variable RFC
    • Anpassungen an der Syntax für Variablen RFC
    • Namespaces werden als ein Token ausgewertet RFC
    • throw ist jetzt ein Ausdruck RFC
    • Nutzung von ::class auf Objekten RFC

    Neue Klassen, Interfaces, und Funktionen

    Bessere Performance, bessere Syntax, optimierte Typsicherheit.

    Wechsle jetzt zu PHP 8!

    Für den direkten Code-Download von PHP 8 schaue bitte auf der Downloads Seite vorbei. Windows Pakete können auf der PHP für Windows Seite gefunden werden. Die Liste der Änderungen ist im ChangeLog festgehalten.

    Der Migration Guide ist im PHP Manual verfügbar. Lies dort nach für detaillierte Informationen zu den neuen Funktionen und inkompatiblen Änderungen zu vorherigen PHP Versionen.

    To Top