{"id":43724,"date":"2021-10-05T10:04:40","date_gmt":"2021-10-05T08:04:40","guid":{"rendered":"https:\/\/kinsta.com\/?p=100177"},"modified":"2023-07-27T11:41:21","modified_gmt":"2023-07-27T10:41:21","slug":"transpilierung-php","status":"publish","type":"post","link":"https:\/\/kinsta.com\/de\/blog\/transpilierung-php\/","title":{"rendered":"Der ultimative Leitfaden f\u00fcr die Transpilierung von PHP-Code"},"content":{"rendered":"

Im Idealfall sollten wir PHP 8.0<\/a> (die neueste Version zum Zeitpunkt der Erstellung dieses Artikels) f\u00fcr all unsere Webseiten verwenden und es aktualisieren, sobald eine neue Version ver\u00f6ffentlicht wird. Allerdings m\u00fcssen Entwickler oft mit fr\u00fcheren PHP-Versionen arbeiten, z. B. wenn sie ein \u00f6ffentliches Plugin f\u00fcr WordPress<\/a> erstellen oder mit veraltetem Code arbeiten, der eine Aktualisierung der Webserver-Umgebung verhindert.<\/p>\n

In diesen Situationen k\u00f6nnten wir die Hoffnung aufgeben, den neuesten PHP-Code zu verwenden. Aber es gibt eine bessere Alternative: Wir k\u00f6nnen unseren Quellcode immer noch mit PHP 8.0 schreiben und ihn in eine fr\u00fchere PHP-Version transpilieren – sogar in PHP 7.1.<\/p>\n

In diesem Leitfaden erf\u00e4hrst du alles, was du \u00fcber das Transpilieren von PHP-Code wissen musst.<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Was ist Transpilieren?<\/h2>\n

Beim Transpilieren wird der Quellcode einer Programmiersprache<\/a> in einen gleichwertigen Quellcode der gleichen oder einer anderen Programmiersprache umgewandelt.<\/p>\n

Transpilieren ist kein neues Konzept in der Webentwicklung: Client-seitige Entwickler\/innen werden wahrscheinlich mit Babel<\/a>, einem Transpiler f\u00fcr JavaScript-Code, vertraut sein.<\/p>\n

Babel wandelt JavaScript-Code von der modernen ECMAScript 2015+ Version in eine Legacy-Version um, die mit \u00e4lteren Browsern kompatibel ist. Nehmen wir zum Beispiel eine ES2015-Pfeilfunktion:<\/p>\n

[2, 4, 6].map((n) => n * 2);\n<\/code><\/pre>\n
…wandelt Babel es in seine ES5-Version um:<\/p>\n
[2, 4, 6].map(function(n) {\n  return n * 2;\n});\n<\/code><\/pre>\n
Was ist Transpiling PHP?<\/h3>\n
Eine potenzielle Neuheit in der Webentwicklung ist die M\u00f6glichkeit, serverseitigen Code, insbesondere PHP, zu transpilieren.<\/p>\n
Das Transpilieren von PHP funktioniert auf die gleiche Weise wie das Transpilieren von JavaScript: Der Quellcode einer modernen PHP-Version<\/a> wird in einen entsprechenden Code f\u00fcr eine \u00e4ltere PHP-Version umgewandelt.<\/p>\n
Nach dem gleichen Beispiel wie zuvor, eine Pfeilfunktion aus PHP 7.4:<\/p>\n
$nums = array_map(fn($n) => $n * 2, [2, 4, 6]);\n<\/code><\/pre>\n
…kann in die entsprechende PHP 7.3 Version transpiliert werden:<\/p>\n
$nums = array_map(\n  function ($n) {\n    return $n * 2;\n  },\n  [2, 4, 6]\n);\n<\/code><\/pre>\n
Pfeilfunktionen k\u00f6nnen transpiliert werden, weil sie syntaktischer Zucker<\/a> sind, d.h. eine neue Syntax, um ein bestehendes Verhalten zu erzeugen. Das ist die niedrig h\u00e4ngende Frucht.<\/p>\n
Es gibt jedoch auch neue Funktionen, die ein neues Verhalten erzeugen, und als solche gibt es keinen entsprechenden Code f\u00fcr fr\u00fchere PHP-Versionen. Das ist der Fall bei den Union-Typen<\/a>, die in PHP 8.0 eingef\u00fchrt wurden:<\/p>\n
function someFunction(float|int $param): string|float|int|null\n{\n  \/\/ ...\n}\n<\/code><\/pre>\n
In diesen Situationen kann die Transpilierung trotzdem durchgef\u00fchrt werden, solange das neue Feature f\u00fcr die Entwicklung, aber nicht f\u00fcr die Produktion ben\u00f6tigt wird. Dann k\u00f6nnen wir das Feature einfach ganz aus dem transpilierten Code entfernen, ohne dass es ernsthafte Konsequenzen hat.<\/p>\n
Ein solches Beispiel sind Union-Typen. Diese Funktion wird verwendet, um zu pr\u00fcfen, dass es keine Unstimmigkeiten zwischen dem Eingabetyp und dem bereitgestellten Wert gibt, was hilft, Fehler zu vermeiden. Wenn es einen Konflikt mit den Typen gibt, entsteht bereits in der Entwicklung ein Fehler, und wir sollten ihn abfangen und beheben, bevor der Code in die Produktion gelangt.<\/p>\n
Daher k\u00f6nnen wir es uns leisten, die Funktion aus dem Code f\u00fcr die Produktion zu entfernen:<\/p>\n
function someFunction($param)\n{\n  \/\/ ...\n}\n<\/code><\/pre>\n
Wenn der Fehler in der Produktion trotzdem auftritt, wird die Fehlermeldung weniger pr\u00e4zise sein als bei Union-Typen. Dieser potenzielle Nachteil wird jedoch dadurch aufgewogen, dass wir \u00fcberhaupt Union-Typen verwenden k\u00f6nnen.<\/p>\n\n
Vorteile der Transpilierung von PHP-Code<\/h2>\n
Mit Transpiling kann man eine Anwendung mit der neuesten PHP-Version programmieren und eine Version erstellen, die auch in Umgebungen mit \u00e4lteren PHP-Versionen funktioniert.<\/p>\n
Das kann besonders f\u00fcr Entwickler\/innen n\u00fctzlich sein, die Produkte f\u00fcr \u00e4ltere Content-Management-Systeme (CMS)<\/a> entwickeln. WordPress zum Beispiel unterst\u00fctzt offiziell immer noch PHP 5.6<\/a> (auch wenn es PHP 7.4+ empfiehlt). Der Prozentsatz der WordPress Seiten, die mit den PHP-Versionen 5.6 bis 7.2 laufen – die alle End-of-Life (EOL) sind, d.h. sie erhalten keine Sicherheitsupdates mehr – liegt bei beachtlichen 34,8 % und der Anteil der Seiten, die mit einer anderen PHP-Version als 8.0 laufen, bei satten 99,5 %:<\/p>\n
\"WordPress-Nutzungsstatistiken<\/a>
WordPress-Nutzungsstatistiken nach Version. Bildquelle: WordPress<\/a><\/figcaption><\/figure>\n
Daher werden WordPress-Themes und Plugins, die sich an ein globales Publikum richten, h\u00f6chstwahrscheinlich mit einer alten PHP-Version programmiert, um ihre m\u00f6gliche Reichweite zu erh\u00f6hen. Dank der Transpilierung k\u00f6nnen sie mit PHP 8.0 programmiert und trotzdem f\u00fcr eine \u00e4ltere PHP-Version ver\u00f6ffentlicht werden, um so viele Nutzer\/innen wie m\u00f6glich anzusprechen.<\/p>\n
Jede Anwendung, die eine andere als die neueste PHP-Version unterst\u00fctzen muss (selbst innerhalb der aktuell unterst\u00fctzten PHP-Versionen), kann davon profitieren.<\/p>\n
Dies ist bei Drupal der Fall, das PHP 7.3 ben\u00f6tigt<\/a>. Dank der Transpilierung k\u00f6nnen Entwickler \u00f6ffentlich verf\u00fcgbare Drupal-Module mit PHP 8.0 erstellen und sie mit PHP 7.3 ver\u00f6ffentlichen.<\/p>\n
Ein weiteres Beispiel ist die Erstellung von benutzerdefiniertem Code f\u00fcr Kunden, die aus dem einen oder anderen Grund kein PHP 8.0 in ihrer Umgebung einsetzen k\u00f6nnen. Dank der Transpilierung k\u00f6nnen die Entwickler\/innen ihre Produkte trotzdem mit PHP 8.0 programmieren und sie in diesen Legacy-Umgebungen einsetzen.<\/p>\n
transpilieren<\/h3>\n
PHP-Code kann immer transpiliert werden, es sei denn, er enth\u00e4lt eine PHP-Funktion, f\u00fcr die es in der vorherigen PHP-Version keine Entsprechung gibt.<\/p>\n
Das ist zum Beispiel bei den Attributen<\/a> der Fall, die in PHP 8.0 eingef\u00fchrt wurden:<\/p>\n
#[SomeAttr]\nfunction someFunc() {}\n\n#[AnotherAttr]\nclass SomeClass {}\n<\/code><\/pre>\n
Im vorherigen Beispiel mit den Pfeilfunktionen konnte der Code transpiliert werden, weil Pfeilfunktionen syntaktischer Zucker sind. Attribute hingegen schaffen ein v\u00f6llig neues Verhalten. Dieses Verhalten k\u00f6nnte auch mit PHP 7.4 und niedriger reproduziert werden, aber nur durch manuelle Programmierung, d.h. nicht automatisch mit Hilfe eines Tools oder Prozesses (KI k\u00f6nnte eine L\u00f6sung bieten, aber so weit sind wir noch nicht).<\/p>\n
Attribute, die f\u00fcr die Entwicklung bestimmt sind, wie z. B. #[Deprecated]<\/a><\/code>, k\u00f6nnen auf dieselbe Weise entfernt werden wie Union-Typen. Aber Attribute, die das Verhalten der Anwendung in der Produktion ver\u00e4ndern, k\u00f6nnen nicht entfernt werden, und sie k\u00f6nnen auch nicht direkt transpiliert werden.<\/p>\n
Bis heute kann kein Transpiler Code mit PHP 8.0-Attributen automatisch in entsprechenden PHP 7.4-Code umwandeln. Wenn dein PHP-Code also Attribute verwenden muss, wird es schwierig oder unm\u00f6glich sein, ihn zu transpilieren.<\/p>\n
PHP-Funktionen, die transpiliert werden k\u00f6nnen<\/h3>\n
Dies sind die Funktionen von PHP 7.1 und h\u00f6her, die derzeit transpiliert werden k\u00f6nnen. Wenn dein Code nur diese Funktionen verwendet, kannst du sicher sein, dass deine transpilierte Anwendung funktionieren wird. Andernfalls musst du pr\u00fcfen, ob der transpilierte Code zu Fehlern f\u00fchren wird.<\/p>\n\n\n\n\n\n\n\n\n\n
PHP Version<\/th>\nFeatures<\/th>\n<\/tr>\n<\/thead>\n
7.1<\/td>\nAlles<\/td>\n<\/tr>\n
7.2<\/td>\n– object<\/code>-Typ<\/a>
\n– Parameter-Typ-Erweiterung<\/a>
\n– PREG_UNMATCHED_AS_NULL<\/code> Flag in preg_match<\/code><\/a><\/td>\n<\/tr>\n
7.3<\/td>\n– Referenzzuweisungen in list()<\/code> \/ Array-Destrukturierung<\/a> (au\u00dfer innerhalb von foreach<\/code> \u2014\u00a0#4376<\/a><\/em>)
\n– Flexible Heredoc- und Nowdoc-Syntax<\/a>
\n– Nachgestellte Kommas in Funktionsaufrufen<\/a>
\n– set(raw)cookie<\/code> akzeptiert das Argument $option<\/a><\/td>\n<\/tr>\n
7.4<\/td>\n– Typisierte Eigenschaften<\/a>
\n– Pfeilfunktionen<\/a>
\n– Null verschmelzende Zuweisungsoperatoren<\/a>
\n– Entpacken innerhalb von Arrays<\/a>
\n– Numerisches Literal-Trennzeichen<\/a>
\n– strip_tags()<\/code> mit Array von Tag-Namen<\/a>
\n– kovariante R\u00fcckgabetypen und kontravariante Parametertypen<\/a><\/td>\n<\/tr>\n
8.0<\/td>\n– Union-Typen<\/a>
\n– mixed<\/code> Pseudo-Typ<\/a>
\n– static<\/code> R\u00fcckgabetyp<\/a>
\n– ::class<\/code> magische Konstante f\u00fcr Objekte<\/a>
\n– match<\/code> Ausdr\u00fccke<\/a>
\n– catch<\/code> Ausnahmen nur nach Typ<\/a>
\n– Null-sicherer Operator<\/a>
\n– Bef\u00f6rderung von Klassenkonstruktoreigenschaften<\/a>
\n– Anh\u00e4ngende Kommas in Parameterlisten und use<\/code> Listen f\u00fcr Closures<\/a><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
PHP-Transpilierer<\/h2>\n
Derzeit gibt es nur ein Tool zum Transpilieren von PHP-Code: Rector<\/a>.<\/p>\n
Rector ist ein Tool zur PHP-Rekonstruktion, das PHP-Code anhand von programmierbaren Regeln umwandelt. Wir geben den Quellcode und die Regeln ein, die ausgef\u00fchrt<\/a> werden sollen, und Rector wandelt den Code um.<\/p>\n
Rector wird \u00fcber die Kommandozeile bedient und \u00fcber Composer in das Projekt installiert. Nach der Ausf\u00fchrung gibt Rector einen „Diff“ (Hinzuf\u00fcgungen in gr\u00fcn, Entfernungen in rot) des Codes vor und nach der Conversion aus:<\/p>\n
\"\"diff\"<\/a>
„diff“ Ausgabe von Rector<\/figcaption><\/figure>\n
Welche Version von PHP soll transpiliert werden?<\/h2>\n
Um Code zwischen verschiedenen PHP-Versionen zu transpilieren, m\u00fcssen die entsprechenden Regeln erstellt werden.<\/p>\n
Heute enth\u00e4lt die Rector-Bibliothek die meisten Regeln f\u00fcr das Transpilieren von Code im Bereich von PHP 8.0 bis 7.1. So k\u00f6nnen wir unseren PHP-Code zuverl\u00e4ssig bis zur Version 7.1 transpilieren.<\/p>\n
Es gibt auch Regeln f\u00fcr die Transpilierung von PHP 7.1 nach 7.0<\/a> und von 7.0 nach 5.6<\/a>, aber diese sind nicht vollst\u00e4ndig. Wir arbeiten daran, sie zu vervollst\u00e4ndigen, so dass wir PHP-Code eventuell bis zur Version 5.6 transpilieren k\u00f6nnen.<\/p>\n
Transpilieren vs. Backporting<\/h2>\n
Das Backporting ist \u00e4hnlich wie das Transpilieren, aber einfacher. Bei der R\u00fcckportierung von Code werden nicht unbedingt neue Funktionen einer Sprache verwendet. Stattdessen kann dieselbe Funktion in einer \u00e4lteren Version der Sprache bereitgestellt werden, indem der entsprechende Code aus der neuen Version der Sprache einfach kopiert\/eingepasst\/angepasst wird.<\/p>\n
Zum Beispiel wurde die Funktion str_contains<\/code> in PHP 8.0 eingef\u00fchrt. Die gleiche Funktion f\u00fcr PHP 7.4 und darunter kann einfach wie folgt implementiert werden:<\/p>\n
if (!defined('PHP_VERSION_ID') || (defined('PHP_VERSION_ID') && PHP_VERSION_ID < 80000)) {\n  if (!function_exists('str_contains')) {\n    \/**\n     * Checks if a string contains another\n     *\n     * @param string $haystack The string to search in\n     * @param string $needle The string to search\n     * @return boolean Returns TRUE if the needle was found in haystack, FALSE otherwise.\n     *\/\n    function str_contains(string $haystack, string $needle): bool\n    {\n      return strpos($haystack, $needle) !== false;\n    }\n  }\n}\n<\/code><\/pre>\n
Da die R\u00fcckportierung einfacher ist als die Transpilierung, sollten wir uns f\u00fcr diese L\u00f6sung entscheiden, wenn die R\u00fcckportierung die Aufgabe erf\u00fcllt.<\/p>\n
Was den Bereich zwischen PHP 8.0 und 7.1 angeht, k\u00f6nnen wir die Polyfill-Bibliotheken von Symfony<\/a> verwenden:<\/p>\n