--- title: 'PHP 7.1 from 7.0: Nullables, void, Symmetric Destructuring & Migration | DevSense' description: 'Upgrade-Leitfaden für PHP 7.1: Nullable-Typen, void-Rückgabetypen, Sichtbarkeit von Klassenkonstanten, symmetrisches Array-Destructuring, iterable-Pseudotyp, Multi-Catch, negative String-Offsets und BC-Breaks.' faq: - { question: 'Was sind Nullable-Typen in PHP 7.1?', answer: "Nullable-Typen ermöglichen es Parametern und Rückgabetypen, entweder den angegebenen Typ oder null zu akzeptieren, indem dem Typnamen ein Fragezeichen vorangestellt wird (z. B. '?string')." } - { question: "Wie verhält sich der Rückgabetyp 'void'?", answer: "Eine Funktion, die mit dem Rückgabetyp 'void' deklariert ist, darf entweder keine return-Anweisung enthalten oder muss ein leeres 'return;' verwenden. Das Zurückgeben eines Wertes, einschließlich 'null', löst einen Fatal Error aus." } - { question: 'Was ist symmetrisches Array-Destructuring?', answer: "Symmetrisches Array-Destructuring ermöglicht es Entwicklern, die kurze Array-Syntax ('[]') anstelle von 'list()' zu verwenden, um Arrays zu entpacken (z. B. '[$a, $b] = $arr'). Zudem wird die Angabe von Schlüsseln unterstützt." } - { question: 'Wie funktioniert die Sichtbarkeit von Klassenkonstanten?', answer: "PHP 7.1 führt die Möglichkeit ein, Klassenkonstanten als 'public', 'protected' oder 'private' zu deklarieren, analog zu den Sichtbarkeitsregeln für Eigenschaften und Methoden." } published: '2026-05-31' --- # PHP 7.1: Hauptmerkmale Was wäre, wenn Sie drei verschiedene Exception-Typen in einem einzigen Block abfangen könnten, ohne wiederkehrenden Boilerplate-Code schreiben zu müssen? Oder Klassenkonstanten definieren könnten, die vor externem Zugriff geschützt sind? PHP 7.1 führt genau diese Fähigkeiten ein und bringt robuste Typsicherheit und Ausdrucksstärke in moderne PHP-Architekturen. Es verbessert Typensysteme und Syntax durch Nullable-Typen, void-Funktionen, symmetrisches Array-Destructuring mit Schlüsseln, Sichtbarkeit von Klassenkonstanten und Multi-Catch-Exceptions. ## Inhalt * [Nullable-Typen](#nullable-types) * [Void-Funktionen](#void-functions) * [Symmetrisches Array-Destructuring](#symmetric-destructuring) * [Sichtbarkeit von Klassenkonstanten](#constant-visibility) * [`iterable`-Pseudotyp](#iterable-type) * [Abfangen mehrerer Exception-Typen (Multi-Catch)](#multi-catch) * [Schlüssel im list- / Short-Destructuring](#destructuring-keys) * [Unterstützung für negative String-Offsets](#negative-offsets) * [Bemerkenswerte Erweiterungen & Stdlib](#extensions-stdlib) * [Praktische Rezepte](#practical-recipes) * [Häufige Fehler](#common-mistakes) * [Einschränkungen](#limitations) * [Rückwärtskompatibilität und BC-Breaks](#backward-incompatible) * [Veraltete Features (frühzeitig beheben)](#deprecations) * [Weitere Änderungen](#other-changes) * [Interaktives Quiz](#interactive-quiz) * [Schlussgedanken](#closing-thoughts) --- ## Nullable-Typen Sie können jedem Typ-Hint ein **`?`** voranstellen, um **`null`** als gültigen Wert neben dem primären Typ zuzulassen: ```php // src/UserService.php function findUser(int $id): ?User { return $id === 0 ? null : new User($id); } ``` > [!NOTE] > Wussten Sie schon? In PHP 7.0 war ein Typ-Hint wie `User` absolut: Die Rückgabe von `null` löste einen TypeError aus. Nullable-Typen lösen dieses Problem, ohne dass Entwickler komplett auf Typ-Hints verzichten müssen. --- ## Void-Funktionen Funktionen, die nichts zurückgeben, verwenden **`void`**. Es ist nur ein leeres **`return;`** oder das vollständige Weglassen von `return` erlaubt. Die Rückgabe von etwas anderem (einschließlich eines expliziten **`return null;`**) führt zu einem Fehler zur Kompilierzeit. ```php // src/Notifier.php function notify(string $message): void { echo $message; return; // Ein leeres return ist gültig; das Zurückgeben eines Wertes führt zu einem Typfehler } ``` > [!NOTE] > Wussten Sie schon? `void` ist ein reiner Rückgabetyp. Sie können ihn nicht verwenden, um einen Funktionsparameter zu typisieren (z. B. ist `function foo(void $x)` ungültig). --- ## Symmetrisches Array-Destructuring Entpacken Sie Arrays mit der kurzen Array-Syntax **`[]`** als Alternative zu **`list()`**: ```php // src/Config.php [$host, $port] = ['127.0.0.1', 3306]; ``` Diese Syntax kann auch in `foreach`-Schleifen verwendet werden: `foreach ($data as [$id, $name])`. --- ## Sichtbarkeit von Klassenkonstanten Konstanten können die Sichtbarkeit **`public`**, **`protected`** oder **`private`** haben: ```php // src/PaymentGateway.php class PaymentGateway { private const API_KEY = 'secret-key'; public const DEFAULT_TIMEOUT = 30; } ``` > [!NOTE] > Wussten Sie schon? Konstanten sind standardmäßig `public`, wenn kein Sichtbarkeitsmodifikator deklariert ist, was die Rückwärtskompatibilität mit älteren PHP-Versionen wahrt. --- ## `iterable`-Pseudotyp Entspricht jedem Wert, der **`is_array()`** erfüllt oder eine Instanz von **`\Traversable`** ist: ```php // src/Collection.php function processItems(iterable $items): void { foreach ($items as $item) { // Funktioniert sowohl für Arrays als auch für Generator-/Iterator-Objekte } } ``` --- ## Catching multiple exception types Fangen Sie verschiedene Exceptions in einem einzigen Block mit dem Operator **`|`** ab: ```php // src/ApiConnector.php try { // API-Request ausführen } catch (ConnectionException | ResponseException $e) { // Hier beide Exception-Typen behandeln } ``` --- ## Schlüssel im list- / Short-Destructuring Sie können Schlüssel angeben, wenn Sie Arrays entpacken: ```php // src/UserProfile.php ['id' => $userId, 'name' => $username] = $user; ``` Dies funktioniert sowohl für `list()` als auch für die neue kurze `[]`-Syntax. --- ## Unterstützung für negative String-Offsets Indizieren Sie Strings vom Ende her mit negativen Zahlen: ```php // src/StrHelper.php $lastChar = 'abcdef'[-1]; // 'f' $sub = substr('abcdef', -3, -1); // 'de' ``` Negative Offsets werden auch beim String-Zeichenzugriff unterstützt: `$str[-2] = 'z';`. --- ## Bemerkenswerte Erweiterungen & Stdlib * **cURL HTTP/2**: Unterstützung für HTTP/2 Push und Multi-Server-Features. * **OpenSSL AEAD**: Unterstützung für AEAD-Modi (GCM und CCM) hinzugefügt. * **`session_gc()`**: Macht die standardmäßige Session-Garbage-Collection explizit aufrufbar. --- ## Praktische Rezepte ### Nullable-Methodensignatur ```php // src/recipes.php public function setName(?string $name): void { $this->name = $name; } ``` ### Datenbankzeilen mit Schlüsseln entpacken ```php // src/recipes.php foreach ($rows as ['id' => $id, 'role' => $role]) { // ... } ``` --- ## ⚠️ Häufige Fehler Hier sind typische Stolpersteine in PHP 7.1: ### 1. Rückgabe von `null` aus einer `void`-Funktion In PHP 7.1 löst die explizite Rückgabe von `null` aus einer als `void` markierten Funktion einen Fatal Error aus. ```php // src/BadVoid.php // Schlecht: Die explizite Rückgabe von null ist bei void-Rückgabetypen verboten function doNothing(): void { return null; // Fatal Error: A void function must not return a value } ``` ```php // src/GoodVoid.php // Gut: Verwenden Sie ein leeres return oder lassen Sie es ganz weg function doNothingGood(): void { return; } ``` ### 2. Die Annahme, dass `iterable` nur Arrays akzeptiert Die Prüfung von `is_array()` auf einen `iterable`-Parameter überspringt möglicherweise Generatoren oder Iterator-Klassen, was zu unerwarteten Laufzeitfehlern führen kann. ```php // src/BadIterable.php // Schlecht: Wirft Fehler, wenn $items ein Traversable-Objekt und kein Array ist function dumpItems(iterable $items) { echo count($items); // Fatal Error, wenn $items ein Generator ist (nicht Countable) } ``` ```php // src/GoodIterable.php // Gut: Bei Bedarf in Array konvertieren oder foreach verwenden (was beides handhaben kann) function dumpItemsGood(iterable $items) { foreach ($items as $item) { echo $item; } } ``` --- ## Einschränkungen * **Nullable-Typen**: Sie können Nullable-Typen nicht mit Union-Typen kombinieren. Das Schreiben von `?int|string` ist ein Syntaxfehler (Union-Typen werden erst in PHP 8.0 eingeführt). * **Sichtbarkeit von Konstanten**: Erzwingt die Zugriffskontrolle, unterstützt aber keine Typisierung von Klassenkonstanten. Das Schreiben von `public const int TIMEOUT = 10;` bleibt bis PHP 8.3 ein Syntaxfehler. --- ## Rückwärtskompatibilität und BC-Breaks ### Core & Typen * **Fehler bei zu wenigen Argumenten**: Das Übergeben von zu wenigen Argumenten an eine benutzerdefinierte Funktion wirft nun eine **`ArgumentCountError`**-Exception (anstelle einer Warnung). * **Verhalten von String-Offsets**: Der Zugriff auf leere Indizes `[]` bei Strings ist **nicht mehr stumm** oder wird über automatische Konvertierung toleriert. * **`iterable` ist ein reserviertes Wort**: Sie können Klassen, Interfaces oder Traits nicht mehr `iterable` nennen. --- ## Interaktives Quiz Testen Sie Ihr Wissen über PHP 7.1: 1. **Welche der folgenden Aussagen ist wahr für eine Funktion mit dem Rückgabetyp `void`?** * A) Sie muss explizit `null` zurückgeben. * B) Sie darf überhaupt keine `return`-Anweisung enthalten. * C) Sie kann ein leeres `return;` verwenden oder es weglassen. * D) Sie gibt standardmäßig `false` zurück.
Klicken, um die Antwort anzuzeigen **Richtige Antwort: C** Eine `void`-Funktion kann eine leere `return;`-Anweisung verwenden, um vorzeitig abzubrechen, oder sie ganz weglassen. Das Zurückgeben eines Wertes (selbst `null`) ist jedoch ein Syntaxfehler.
2. **Welche Exception wird geworfen, wenn in PHP 7.1 zu wenige Argumente an eine Benutzerfunktion übergeben werden?** * A) TypeError * B) ArgumentCountError * C) WarningException * D) Error
Klicken, um die Antwort anzuzeigen **Richtige Antwort: B** PHP 7.1 stuft Warnungen über fehlende Argumente zu einer werfbaren `ArgumentCountError`-Exception auf.
3. **Wie definiert man eine Klassenkonstante, auf die nur innerhalb der Klasse selbst zugegriffen werden kann?** * A) `private const MY_CONST = 1;` * B) `const private MY_CONST = 1;` * C) `protected const MY_CONST = 1;` * D) `private MY_CONST = 1;`
Klicken, um die Antwort anzuzeigen **Richtige Antwort: A** PHP 7.1 erlaubt die Verwendung von Standard-Sichtbarkeitsmodifikatoren für Klassenkonstanten: `public const`, `protected const` oder `private const`.
--- ## Schlussgedanken PHP 7.1 ist ein grundlegendes Release für **strenge Typenhygiene** und sauberere Datenstrukturen. Konvertieren Sie alte `list()`-Strukturen in `[]`, fügen Sie `?` zu optionalen Argumenten hinzu und passen Sie Ihre Exception-Catches an, um Ihre Anwendung auf PHP 7.2+ vorzubereiten.