Am 6. Dezember 2018 wurde das dritte Feature-Update für PHP 7 vorgestellt. PHP 7.3 wurde somit, wie geplant, pünktlich zu Nikolaus veröffentlicht. Die serverseitige Skriptsprache PHP, welche hauptsächlich in der Webentwicklung zur Erstellung von dynamischen Websites bzw. Webanwendungen eingesetzt wird, erreicht damit ihre dritte große Iteration der PHP-7-Reihe.

Heute schauen wir uns mal die Neuerungen an, die in der Version 7.3 der meistverbreiteten serverseitigen Skriptsprache umgesetzt wurden.

Das sind die wesentlichen Neuerungen

Ich beginne erstmal mit einem groben Überblick über die wesentlichen Neuerungen. Im Anschluss schauen wir uns dann die einzelnen Features und Änderungen im Detail an. So lässt sich erst einmal festhalten, dass der Release von PHP 7.3 wieder einige Features und Verbesserungen, insbesondere auch der Performance, mit sich bringt. Darüber hinaus wurden natürlich wieder zahlreiche Fehler behoben, genauso wie manche Bestandteile als "deprecated" markiert wurden, sodass diese mit der nächsten Hauptversion, respektive PHP 8, aus PHP entfernt werden.

Zu den wichtigsten Neuerungen zählen folgende Punkte:

Wer auf der Suche nach einer vollständigen Übersicht mit allen Änderungen ist, findet diese im Changelog bzw. im Migration Guide für PHP 7.3. Für Details und Hintergründe zu den einzelnen Neuerungen empfehlen sich ansonsten immer die jeweiligen RFCs.

Optimierte Syntax für Heredoc und Nowdoc

Die Änderungen in Bezug auf die Syntax von Heredoc und Nowdoc sind ein wesentlicher Bestandteil von PHP 7.3 und bekommen dadurch aktuell ungewohnt viel Aufmerksamkeit. Ganz ehrlich: Ihr müsst euch nicht schämen, wenn euch die Features rund um Heredoc und Nowdoc bisher nicht bekannt waren. Ich weiß auch erst seit PHP 7.3 über deren Existenz Bescheid und habe sie dementsprechend noch nie benutzt. Genau aus diesem Grund schauen wir uns also erstmal an, was überhaupt hinter diesen interessanten Begriffen Heredoc und Nowdoc steckt.

Heredoc und Nowdoc: Eine kurze Einführung

Der sogenannte Heredoc bringt die Möglichkeit mit sich, einen längeren Text in den PHP-Code einzufügen, ohne z.B. doppelte Anführungszeichen escapen zu müssen, da man durch den Einsatz von Heredoc schlicht auf diese verzichten kann, um einen String zu definieren. Die Syntax ist dabei so aufgebaut, dass man den Heredoc mit <<< beginnt. Darauf folgt dann ein sogenannter "Marker". Dieser Marker wird schlussendlich genutzt, um den String auch wieder zu schließen bzw. das Ende der Zeichenkette zu markieren. Wie so häufig darf das Semikolon am Ende einer Anweisung natürlich auch nicht fehlen.

Hier ist ein Beispiel:

<?php

echo <<<EOT
Lorem ipsum dolor sit amet ...
EOT;

Im Grunde kann man den Heredoc als alternative Schreibweise von einem String mit doppelten Anführungszeichen ansehen, da der Text zwischen den beiden Markern, welche Anfang und Schluss repräsentieren, von PHP interpretiert wird. Diese Interpretation ist bei doppelten Anführungszeichen ebenso gegeben.

In diesem Sinne lassen sich beispielsweise Variablen direkt in den Text einfügen: 

<?php

$website = 'jr-cologne.de';

// Ausgabe: Hello from jr-cologne.de!
echo <<<EOT
Hello from $website!
EOT;

Wenn ein Heredoc eine Alternative zu einem String mit doppelten Anführungszeichen darstellt, was ist dann wohl ein Nowdoc? Richtig, ein Nowdoc ist das Gegenstück zu einer Zeichenkette mit einfachen Anführungszeichen!

Dadurch ergeben sich folgende Änderungen im Vergleich zum Heredoc:

  • Der Marker wird zu Beginn von einfachen Anführungszeichen umschlossen
  • Der Text innerhalb eines Nowdocs wird nicht von PHP geparst

Dies wäre ein Beispiel für einen Nowdoc: 

<?php

// Ausgabe: Hello from $website!
echo <<<'EOT'
Hello from $website!
EOT;

Die wesentlichen Gemeinsamkeiten von Heredoc und Nowdoc liegen bei den Vorschriften für die Endmarkierungen. So darf der Endmarker nicht eingerückt werden und muss stets unmittelbar am Anfang einer Zeile stehen. Ebenso darf die Schlussmarkierung lediglich ein Newline-Zeichen hinter sich haben und muss dementsprechend eine eigene Zeile im Code einnehmen. Was die Namensgebung der Marker betrifft, gelten die gleichen Regeln wie auch bei sonstigen Bezeichnern in PHP. So dürfte ein Marker z.B. nicht mit einer Zahl beginnen.

Wie ihr vielleicht bereits erahnen könnt, sind dies relativ starke Einschränkungen, die dafür sorgen, dass die Syntax von Heredocs und Nowdocs schnell unschöne Formen annimmt: 

<?php

class Foo {
  public $bar = <<<EOT
bar
EOT;
}

Heredoc und Nowdoc: Das sind die Neuerungen

Kommen wir nun also wieder zurück zu PHP 7.3 und den Verbesserungen, welche in diesem Release für Here- und Nowdocs eingeführt wurden.

1. Erlaubte Einrückung der Endmarkierung inkl. Entfernung des vorderen Whitespaces

Damit man nicht gezwungen ist, den Code so komisch zu formatieren, ist es seit PHP 7.3 jetzt erlaubt, die Endmarkierung einzurücken. Zu beachten gilt dabei, dass die Einrückung des Endmarkers darüber entscheidet, wie viel Whitespace vor dem Text innerhalb des Here- bzw. Nowdocs entfernt wird. Auch darf der Endmarker nicht weiter als der Inhalt eingerückt sein.

Unser Beispiel sieht mit PHP 7.3 doch schon mal deutlich besser aus: 

<?php

class Foo {
  public $bar = <<<EOT
      bar
  EOT;
}
2. Endmarkierung muss nicht mehr alleine in einer Zeile stehen

Um einen mit Heredoc oder Nowdoc definierten String zu beenden, muss nun kein Newline-Zeichen mehr auf die Endmarkierung folgen. Dies bedeutet, dass diese nicht mehr alleine eine komplette Zeile im Code in Anspruch nimmt.

Folgendes ist mit PHP 7.3 also beispielsweise möglich:

<?php

$values = [
    'foo' => <<<END
      a
      b
      c
    END,
    'd e f'
];

/*
Ausgabe:

a
b
c
*/
echo $values['foo'];

Alles in allem sind das zwei schöne Neuerungen, die den String-Syntax von Heredocs und Nowdocs ein Stück weit attraktiver machen.

"Trailing Commas" in Funktionsaufrufen

Mit der Erlaubnis sogenannte "Trailing Commas" in Funktionsaufrufen einzusetzen, sorgt PHP 7.3 u.a. auch für mehr Flexibilität sowie die Verhinderung von typischen Fehlern. Unter "trailing commas" versteht man die Möglichkeit, an eine Liste von Elementen, Parametern oder Eigenschaften ein nachfolgendes Komma anzuhängen. Dies erweist sich als besonders nützlich, wenn z.B. häufig neue Elemente zu einem Array hinzugefügt werden müssen. Hängt man dabei stets ein Komma an das letzte Element an, ist es deutlich unwahrscheinlicher, dass einem ein Syntax-Fehler unterläuft, weil man z.B. ein Komma vergessen hat.

Bekannt war diese Option bisher vor allen Dingen bei Arrays, wo ein nachgestelltes Komma erlaubt ist und die Nutzung dieser Funktionalität von manchen sogar als Empfehlung herausgegeben wird.

Das Ganze sieht dann z.B. so aus:

<?php

$values = [
  'foo' => $foo,
  'bar' => $bar,
];

Mit PHP 7.3 ist dies auch bei Funktionsaufrufen möglich. Praktisch kann das vor allen Dingen bei Funktionen sein, welche theoretisch unendlich viele Argumente verarbeiten können.

Ein Beispiel ist die Funktion array_merge(): 

<?php

$foo = [ 1, 2, 3 ];
$bar = [ 4, 5, 6 ];

$foobar = array_merge(
  $foo,
  $bar,
  [ 7, 8, 9 ],
);

Ähnliche Anwendungsfälle sind das Debuggen mit der Funktion var_dump() oder auch die beiden Funktionen unset() sowie isset(). 

<?php

var_dump(
  $foo,
  $bar,
  $foobar,
);

Wichtig zu erwähnen ist bei diesem Feature noch, dass es ebenfalls für Methodenaufrufe gilt. Genauso sollte allerdings beachtet werden, dass eine Funktions- bzw. Methodendeklaration weiterhin keine "trailing commas" erlaubt, was auch gut so ist. Darüber hinaus sind auch freistehende, mehrere nachfolgende oder führende Kommata nicht zulässig. Sollte eigentlich selbstverständlich sein. Zur Sicherheit erwähne ich es aber trotzdem.

Dass "trailing commas" jetzt in Funktionsaufrufen erlaubt sind, halte ich auf jeden Fall für eine sinnvolle Neuerung, die ich sicher das eine oder andere Mal nutzen werde.

Neues Flag: JSON_THROW_ON_ERROR

Einer der beliebtesten Änderungen ist sicher die Einführung einer neuen Möglichkeit, JSON-Fehler zu behandeln. Diese Neuerung an der JSON-Erweiterung ändert nun das Verhalten bei Fehlern der Funktionen json_encode() sowie json_decode().

Bisher war das Behandeln von Fehlern immer ein wenig umständlich und verwirrend. So gibt json_decode() bei einem Fehler null zurück. Gleichzeitig kann null aber auch ein valider Rückgabewert sein, wenn kein Fehler aufgetreten ist.

Folglich war man eigentlich immer gezwungen, mittels der Funktion json_last_error() zu prüfen, ob ein Fehler aufgetreten ist. Bei der Funktion json_encode() sieht dies hingegen ein Stück weit besser aus, da diese Funktion im Fehlerfall false zurückgibt. Trotzdem ist das Ganze nicht ideal, da beide Funktionen weder den Programmablauf unterbrechen, noch eine Warnung verursachen.

Mit PHP 7.3 wird dies endlich deutlich verbessert. Durch die Einführung des neuen Flags JSON_THROW_ON_ERROR, der beiden Funktionen übergeben werden kann, kann der Umgang mit Fehlern auf Wunsch verändert werden, sodass die beiden Funktionen json_decode() sowie json_encode() nun eine sogenannte JsonException werfen, wenn etwas schief gehen sollte. Demnach hat man mit PHP 7.3 die Möglichkeit, Fehler deutlich einfacher durch das Abfangen der JsonException zu verarbeiten.

Ein Beispiel:

<?php

try {
  $data = json_decode('{', true, 512, JSON_THROW_ON_ERROR);
} catch (\JsonException $e) {
  echo $e->getMessage(); // Ausgabe: Syntax error
}

Erwähnenswert ist vielleicht noch, dass JSON_THROW_ON_ERROR wirklich nur dafür sorgt, dass Fehler im übergebenen JSON-Code entsprechend als JsonException behandelt werden können. Ruft man die Funktion json_decode() beispielsweise falsch auf, weil man z.B. ein Parameter falsch setzt, verursacht dies weiterhin nur Warnungen oder sonstige PHP-Fehler und die Funktion gibt wie zuvor null zurück.

Insgesamt eine wirklich schöne Neuerung, auf die sicher viele schon gewartet haben.

Referenz-Zuweisung bei list()

Kommen wir nun zu einer weiteren Neuerung, die tendenziell wahrscheinlich wieder eine geringere Anzahl von PHP-Entwicklern betreffen wird.

Auch hier schauen wir uns erstmal an, was überhaupt mit einer Referenz-Zuweisung gemeint ist.

Was ist eine Referenz-Zuweisung?

Eine Referenz-Zuweisung kann man im Grunde als eine spezielle Art der Zuweisung bezeichnen, bei der der Wert einer Variable $a nicht einfach in die Variable $b kopiert wird. Stattdessen zeigt die Variable $b anschließend lediglich auf $a und hat somit stets den gleichen Inhalt wie $a. Gekennzeichnet wird eine Referenz-Zuweisung durch ein &-Zeichen vor der Variable, welche referenziert werden soll.

Am besten lässt sich dies durch ein Beispiel veranschaulichen:

<?php

$a = 3;
$b = &$a;

var_dump($a, $b); // 3, 3

$a = 5;

var_dump($a, $b); // 5, 5

$b = 3;

var_dump($a, $b); // 3, 3

Zu Beginn weisen wir der Variable $a den Integer-Wert 3 zu. Anschließend nehmen wir eine Referenz-Zuweisung vor, sodass $b anschließend ein Zeiger auf die Variable $a darstellt. Lassen wir uns den Inhalt beider Variablen anzeigen, stimmen beide Werte überein, was nicht weiter überraschend ist.

Interessant wird es, wenn wir den Wert von $a bzw. $b ändern. Aufgrund der Tatsache, dass wir eine Referenz-Zuweisung vorgenommen haben, werden bei einer Änderung einer Variable gleich beide Variablen geändert. Dies liegt daran, dass beide Variablen auf den gleichen Speicherplatz im Arbeitsspeicher zeigen. Sobald wir beispielsweise der Variable $b einen neuen Wert zuweisen, wird im Hintergrund somit eigentlich nachgeschaut, auf welche Variable und somit auch auf welchen Speicherplatz $b verweist. In unserem Fall ist das der Speicherplatz der Variable $a, welche im Anschluss geändert wird. $b hingegen wird eigentlich nicht geändert, sondern dient lediglich als Referenz für die andere Variable und deren Speicherplatz.

Wenn ihr dieses Konzept soweit verstanden habt, können wir uns nun das list()-Sprachkonstrukt anschauen, das in PHP 7.3 auch die Referenz-Zuweisungen unterstützt.

Das Sprachkonstrukt list() und seine Neuerungen in PHP 7.3

Das Sprachkonstrukt list() wird im PHP-Handbuch als eine Funktionalität beschrieben, welche Variablen zuweist, als wären sie ein Array. Wer das auf Anhieb versteht, verdient meine Anerkennung. Ich gehöre eher zu denjenigen, die zugegebenermaßen noch heute nicht wirklich verstehen, was mit dieser kryptischen Definition gemeint ist.

Aus diesem Grund versuche ich es mal einfacher zu erklären: Im Prinzip macht list() nichts anderes, als die Elemente eines Arrays jeweils auf die übergebenen Variablen zu übertragen.

Hier ist ein Beispiel:

<?php

$arr = [
  'foo',
  'bar',
  'foobar',
];

list($foo, $bar, $foobar) = $arr;

/*
Ausgabe:

array(3) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(6) "foobar"
}
string(3) "foo"
string(3) "bar"
string(6) "foobar"
*/
var_dump($arr, $foo, $bar, $foobar);

Wie ihr euch sicher bereits denken könnt, war dies jedoch vor PHP 7.3 noch nicht mit Referenz-Zuweisungen möglich. Statt umständlich jede Referenz-Zuweisung einzeln vornehmen zu müssen, ist eine Referenz-Zuweisung bestimmter oder aller Elemente eines Arrays auf Variablen ab PHP 7.3 deutlich einfacher realisierbar.

Eine Gegenüberstellung der beiden Varianten:

<?php

// alt
$arr = [
  'foo',
  'bar',
];

$foo = $arr[0];
$bar = &$arr[1];

$bar = 'hello';

var_dump($arr, $foo, $bar); // $arr[1] und $bar haben beide den Wert 'hello'

// neu
$arr = [
    'foo',
    'bar',
];

list($foo, &$bar) = $arr;

$bar = 'hello';

var_dump($arr, $foo, $bar); // $arr[1] und $bar haben beide den Wert 'hello'

Die alte Version erzeugt genau das gleiche Ergebnis, ist allerdings deutlich schlechter lesbar und benötigt mehr Code. Besonders bei langen Arrays würde die alte Variante sehr schnell hässliche Ausmaße annehmen. PHP 7.3 führt damit also wieder eine klare Verbesserung der Syntax ein.

Neue Funktionen is_countable(), array_key_first(), array_key_last()

PHP 7.3 hat zusätzlich auch drei komplett neue Funktionen eingeführt, welche wir uns im Folgenden mal näher anschauen. Die Rede ist von den Funktionen is_countable() und array_key_first() sowie array_key_last().

Die Funktion is_countable()

Die erste Funktion, welche in PHP 7.3 neu eingeführt wurde, ist die Funktion is_countable(). Wie der Name schon sagt, lässt sich mit dieser Funktion überprüfen, ob eine Variable zählbar ist. Als "countable" wird ein Array oder ein Objekt, dessen Klasse das Countable-Interface implementiert, angesehen.

Nützlich ist die Funktion is_countable() aus dem Grund, dass die Funktion count() seit PHP 7.2 eine Warnung ausspuckt, wenn wir als Argument etwas übergeben, was per Definition nicht zählbar ist, also nicht mit den oben genannten Kriterien korrespondiert. Um diese Warnung zu verhindern, muss man streng genommen somit jede count()-Anweisung mit einer entsprechenden if-Abfrage umschließen, wenn man sich nicht sicher sein kann, dass etwas wirklich als zählbar akzeptiert wird.

Bisher ergab das ungefähr folgenden Code:

<?php

if (is_array($foo) || $foo instanceof Countable) {
  // countable
}

Mit PHP 7.3 ist diese umständliche Abfrage jetzt Geschichte. Dank der Funktion is_countable(), welche einen booleschen Wert je nach Zählbarkeit der Variable zurückgibt, können wir das Ganze zumindest deutlich abkürzen. 

<?php

if (is_countable($foo)) {
  // countable
}

Die Funktionen array_key_first() sowie array_key_last()

Die beiden Funktionen array_key_first() sowie array_key_last() gehören ebenfalls zu den Neuerungen von PHP 7.3 und wurden als Antwort auf ein bekanntes Problem eingeführt. So ist es bei Arrays, insbesondere assoziativer Art, nicht so einfach möglich, z.B. den letzten Key herauszufinden. Die "beste" Lösung griff bisher meist auf die Funktionen reset(), end() und key() zurück, um den internen Zeiger eines Arrays zu verschieben und anschließend den Key herauszufinden.

Das Ganze sieht dann ungefähr so aus:

<?php

$arr = [
  'nheb' => 'foo',
  'bfhe' => 'bar',
  'efzg' => 'foobar',
];

end($arr);

var_dump(key($arr)); // Ausgabe: efzg

reset($arr);

Wirklich schön ist das nicht, da man eben den internen Zeiger manipulieren muss.

Dank den beiden neuen Funktionen geht das Ganze jetzt deutlich einfacher, ohne den internen Zeiger des Arrays in irgendeiner Form zu manipulieren. 

<?php

$arr = [
  'nheb' => 'foo',
  'bfhe' => 'bar',
  'efzg' => 'foobar',
];

var_dump(array_key_last($arr)); // Ausgabe: efzg

Genau nach dem gleichen Prinzip funktioniert natürlich die Funktion array_key_first(), nur das sie eben den Key des ersten Elements eines Arrays zurückgibt.

Ganz interessant ist an dieser Stelle vielleicht noch zu erwähnen, dass die beiden Funktionen array_key_first() sowie array_key_last() nicht unumstritten sind. Dies zeigt sich allein schon an dem Abstimmungsergebnis von 18:14, mit dem der RFC angenommen wurde. Darüber hinaus hatte der RFC ursprünglich auch noch die Einführung der Funktionen array_value_first() sowie array_value_last() vorgeschlagen. Diese wurden aber leider nicht angenommen und sind somit kein Bestandteil von PHP 7.3 geworden. Natürlich ist es mit den neuen array_key-Funktionen jetzt auch einfacher möglich, die entsprechenden Werte zu bestimmen. Trotzdem hätte ich es zwecks der Lesbarkeit bevorzugt, die Funktionen array_value_first() bzw. array_value_last() zu nutzen.

Dass die zwei Funktionen kein Bestandteil von PHP sind, ist letztendlich vertretbar. Immerhin besteht ja auch die Möglichkeit, das Ganze über ein kleines "Polyfill" zu lösen. 

<?php

if (!function_exists('array_value_first')) {
  function array_value_first(array $arr) {
    return $arr[array_key_first($arr)];
  }
}

if (!function_exists('array_value_last')) {
  function array_value_last(array $arr) {
    return $arr[array_key_last($arr)];
  }
}

Optimierungen vom Hashing-Algorithmus Argon2

Wenn ihr die Erscheinung von PHP 7.2 sowie die damit verbundenen Neuerungen verfolgt habt, dürfte euch der Hashing-Algorithmus Argon2 bereits bekannt sein. Er wurde vor gut einem Jahr als Alternative zu Bcrypt eingeführt. Mit der Konstante PASSWORD_ARGON2I wurde er letztlich für die password_*-Funktionen der Password Hashing API zur Verfügung gestellt.

Seit der ersten Implementation in PHP wurde mittlerweile eine weitere Variante des Algorithmus entwickelt, welche nun mit PHP 7.3 hinzugefügt wurde.

Die neue Konstante lautet PASSWORD_ARGON2ID und kann eigentlich genauso verwendet werden, wie schon zuvor PASSWORD_ARGON2I. 

<?php

password_hash('password', PASSWORD_ARGON2ID);

Ihr fragt euch, welchen Argon2-Algorithmus ihr jetzt nutzen solltet und wo die Unterschiede liegen? Die kurze Antwort ist, dass der Algorithmus hinter der Konstante PASSWORD_ARGON2ID jetzt als die beste Variante angesehen werden kann und dementsprechend empfohlen wird, solange man sich nicht auskennt und eine qualifizierte andere Meinung pflegen kann.

Für eine etwas genauere Erläuterung, habe ich mal ein Zitat aus dem RFC herausgesucht, welches die Unterschiede ganz gut darlegt.

Argon2 has three variants: Argon2i, Argon2d, and Argon2id. Argon2d is faster and uses data-depending memory access, which makes it highly resistant against GPU cracking attacks and suitable for applications with no threats from side-channel timing attacks (eg. cryptocurrencies). Argon2i instead uses data-independent memory access, which is preferred for password hashing and password-based key derivation, but it is slower as it makes more passes over the memory to protect from tradeoff attacks. Argon2id is a hybrid of Argon2i and Argon2d, using a combination of data-depending and data-independent memory accesses, which gives some of Argon2i's resistance to side-channel cache timing attacks and much of Argon2d's resistance to GPU cracking attacks.

Charles R. Portwood II in PHP RFC: Argon2 Password Hash Enhancements

Deprecations: Diese Features werden bald entfernt

Bevor Bestandteile von PHP komplett entfernt werden und für immer verschwinden, werden diese Features bzw. Funktionalitäten erstmal als veraltet markiert. Mit der nächsten Hauptversion PHP 8 wird es dann spätestens zu einer Entfernung kommen. In diesem Sinne sollten wir uns besser schon jetzt darum bemühen, die nachfolgend erwähnten Bestandteile von PHP nicht mehr zu nutzen.

Die Funktion image2wbmp()

Die Funktion image2wbmp() kann dafür genutzt werden, eine WBMP-Version eines bestimmten Bildes zu speichern oder im Browser auszugeben. Da die Funktion seit PHP 5.0 identisch mit der Funktion imagewbmp() ist, soll letztere Funktion zukünftig als Alternative genutzt werden, sodass die Funktion image2wbmp() dann mit PHP 8 problemlos entfernt werden kann.

"Case-insensitive" Konstanten

PHP unterstützt bisher sowohl "case-sensitive" als auch "case-insensitive" Konstanten. Case-Sensitivität meint schlicht und ergreifend, ob die Groß- und Kleinschreibung beachtet wird. Im Falle einer vorliegenden Case-Sensitivität würden sich die Bezeichner "FOO" und "Foo" beispielsweise unterscheiden.

Standardmäßig sind Konstanten in PHP eigentlich "case-sensitive". Zusätzlich existiert die weit verbreitete Konvention, dass Konstanten komplett in Großbuchstaben geschrieben werden. Dennoch ist es möglich, "case-insensitive" Konstanten mit der Funktion define() zu erzeugen, indem man als dritten Parameter den Wert true übergibt, da dieser für die Case-Insensitivität steht.

Folgende Änderungen wurden bzw. werden also vorgenommen:

  • Deprecation des Aufrufs der Funktion define() mit dem Wert true als drittes Argument (PHP 7.3)
  • Deprecation des Zugriffs auf "case-insensitive" Konstanten mit einem von der Deklaration unterschiedlichen "Casing", Ausnahmen: true, false, null (PHP 7.3)
  • Entfernung der Möglichkeit, "case-insensitive" Konstanten zu deklarieren (PHP 8.0)
  • Umstellung der speziellen Konstanten true, false und null zu reservierten Schlüsselwörtern (PHP 8.0)

Nicht dokumentierte mbstring-Funktionsaliase

Es existieren zahlreiche mbstring-Funktionen, welche nicht dokumentiert sind und lediglich ein Duplikat der äquivalenten Funktionen mit dem Präfix "mb_" darstellen. Ein Beispiel hierfür ist die Funktion mbereg(), welche ein Alias von mb_ereg() ist. Alle Funktionen dieser Art werden mit PHP 7.3 als veraltet eingestuft.

Migration Guide für PHP 7.3: Alle Neuerungen in der Übersicht

Zum Abschluss möchte ich nun noch auf den Migration Guide für PHP 7.3 hinweisen. Dieser beinhaltet eine komplette Übersicht über alle Änderungen, welche mit PHP 7.3 eingeführt wurden. Hierzu gehören alle neuen Features, alle neuen Funktionen, alle neuen globalen Konstanten, die sogenannten "Backward Incompatible Changes", alle Deprecations, sonstige Änderungen und zuletzt noch Änderungen bzgl. der Windows-Unterstützung. All das wird im Migration Guide behandelt.

Fazit

Zusammenfassend lässt sich dieses Jahr meiner Meinung nach wieder sagen, dass PHP keinesfalls tot ist. Stattdessen wird die PHP-7-Reihe weiterhin ordentlich weiterentwickelt, sodass PHP noch nie eine so performante und schöne Skriptsprache war, wie sie jetzt mit dem Release von PHP 7.3 darstellt.

Ich bin auf alle Fälle gespannt, was uns diesbezüglich in Zukunft noch erwartet. Mit PHP 7.3 wurden auf alle Fälle einige Neuerungen eingeführt, die zwar keine sonderlich großen Änderungen darstellen, aber dennoch PHP als Sprache mehr und mehr abrunden. Besonders freue ich mich dieses Jahr über die "trailing commas" in Funktionsaufrufen, JSON_THROW_ON_ERROR, die drei vorgestellten neuen Funktionen sowie die Verbesserungen rund um Argon2.

Ich hoffe, ihr konntet euch einen Eindruck von PHP 7.3 machen und freut euch, genauso wie ich, auf den Einsatz der neuen Features.

Weiterführende Links / Quellen