Was ist neu in PHP 7.4 (Features, Verwerfungen, Geschwindigkeit)

PHP 7.4, das nächste PHP 7 Minor Release, wurde am 28. November 2019 für die allgemeine Verfügbarkeit freigegeben. Es ist also Zeit für uns, in einige der aufregendsten Erweiterungen und neuen Funktionen einzutauchen, die PHP schneller und zuverlässiger gemacht haben werden.

Update: PHP 8.1 (offizielles Release) ist jetzt für alle Kunden von Kinsta verfügbar. PHP 7.4 wird von Kinsta nicht mehr unterstützt. Bitte beachte, dass wir die PHP-Versionen 8.1, 8.2 und 8.3 unterstützen.

Wenn PHP 7.4 die Leistung deutlich steigert und die Code-Lesbarkeit verbessert, wird PHP 8 der eigentliche Meilenstein für die PHP-Performance sein, da der Vorschlag zur JIT-Einbindung bereits genehmigt wurde.

Wie auch immer, heute durchlaufen wir einige der interessantesten Features und Änderungen, die wir mit PHP 7.4 erwarten. Nur für die Akten, das waren die wichtigen Daten für die Version 7.4:

• 6. Juni 2019: PHP 7.4 Alpha 1
• 18. Juli 2019: PHP 7.4 Beta 1 – Einfrieren von Funktionen
• 28. November 2019: PHP 7.4 GA Freigabe

Die vollständige Liste der Features und Ergänzungen findest du auf der offiziellen RFC-Seite.

Was ist neu in PHP mit PHP 7.4?

In diesem Beitrag behandeln wir einige Änderungen und Funktionen, die der Sprache mit der endgültigen Version von PHP 7.4 hinzugefügt werden sollten:

Vergesse array_merge: PHP 7.4 bringt den Spread-Operator in Array-Ausdruck

Seit PHP 5.6 verfügbar, ist das Entpacken von Argumenten eine Syntax zum Entpacken von Arrays und Traversables in Argumentenlisten. Um ein Array oder ein Traversable zu entpacken, muss es mit … (3 Punkten) vorangestellt werden, wie im folgenden Beispiel gezeigt:

function test(...$args) { var_dump($args); }
test(1, 2, 3);

Nun schlägt dieser PHP 7.4 RFC vor, diese Funktion auf Array-Definitionen auszudehnen:

$arr = [...$args];

Der erste erklärte Vorteil des Spread Operators im Array-Ausdruck ist die Leistung. In der Tat, so heißt es in der RFC-Dokumentation:

Spread-Operator sollte eine bessere Performance haben als array_merge. Das liegt nicht nur daran, dass der Spread-Operator eine Sprachstruktur ist, während array_merge eine Funktion ist, sondern auch daran, dass die Kompilierzeitoptimierung für konstante Arrays performant sein kann.

Ein wesentlicher Vorteil des Spread-Operators ist, dass er alle durchquerbaren Objekte unterstützt, während die Funktion array_merge nur Arrays unterstützt.

Hier ist ein Beispiel für das Entpacken von Argumenten im Array-Ausdruck:

$parts = ['apple', 'pear'];
$fruits = ['banana', 'orange', ...$parts, 'watermelon'];
var_dump($fruits);

Wenn du diesen Code mit in PHP 7.3 oder früher ausführst, löst PHP einen Parse-Fehler aus:

Parse error: syntax error, unexpected '...' (T_ELLIPSIS), expecting ']' in /app/spread-operator.php on line 3

Stattdessen würde PHP 7.4 ein Array zurückgeben:

array(5) {
	[0]=>
	string(6) "banana"
	[1]=>
	string(6) "orange"
	[2]=>
	string(5) "apple"
	[3]=>
	string(4) "pear"
	[4]=>
	string(10) "watermelon"
}

Der RFC besagt, dass wir das gleiche Array mehrfach erweitern können. Außerdem können wir die Syntax des Spread Operators überall im Array verwenden, da normale Elemente vor oder nach dem Spread Operator hinzugefügt werden können. Der folgende Code wird also so funktionieren, wie wir es erwarten können:

$arr1 = [1, 2, 3];
$arr2 = [4, 5, 6];
$arr3 = [...$arr1, ...$arr2];
$arr4 = [...$arr1, ...$arr3, 7, 8, 9];

Es ist auch möglich, Arrays, die von einer Funktion zurückgegeben werden, direkt in ein neues Array zu entpacken:

function buildArray(){
	return ['red', 'green', 'blue'];
}
$arr1 = [...buildArray(), 'pink', 'violet', 'yellow'];

PHP 7.4 gibt das folgende Array aus:

array(6) {
	[0]=>
	string(3) "red"
	[1]=>
	string(5) "green"
	[2]=>
	string(4) "blue"
	[3]=>
	string(4) "pink"
	[4]=>
	string(6) "violet"
	[5]=>
	string(6) "yellow"
}

Wir können auch die Generatorsyntax verwenden:

function generator() {
	for ($i = 3; $i <= 5; $i++) {
		yield $i;
	}
}
$arr1 = [0, 1, 2, ...generator()];

Es ist uns jedoch nicht gestattet, Arrays zu entpacken, die als Referenz übergeben werden. Betrachte das folgende Beispiel:

$arr1 = ['red', 'green', 'blue'];
$arr2 = [...&$arr1];

Wenn wir versuchen würden, ein Array per Referenz zu entpacken, löst PHP den folgenden Parse-Fehler aus:

Parse error: syntax error, unexpected '&' in /app/spread-operator.php on line 3

Jedenfalls, wenn die Elemente des ersten Arrays durch Referenz gespeichert werden, werden sie auch durch Referenz im zweiten Array gespeichert. Hier ist ein Beispiel:

$arr0 = 'red';
$arr1 = [&$arr0, 'green', 'blue'];
$arr2 = ['white', ...$arr1, 'black'];

Und hier ist, was wir mit PHP 7.4 erreichen:

array(5) {
	[0]=>
	string(5) "white"
	[1]=>
	&string(3) "red"
	[2]=>
	string(5) "green"
	[3]=>
	string(4) "blue"
	[4]=>
	string(5) "black"
}

Der Vorschlag des Spread-Betreibers wurde mit 43 zu 1 Stimmen angenommen.

Arrow Functions 2.0 (Short Closures)

In PHP gelten anonyme Funktionen als recht ausführlich und schwer zu implementieren und zu warten. Dieser RFC schlägt die Einführung der kürzeren und klareren Syntax der Arrow Functions (oder Short Closures) vor, die es uns ermöglichen sollte, unseren PHP-Code deutlich zu bereinigen.

Betrachte das folgende Beispiel:

function cube($n){
	return ($n * $n * $n);
}
$a = [1, 2, 3, 4, 5];
$b = array_map('cube', $a);
print_r($b);

PHP 7.4 erlaubt es, eine präzisere Syntax zu verwenden, und die obige Funktion könnte wie folgt umgeschrieben werden:

$a = [1, 2, 3, 4, 5];
$b = array_map(fn($n) => $n * $n * $n, $a);
print_r($b);

Derzeit können anonyme Funktionen (Closures) Variablen, die im übergeordneten Bereich definiert sind, dank des use Language Konstrukts erben, wie unten gezeigt:

$factor = 10;
$calc = function($num) use($factor){
	return $num * $factor;
};

Aber mit PHP 7.4 werden Variablen, die im übergeordneten Bereich definiert sind, implizit durch Wert erfasst (implizite Bindung nach Wert). So können wir die gesamte oben beschriebene Funktion in eine einzige Zeile schreiben:

$factor = 10;
$calc = fn($num) => $num * $factor;

Die im übergeordneten Bereich definierte Variable kann in der Pfeilfunktion genauso verwendet werden, als ob wir ($var) verwenden würden, und es ist nicht möglich, eine Variable aus dem übergeordneten Bereich zu ändern.

Die neue Syntax ist eine große Verbesserung der Sprache, da sie es uns ermöglicht, besser lesbaren und wartbaren Code zu erstellen. Wir können auch Parameter- und Rückgabetypen, Standardwerte, Argumentlisten mit variabler Länge (variadische Funktionen) verwenden, wir können übergeben und per Referenz zurückkehren, etc. Schließlich können Short Closures auch in Klassenmethoden verwendet werden, und sie können die Variable $this wie normale Closures verwenden.

Dieser RFC wurde mit 51 bis 8 Stimmen genehmigt, so dass wir davon ausgehen können, dass er Teil der PHP 7.4 Ergänzungen sein wird.

Null Coalescing Assignment Operator

In PHP 7 hinzugefügt, ist der Koaleszenzoperator (??) praktisch, wenn wir einen ternären Operator in Verbindung mit isset() verwenden müssen. Es gibt den ersten Operanden zurück, wenn er existiert und ist nicht NULL. Andernfalls gibt es den zweiten Operanden zurück. Hier ist ein Beispiel:

$username = $_GET['user'] ?? 'nobody';

Was dieser Code tut, ist ziemlich einfach: Er holt den Anforderungsparameter und setzt einen Standardwert, wenn er nicht existiert. Die Bedeutung dieser Zeile ist klar, aber was wäre, wenn wir viel längere Variablennamen wie in diesem Beispiel aus dem RFC hätten?

$this->request->data['comments']['user_id'] = $this->request->data['comments']['user_id'] ?? 'value';

Auf lange Sicht könnte dieser Code etwas schwierig zu pflegen sein. Um Entwicklern zu helfen, intuitiveren Code zu schreiben, schlägt dieser RFC die Einführung des null coalescing assignment operator (??=) vor. Anstatt also den vorherigen Code zu schreiben, könnten wir folgendes schreiben:

$this->request->data['comments']['user_id'] ??= 'value';

Wenn der Wert des linken Parameters null ist, dann wird der Wert des rechten Parameters verwendet. Beachte, dass der Koaleszenzoperator zwar ein Vergleichsoperator ist, aber ??= ein Zuordnungsoperator ist.

Dieser Vorschlag wurde mit 37 zu 4 Stimmen angenommen.

Typisierte Eigenschaften 2.0

Argumenttypdeklarationen oder Typhinweise ermöglichen es, den Typ einer Variablen anzugeben, der voraussichtlich an eine Funktion oder eine Klassenmethode übergeben wird. Typ-Hinweise sind eine Funktion, die seit PHP 5 verfügbar ist, und seit PHP 7.2 können wir sie mit dem object-datentyp verwenden. Jetzt bringt PHP 7.4 Type Hinting einen Schritt voran, indem es die Unterstützung für erstklassige Property Type Declarations hinzufügt. Hier ist ein sehr einfaches Beispiel:

class User {
	public int $id;
	public string $name;
}

Es werden alle Typen unterstützt, mit Ausnahme von void und callable:

public int $scalarType;
protected ClassName $classType;
private ?ClassName $nullableClassType;

Der RFC erklärt den Grund, warum void und callable nicht unterstützt werden:

Der Void Typ wird nicht unterstützt, da er nicht nützlich ist und eine unklare Semantik hat.

Der Callable Type wird nicht unterstützt, da sein Verhalten kontextabhängig ist.

Also können wir bool, int, float, string, array, object, iterable, self, parent, jeden Klassen- oder Interface-Namen und nullable Typen (?type) verwenden.

Typen können für statische Eigenschaften verwendet werden:

public static iterable $staticProp;

Sie sind auch mit der var-Notation erlaubt:

var bool $flag;

Es ist möglich, Standardeigenschaftenwerte festzulegen, die natürlich mit dem deklarierten Eigenschaftentyp übereinstimmen müssen, aber nur nullbare Eigenschaften können einen Standard-null-wert haben:

public string $str = "foo";
public ?string $nullableStr = null;

Der gleiche Typ gilt für alle Eigenschaften in einer einzigen Deklaration:

public float $x, $y;

Was passiert, wenn wir einen Fehler machen? Beachte den folgenden Code:

class User {
	public int $id;
	public string $name;
}

$user = new User;
$user->id = 10;
$user->name = [];

Im obigen Code haben wir einen Zeichenketten-Eigenschaftstyp deklariert, aber wir haben ein Array als Eigenschaftswert gesetzt. In einem solchen Szenario erhalten wir den folgenden Fatalen Fehler:

Fatal error: Uncaught TypeError: Typed property User::$name must be string, array used in /app/types.php:9

Dieser RFC wurde mit 70 zu 1 Stimmen genehmigt.

Weak References

Mit diesem RFC führt PHP 7.4 die Klasse WeakReference ein, die es Programmierern ermöglicht, eine Referenz auf ein Objekt zu behalten, das nicht verhindert, dass das Objekt selbst zerstört wird.

Derzeit unterstützt PHP Schwache Referenzen, indem es eine Erweiterung wie pecl-weakref verwendet. Wie auch immer, die neue API unterscheidet sich von der dokumentierten WeakRef-Klasse.

Hier ist ein Beispiel vom Autor dieses Vorschlags, Nikita Popov:

$object = new stdClass;
$weakRef = WeakReference::create($object);

var_dump($weakRef->get());
unset($object);
var_dump($weakRef->get());

Der erste var_dump druckt das object(stdClass)#1 (0) {}, während der zweite var_dump NULL druckt, da das referenzierte Objekt zerstört wurde.

Slides for my PHP 7.4 talk at #PHPRussia2019. Was a great conference!https://t.co/zLr9Bj2aKl

— Nikita Popov (@nikita_ppv) May 19, 2019

Dieser RFC wurde mit 28 zu 5 Stimmen verabschiedet.

Kovariante Rückgaben und Kontravariante Parameter

Varianz ist eine Eigenschaft von Klassenhierarchien, die beschreibt, wie sich die Typen eines Typkonstruktors auf Subtypen auswirken. Im Allgemeinen kann ein Typkonstruktor sein:

• Invariant: Wenn der Typ des Supertyps den Typ des Subtyps einschränkt.
• Kovariant: wenn die Reihenfolge der Typen beibehalten wird (Typen werden von spezifischer zu generischer geordnet).
• Kontravariant: wenn sie die Reihenfolge umkehrt (Typen werden von generischer zu spezifischer bestellt).

Derzeit hat PHP mit wenigen Ausnahmen meist invariante Parameter- und Rückgabetypen. Dieser RFC schlägt vor, Kovarianz und Kontravarianz für Parametertypen und Rückgabetypen zuzulassen und bietet mehrere Beispiele für Code.

Hier ist ein Beispiel für den kovarianten Rückgabetyp:

interface Factory {
	function make(): object;
}

class UserFactory implements Factory {
	function make(): User;
}

Und hier ist ein Beispiel für einen kontravarianten Parametertyp:

interface Concatable {
	function concat(Iterator $input); 
}
 
class Collection implements Concatable {
	// accepts all iterables, not just Iterator
	function concat(iterable $input) {/* . . . */}
}

Siehe RFC für einen genaueren Blick auf Kovarianz und Kontravarianz in PHP 7.4.

Dieser RFC wurde mit 39 zu 1 Stimmen verabschiedet.

Preloading

Dieser Vorschlag von Dmitri Stogov ist einer unserer Favoriten, weil er eine deutliche Leistungssteigerung bringen sollte. Preloading ist der Prozess des Ladens von Bibliotheken und Frameworks in den OPCache bei der Modulinitialisierung (lese mehr über den PHP-Lebenszyklus).

Hier ist, wie das Vorladen mit den Worten von Dmitry funktioniert:

Beim Start des Servers – bevor ein Anwendungscode ausgeführt wird – können wir einen bestimmten Satz von PHP-Dateien in den Speicher laden – und deren Inhalt für alle nachfolgenden Anfragen, die von diesem Server bedient werden, „permanent verfügbar“ machen. Alle in diesen Dateien definierten Funktionen und Klassen stehen für Anfragen sofort zur Verfügung, genau wie interne Einheiten.

Diese Dateien werden beim Start des Servers geladen, vor jeder Anwendung ausgeführt und bleiben für zukünftige Anfragen verfügbar. Das ist großartig in Bezug auf die Leistung.

Das Preloading wird durch eine spezielle php.ini Anweisung gesteuert: opcache.preload. Diese Anweisung spezifiziert ein PHP-Skript, das beim Start des Servers kompiliert und ausgeführt wird. Diese Datei kann verwendet werden, um zusätzliche Dateien vorzuladen, entweder inklusive oder über die Funktion opcache_compile_file() (lese mehr über die PHP-Dokumentation).

Aber es gibt einen Nachteil. Tatsächlich wird im RFC ausdrücklich darauf hingewiesen:

vorgeladene Dateien bleiben im Opcache-Speicher für immer zwischengespeichert. Die Änderung der entsprechenden Quelldateien hat ohne einen erneuten Serverneustart keine Auswirkungen.

Alle Funktionen, die in vorgeladenen Dateien definiert sind, werden jedoch dauerhaft in PHP-Funktions- und Klassentabellen geladen und bleiben für jede zukünftige Anforderung verfügbar. Dies wird zu guten Leistungssteigerungen führen, auch wenn diese Verbesserungen erheblich variabel sein können.

Mehr über die Einschränkungen und Ausnahmen des Preloading erfährst du auf der offiziellen Preloading RFC-Seite.

Neuer Mechanismus zur Serialisierung benutzerdefinierter Objekte

Dies ist ein weiterer Vorschlag von Nikita Popov, der mit großer Mehrheit angenommen wurde.

Derzeit haben wir zwei verschiedene Mechanismen für die benutzerdefinierte Serialisierung von Objekten in PHP:

• Die magischen Methoden __sleep() und __wakeup()
• Die Serializable Schnittstelle

Laut Nikita haben beide Optionen Probleme, die zu komplexem und unzuverlässigem Code führen. Im RFC kannst du tief in dieses Thema eintauchen. Hier erwähne ich nur, dass der neue Serialisierungsmechanismus diese Probleme verhindern sollte, indem er zwei neue magische Methoden zur Verfügung stellt, __serialize() und __unserialize(), die die beiden bestehenden Mechanismen kombinieren.

Dieser Vorschlag wurde mit 20 zu 7 Stimmen angenommen.

Verwerfungen

Die folgenden Funktionen/Funktionalitäten werden mit PHP 7.4 veraltet sein. Eine umfassendere Liste der Verwerfungen findest du in PHP 7.4 Upgrade Notes.

Ändern der Priorität des Verknüpfungsoperators

Derzeit werden in PHP die arithmetischen Operatoren „+“ und „-“ und der Zeichenkettenoperator „.“ assoziativ belassen und haben den gleichen Vorrang (lese mehr über die Operatorpriorität).

Betrachte als Beispiel die folgende Zeile:

echo "sum: " . $a + $b;

In PHP 7.3 erzeugt dieser Code die folgende Warnung:

Warning: A non-numeric value encountered in /app/types.php on line 4

Denn die Verkettung wird von links nach rechts ausgewertet. Es ist dasselbe wie das Schreiben des folgenden Codes:

echo ("sum: " . $a) + $b;

Dieser RFC schlägt vor, die Priorität von Operatoren zu ändern, indem er „…“ eine niedrigere Priorität als „+“ und „-“ Operatoren gibt, so dass Additionen und Subtraktionen immer vor der Zeichenkettenverkettung durchgeführt werden. Diese Codezeile sollte mit der folgenden übereinstimmen:

echo "sum: " . ($a + $b);

Dies ist ein zweistufiger Vorschlag:

• Ab Version 7.4 sollte PHP einen Verfallshinweis ausgeben, wenn es auf einen unklammerten Ausdruck mit „+“, „-“ und „.“ trifft.
• Die tatsächliche Änderung der Priorität dieser Operatoren sollte mit PHP 8 hinzugefügt werden.

In beiden Fällen wurden die Vorschläge mit großer Mehrheit angenommen.

Verwerfen des links-assoziativen ternären Operator

In PHP ist der ternäre Operator, im Gegensatz zu vielen anderen Sprachen, links-assoziativ. Laut Nikita Popof kann dies für Programmierer, die zwischen verschiedenen Sprachen wechseln, verwirrend sein.

Derzeit ist in PHP der folgende Code korrekt:

$b = $a == 1 ? 'one' : $a == 2 ? 'two' : $a == 3 ? 'three' : 'other';

Es wird interpretiert als:

$b = (($a == 1 ? 'one' : $a == 2) ? 'two' : $a == 3) ? 'three' : 'other';

Und das könnte zu Fehlern führen, weil es vielleicht nicht das ist, was wir vorhaben zu tun. Dieser RFC schlägt also vor, die Verwendung von Linksassoziativität für ternäre Operatoren zu verwerfen und zu entfernen und Entwickler zu zwingen, Klammern zu verwenden.

Dies ist ein weiterer zweistufiger Vorschlag:

• Ab PHP 7.4 werden verschachtelte Ternaries ohne explizite Verwendung von Klammern eine Verfallswarnung auslösen.
• Ab PHP 8.0 gibt es einen Kompilier-Laufzeitfehler.

Dieser Vorschlag wurde mit 35 bis 10 Stimmen angenommen.

Was bedeutet PHP 7.4 für WordPress-Benutzer?

PHP ist die am weitesten verbreitete serverseitige Programmiersprache im Web. Laut W3Techs wird PHP seit dem 2. Dezember 2019 von 78,9% aller Websites verwendet, deren serverseitige Programmiersprache sie erkennen können. PHP Nutzung.

Leider wird PHP 5 immer noch von 44,0% aller Websites mit einer bekannten serverseitigen Programmiersprache verwendet. Wenn du die Anzahl der Benutzer hinzufügst, die noch PHP 7.0 und 7.1 verwenden, stellt sich heraus, dass eine große Mehrheit der Websites nicht unterstützte Versionen von PHP ausführen.

Laut der offiziellen WordPress Stats Seite, zum Zeitpunkt des Schreibens, satte 64% aller WordPress Websites laufen auf nicht unterstützten Versionen von PHP. Nur etwas mehr als 13% verwenden PHP 7.3. Und die neueste Version, PHP 7.4, ist noch nicht einmal zu sehen. Du kannst sehen, dass die große Mehrheit der Benutzer, über 23%, immer noch mit PHP 5.6 arbeiten. WordPress PHP Versionen Statistik

Wir empfehlen dir dringend, deinen Host nach einer unterstützten Version von PHP zu fragen, vorzugsweise nach den offiziellen Anforderungen von WordPress. Zum Zeitpunkt dieses Schreibens, Mai 2019, benötigt WordPress:

• PHP Version 7.3 oder höher
• MySQL Version 5.6 oder höher OR MariaDB Version 10.1 oder höher
• HTTPS-Unterstützung

PHP 7 Leistung

Die obigen Zahlen sind besonders entmutigend aus Performance-Sicht, da sich PHP 7 als wesentlich schneller erwiesen hat. Hier sind ein paar Statistiken:

• Offizielle PHP-Benchmarks zeigen, dass PHP 7 es dem System ermöglicht, doppelt so viele Anfragen pro Sekunde im Vergleich zu PHP 5.6 bei fast der Hälfte der Latenzzeit auszuführen.
• Christian Vigh veröffentlichte auch einen PHP-Leistungsvergleich, in dem er feststellte, dass PHP 5.2 400% langsamer war als PHP 7.
• Andrei Avram sah schnellere Ausführungszeiten und weniger Speicherverbrauch in PHP 7.4 gegenüber PHP 7.3.
• Phoronix führte einige frühe Benchmark-Tests mit PHP 7.4 Alpha durch und stellte fest, dass es etwas schneller war als PHP 7.3.

Upgraded my @kinsta site to PHP 7.4 and it is like 10x faster. Woot!

— Ronald Huereca (@RonaldHuereca) December 2, 2019

Wir haben unsere eigenen PHP-Leistungsbenchmarks mit PHP 7.3 durchgeführt. Wir haben gesehen, dass WordPress 5.0 auf PHP 7.3 fast dreimal so viele Transaktionen (Anfragen) pro Sekunde ausführen kann wie PHP 5.6. Wir werden in Kürze PHP 7.4 Benchmarks veröffentlichen!

• WordPress 5.0 PHP 5.6 Benchmark: 91,64 req/sec
• WordPress 5.0 PHP 7.0 Benchmark-Ergebnisse: 206.71 req/sec
• WordPress 5.0 PHP 7.1 Benchmark-Ergebnisse: 210,98 req/sec
• WordPress 5.0 PHP 7.2 Benchmark-Ergebnisse: 229.18 req/sec
• WordPress 5.0 PHP 7.3 Benchmark-Ergebnisse: 253.20 req/sec🏆

Viele sind langsam zu aktualisieren, einfach wegen der Zeit, die mit dem Testen neuer all ihrer Plugins und Designs von Drittanbietern verbunden ist, um sicherzustellen, dass sie ordnungsgemäß funktionieren. Aber oft kommt es darauf an, dass sie es einfach noch nicht getan haben.

Überprüfe deine PHP-Version

Du bist dir nicht sicher, welche Version von PHP du verwendest? Eine der einfachsten Möglichkeiten, dies zu überprüfen, ist die Verwendung eines Tools wie Pingdom oder Google Chrome Devtools. Der erste HTTP-Request-Header zeigt dir typischerweise die Version an.

Dies setzt voraus, dass der Host den X-Powered-By Header-Wert nicht ändert. Viele tun dies jedoch aus Sicherheitsgründen (einschließlich Kinsta). Wenn ja, siehst du möglicherweise deine PHP-Version nicht. In diesem Fall, wenn du WordPress 5.2 oder höher ausführst, gibt es ein neues Site Health Tool, das du verwenden kannst. Gehe zu „Tools“ → „Site Health“ → „Info“ und unter dem Abschnitt „Server“ findest du die PHP-Version deines Servers.

Alternativ kannst du auch ein kostenloses Plugin wie Version Info installieren, das dir einige grundlegende Serverinformationen in der Fußzeile deines WordPress Admin Dashboards anzeigt. Ein paar andere Möglichkeiten, deine PHP-Version zu sehen, sind das Hochladen einer Datei per FTP oder einfach die Kontaktaufnahme mit deinem Host und die Frage.

Aktualisierung auf PHP 7.4

Die endgültige Version von PHP 7.4 ist ab sofort bei Kinsta erhältlich. Alternativ kannst du deine WordPress-Seite lokal testen oder deine Skripte in einer Umgebung wie Docker überprüfen, die es dir ermöglicht, verschiedene Versionen von PHP von der Kommandozeile aus zu testen.

Der einfachste Weg, mit dem Testen zu beginnen, besteht darin, eine Stagingumgebung zu erstellen, da diese sehr ähnlich wie deine Live-Seite ist. Klicke im MyKinsta Dashboard auf deine Seite und ändere die Umgebung auf Staging.

Stelle dann unter dem Menü „Tools“ deine PHP-Engine auf PHP 7.4 um. Du kannst dann mit dem Testen beginnen, um die Kompatibilität von Code, Plugins von Drittanbietern und Designs sicherzustellen.

Wie bei früheren Versionen von PHP unterstützt unsere selbstheilende PHP-Funktion PHP 7.4 vollständig. Sollte PHP aus irgendeinem Grund ausfallen, werden wir es automatisch neu starten. Wenn der Neustart das Problem nicht behebt, wird unser Überwachungssystem unser Systemadministrator-Team benachrichtigen, um die Ursache des Problems zu untersuchen.

Einzelheiten zur Veröffentlichung von PHP 7.4 findest du bei Kinsta.

Installation und Ausführung von PHP 7.4 auf Docker

Willst du es auf Docker testen? Glücklicherweise musst du PHP 7.4 nicht manuell kompilieren und konfigurieren. Wenn du bereits Docker auf deinem System installiert hast, musst du nur das inoffizielle PHP-FPM 7.4 Docker Image installieren und deine Tests von der Kommandozeile aus in wenigen Sekunden ausführen.

Wenn du es vorziehst, deinen PHP 7.4-Code in deinem Browser auszuführen, musst du auch ein Nginx- oder Apache-Image installieren. Aber keine Sorge. Folge einfach den Anweisungen des Entwicklers. Kopiere und füge die Befehle von der Docker Image-Seite in dein Kommandozeilen-Tool ein, und schon kannst du loslegen.

Zusammenfassung

In diesem Beitrag haben wir eine ganze Reihe von Änderungen und Ergänzungen behandelt, die wir mit der Veröffentlichung von PHP 7.4 erwarten können. Wenn du die vollständige Liste der Funktionen zusammen mit der offiziellen RFC-Dokumentation suchst, schau dir die folgenden Ressourcen an:

• PHP 7.4 Anfragen für Kommentare
• PHP 7.4 Upgrade Hinweise
• PHP 7.4 Vorbereitungsaufgaben

Wir halten dich auf dem Laufenden mit den neuesten Informationen zu PHP 7.4. Wenn du ein Kinsta-Kunde bist, kannst du schon jetzt deine WordPress-Seiten auf die neueste Version umstellen.

Bist du bereit, die kommenden PHP-Funktionen zu testen? Welches ist dein Favorit? Teile deine Gedanken mit uns in den Kommentaren unten.