Kürbisgewürz liegt in der Luft, also ist es Zeit für eine neue Version von PHP, der serverseitigen Skriptsprache, die unser Lieblings-CMS, WordPress, antreibt. Im Vorfeld der Veröffentlichung von Version 8.4 am 21. November haben die PHP-Entwickler zahlreiche frühe Versionen der neuen Codebasis vorgestellt, darunter eine Handvoll Release Candidates seit dem Einfrieren der Funktionen im August.

Neben den neuen Funktionen, Verbesserungen und Verwerfungen, die wir in diesem Jahr erwarten, gab es 2024 auch Änderungen am PHP-Veröffentlichungszyklus: Das Ende der Sicherheitsversionen für alle derzeit unterstützten Versionen wurde mit dem Jahresende statt mit dem GA-Geburtstag synchronisiert.

Außerdem wurde der Support um ein Jahr verlängert, so dass du PHP 8.4 sicher bis 2028 nutzen kannst (mit zwei Jahren Sicherheits- und Bugfixes und zwei Jahren reinen Sicherheitsfixes).

Du könntest zwar mehr Zeit mit PHP 8.4 verbringen, aber wahrscheinlich willst du jetzt schon wissen, was in dieser Version neu ist. Also, lass uns loslegen.

Neue Funktionen und Verbesserungen in PHP 8.4

Die neuen Funktionen, die in PHP 8.3 im letzten Jahr enthalten waren, werden dir im Vergleich zu den Neuerungen in 8.4 eher unscheinbar vorkommen:

Eigenschaftshaken

Eigenschaftshaken bieten einen völlig neuen Ansatz für den Umgang mit „Gettern“ und „Settern“ in der objektorientierten Programmierung (OOP) von PHP, mit dem du die Struktur deiner Klassendateien vereinfachen kannst.

Als Beispiel dafür, was Eigenschaftshaken ersetzen können, enthält die folgende einfache Klasse die Eigenschaften $size und $flavor. Sie haben private Sichtbarkeit, um sie vor direktem Zugriff außerhalb des resultierenden Objekts zu schützen. Deshalb vermitteln öffentliche Getter- und Setter-Methoden den Zugriff auf die Eigenschaften:

class Coffee
{
    private string $size;
    private string $flavor;
    public function __construct(string $size, string $flavor) {
        $this->size   = $size;
        $this->flavor = $flavor;
    }

    // "Setting" coffee size and flavor
    public function setSize(string $size): void {
        $this->size = $size;
    }
    public function setFlavor(string $flavor): void {
        $this->flavor = $flavor;
    }

    // "Getting" coffee size and flavor
    public function getSize(): string {
        return $this->size;
    }
    public function getFlavor(): string {
        return $this->flavor;
    }
} // End of class

// Make some coffee
$coffee = new Coffee('Small', 'Pumpkin Spice');
print $coffee->getSize() . ' ' . $coffee->getFlavor(); // Prints "Small Pumpkin Spice"

// Change order
$coffee->setSize('Grande');
$coffee->setFlavor('Mocha');
print $coffee->getSize() . ' ' . $coffee->getFlavor(); // Prints "Grande Mocha"

Vielleicht hat deine Klasse aber auch viele Eigenschaften, und statt viele Getter- und Setter-Methoden zu schreiben, nutzt du die magischen Methoden von PHP _get und _set. Du könntest die Dinge sogar in einer etwas chaotischen switch Anweisung wie diesem Auszug unten regeln.

// __set magic method example
public function __set(string $key, $value): void 
    switch ($key) {
        case 'size':
            $this->size = $value;
            break;
        case 'flavor':
            $this->flavor = $value;
            break;
        default:
            throw new InvalidArgumentException('Invalid input');
        }
}

// Later, we can change the coffee order like this:
$coffee->size = 'Grande';
$coffee->flavor = 'Mocha';

Für welchen Ansatz du dich auch entscheidest, je mehr Eigenschaften du in deiner Klasse hast, desto weiter entfernt sich der Code, mit dem du sie manipulierst, von ihren Definitionen am Anfang deiner Klassendatei. Außerdem können einige Implementierungen der magischen Methoden _get und _set unerwartet Zugriff auf private oder geschützte Eigenschaften deines Objekts geben, die du eigentlich nicht offenlegen wolltest.

Die neue Funktion Property Hooks bündelt die Getter- und Setter-Funktionen mit den Eigenschaften selbst. Im folgenden Beispiel mit den Eigenschaftshaken siehst du, dass die Eigenschaften $size und $flavor der Klasse Kaffee jetzt öffentlich sind. Außerdem haben wir den set Hooks eine grundlegende Validierung hinzugefügt, um sie von direkten Zuweisungen zu unterscheiden.

// Property definitions at the top of our Coffee class
class Coffee
{
    public string $flavor {
        set(string $value) {
            if (strlen($value) > 16) throw new InvalidArgumentException('Input is too long');
                $this->flavor = $value;
        }
    }

    public string $size {
        set(string $value) {
            if (! in_array($value, array(‘Small’, ‘Grande’))) throw new InvalidArgumentException('Not a valid size');
                $this->size = $value;
        }
    }

    // Rest of the Coffee class
}

// Define a coffee
$coffee = new Coffee();
$coffee->size = 'Grande';
$coffee->flavor = 'Pumpkin spice';

Wie du weiter unten sehen kannst, kann ein get Hook auch Funktionen in einen scheinbar gewöhnlichen Verweis auf eine Objekteigenschaft packen.

// Simplified Coffee class
class Coffee
{
    public string $flavor {
        get { 
            return $this->flavor . ' Spice';
       }
    }
}

// Create a flavor 
$coffee = new Coffee();
$coffee->flavor = 'Pumpkin'; // Stores the value "Pumpkin"
print $coffee->flavor;       // Prints "Pumpkin Spice"

Im Gegensatz zu den magischen PHP-Methoden können Eigenschaftshaken in Schnittstellen und abstrakten Klassen verwendet werden. Ein Beispiel für eine Schnittstelle:

interface Coffee
{
    public string $size { get; set; }
    public string $flavor { get; set; }
}

Asymmetrische Sichtbarkeit

Die öffentlich sichtbaren Getter- und Setter-Methoden, die wir uns vorhin angesehen haben, stellen den traditionellen Ansatz für den Zugriff auf private und geschützte Eigenschaften innerhalb ihrer Klassen dar.

Ein raffiniertes Feature von PHP 8.4 ist die Möglichkeit, dass eine Eigenschaft je nach Kontext, in dem auf sie zugegriffen wird, unterschiedliche Sichtbarkeitsstufen hat. So kann eine Eigenschaft öffentlich sein, wenn sie gelesen wird, aber privat oder geschützt, wenn sie gesetzt wird.

Schau dir das an:

class Coffee
{
    public private(set) string $flavor = 'Pumpkin Spice';
}

$coffee = new Coffee();
print $coffee->flavor;     // Prints "Pumpkin Spice"
$coffee->flavor = 'Mocha';  // Error (visibility)

Oben ist die Eigenschaft $flavor der Klasse öffentlich, außer in einem Einstellungskontext. Das ist schon ziemlich einfach, aber die asymmetrische Sichtbarkeit hat sogar eine kleine Abkürzung:

class Coffee
{
    // public is assumed when the context is not setting
    private(set) string $flavor = 'Pumpkin Spice';
}

Du kannst Eigenschaftshaken und asymmetrische Sichtbarkeit in Kombination verwenden, um eine enorme Flexibilität bei der Arbeit mit Objekteigenschaften mit verschiedenen Sichtbarkeiten zu erreichen.

Verkettung von new ohne Klammern

Apropos Abkürzungen: Für den Aufruf von new und die Verkettung von Methoden war es früher erforderlich, den Aufruf in Klammern zu setzen, etwa so:

$coffee = (new Coffee())->getFlavor()->getSize();

PHP 8.4 erlaubt dies:

$coffee = new Coffee()->getFlavor()->getSize();

Es mag wie eine kleine Änderung erscheinen, aber das Weglassen von nur zwei Klammern macht es viel einfacher zu lesen und zu debuggen.

Neue Funktionen zum Auffinden von Array-Elementen

Mit PHP 8.4 wurde die Funktion array_find() eingeführt, mit der Array-Elemente nach Elementen durchsucht werden können, die den in einer Callback-Funktion festgelegten Bedingungen entsprechen. Die Funktion gibt den Wert des ersten Elements zurück, das dem Test der Callback-Funktion entspricht.

Die neue Version enthält drei weitere verwandte Funktionen:

  • array_find_key(): Wie array_find(), aber der Rückgabewert ist der Schlüssel des übereinstimmenden Elements und nicht der Wert des Elements selbst.
  • array_all(): Gibt true zurück, wenn jedes Element im getesteten Array mit dem Test des Rückrufs übereinstimmt.
  • array_any(): Gibt true zurück, wenn mindestens eines der Elemente im Array mit dem Test des Callbacks übereinstimmt.

Beachte, dass die letzten beiden Funktionen boolesche Indikatoren anstelle von Array-Schlüsseln oder -Inhalten zurückgeben.

Hier sind einige kurze Beispiele:

$array = [
    'a' => 'Mocha',
    'b' => 'Caramel',
    'c' => 'Maple',
    'd' => 'Pumpkin'
   ];

// Find the first flavor name that is 5 characters long
var_dump(array_find($array, function (string $value) {
    return strlen($value) == 5;
})); // Returns “Mocha,” even though “Maple” is the same length 

// Find the array key for the first flavor with a name longer than 5 characters.
var_dump(array_find_key($array, function (string $value) {
    return strlen($value) > 5;
})); // Returns “b”

// Check to see if any flavor name is less than 5 characters long
var_dump(array_any($array, function (string $value) {
    return strlen($value) < 5;
})); // Returns false

// Check to see if all flavor names are shorter than 8 characters
var_dump(array_all($array, function (string $value) {
    return strlen($value) < 8;
})); // Returns true

HTML5-Parsing

HTM5 ist der defacto-Standard für die Struktur moderner Webseiten, aber die Parsing-Technologie von PHP für das Document Object Model (DOM) war bei HTML 4.01 stehen geblieben.

Anstatt die bestehende Klasse DOMDocument zu aktualisieren, die mit den älteren HTML-Standards arbeitet, bietet PHP 8.4 eine neue Klasse DomHTMLDocument, die HTM5-fähig ist.

Du kannst den Inhalt einer HTML5-Seite wie folgt importieren:

$document = DomHTMLDocument::createFromString($html)

Neben dem oben genannten createFromString($html) Konstruktor unterstützt die Klasse auch createFromFile($path) und createEmpty()

Der neue Parser erkennt semantische HTML5-Tags wie main, article und section, die den meisten von uns inzwischen vertraut sind.

Multibyte-Trim-Funktionen

Eine weitere Neuerung in PHP 8.4, die lange auf sich warten ließ, ist die Multibyte-Unterstützung in Trim-Funktionen:

  • mb_trim()
  • mb_ltrim()
  • mb_rtrim()

Wie die altbewährte PHP-Funktion trim() entfernt mb_trim Leerzeichen und einige Sonderzeichen wie Zeilenvorschübe von beiden Enden eines Strings, der Multibyte-Zeichen enthalten kann. Die anderen Funktionen schneiden entweder das linke oder das rechte Ende eines Strings ab.

Verwerfungen in PHP 8.4

Jede neue Version von PHP bringt eine lange Liste von Funktionen mit sich, von denen einige ziemlich obskur sind und die irgendwann aus der Plattform entfernt werden sollen. Eine der bekanntesten Abkündigungen in PHP 8.4 ist die Sitzungsverfolgung ohne Cookie.

Abschaffung von GET/POST-Sitzungen

Während Cookies im Allgemeinen die bevorzugte Methode zur Verfolgung von Benutzersitzungen sind, hat PHP die Fixierung von Sitzungs-ID-Daten in GET/POST-Parametern unterstützt. Um die Sitzungsverfolgung über Parameter in URLs zu ermöglichen, wird die PHP-Einstellung session.use_only_cookies deaktiviert und die Einstellung session.use_trans_sid kann aktiviert werden.

In PHP 8.4 führt jeder dieser Zustände der Einstellungen zu einer Veralterungswarnung, die in den Logs deiner Website erscheinen kann. Wenn PHP 9 veröffentlicht wird, werden diese Einstellungen nicht mehr verfügbar sein.

Andere Verwerfungen (und Entfernungen) in PHP 8.4

Im Folgenden findest du eine Liste der Funktionen, die das Team von PHP 8.4 abschaffen will. (Einige enthalten Links zu weiteren Informationen über die Funktionen)

  • Formal veraltete Eigenschaften DOMDocument und DOMEntity verwerfen.
  • DOMImplementation::getFeature($feature, $version) entfernen.
  • Die veraltete Konstante DOM_PHP_ERR.
  • Das abgelehnte „S“-Tag in unserialize().
  • Verwerfung von session.sid_length und session.sid_bits_per_character.
  • SplFixedArray::__wakeup() ablehnen.
  • Abzulehnen xml_set_object() und xml_set_*_handler() mit String-Methodennamen.
  • Verwerfung der Übergabe von null und false an dba_key_split().
  • Verwerfung der Übergabe falscher Datentypen für Optionen an ext/hash-Funktionen.
  • Verwerfung der Konstanten SUNFUNCS_RET_STRING, SUNFUNCS_RET_DOUBLE, SUNFUNCS_RET_TIMESTAMP.
  • Verwerfung des proprietären CSV-Escaping-Mechanismus.
  • Die Konstante E_STRICT wird abgelehnt.
  • strtok() abzulehnen.
  • Die Rückgabe von Nicht-String-Werten aus einem User Output Handler ist abzulehnen.
  • Abgelehnt wird die Erzeugung von Ausgaben in einem User Output Handler.
  • file_put_contents() mit $data als Array ablehnen.
  • mysqli_ping() und mysqli::ping() ablehnen.
  • mysqli_refresh() verwerfen.
  • mysqli_kill() ablehnen.
  • Den zweiten Parameter von mysqli_store_result() verwerfen.
  • lcg_value()ablehnen.
  • uniqid()ablehnen.
  • md5(), sha1(), md5_file()und sha1_file() verwerfen.
  • Die Übergabe von E_USER_ERROR an trigger_error() verwerfen.
  • Die Verwendung eines einzelnen Unterstrichs („_“) als Klassenname ablehnen.
  • Die Konstante SOAP_FUNCTIONS_ALL und ihre Übergabe an SoapServer::addFunction() wird abgelehnt.

Zusammenfassung

PHP 8.4 bringt einige interessante Änderungen mit sich. Wir freuen uns darauf, diese Version bald für unser jährliches PHP-Benchmarking – unsere Tests mit verschiedenen PHP-basierten Content-Management-Systemen – auf unsere Server zu bringen.

Außerdem sind wir gespannt, wann die Entwicklerinnen und Entwickler damit beginnen, einige der neuen Funktionen von PHP 8.4 in ihre Projekte einzubauen, insbesondere die Property Hooks.

Welche Funktionen von PHP 8.4 sind deine Favoriten? Teile deine Meinung mit unserer Community in den Kommentaren!

Steve Bonisteel Kinsta

Steve Bonisteel is Technical Editor bij Kinsta. Hij begon zijn schrijverscarrière als verslaggever en achtervolgde ambulances en brandweerwagens. Sinds eind jaren negentig schrijft hij over internetgerelateerde technologie.