---
title: 'PHP 7.0 from 5.6: Zend Engine 3, Scalar Types, ??, <=> & Migration | DevSense'
description: 'Upgrade-Leitfaden für PHP 7.0: Erfahren Sie alles über skalare Typdeklarationen, Rückgabetypen, Null-Coalescing (??), den Spaceship-Operator (<=>), anonyme Klassen, Throwable, CSPRNG und wichtige BC-Breaks.'
faq:
    - { question: 'Was sind skalare Typdeklarationen in PHP 7.0?', answer: "PHP 7.0 ermöglicht es Entwicklern, Typen (int, float, string, bool) für Funktionsparameter vorzuschreiben. Durch die Deklaration von 'declare(strict_types=1);' am Anfang einer Datei wird die automatische Typumwandlung deaktiviert." }
    - { question: 'Wie funktioniert der Null-Coalescing-Operator (??)?', answer: "Der Null-Coalescing-Operator ('??') gibt seinen ersten Operanden zurück, wenn dieser existiert und nicht null ist; andernfalls gibt er seinen zweiten Operanden zurück. Er ist eine Kurzschreibweise für häufige 'isset()'-Prüfungen." }
    - { question: 'Wofür wird der Spaceship-Operator (<=>) verwendet?', answer: "Der Spaceship-Operator ('<=>') vergleicht zwei Ausdrücke. Er gibt -1 zurück, wenn der linke Ausdruck kleiner als der rechte ist, 0, wenn sie gleich sind, und 1, wenn der linke größer ist. Dies macht Sortierfunktionen sehr gut lesbar." }
    - { question: 'Was ist der Unterschied zwischen Exception und Throwable in PHP 7.0?', answer: "PHP 7.0 führt das 'Throwable'-Interface ein. Sowohl 'Exception' als auch die neue 'Error'-Klasse (die Engine-Fehler repräsentiert) implementieren 'Throwable'. Sie müssen 'Throwable' abfangen, um beide Klassen zu behandeln." }
published: '2026-05-31'
---
# PHP 7.0: Hauptmerkmale

Was wäre, wenn Sie die Performance Ihrer Anwendung über Nacht verdoppeln könnten, indem Sie einfach Ihre Programmiersprache aktualisieren? PHP 7.0 hat genau das erreicht. Angetrieben von der neuen Zend Engine 3 führte es massive Geschwindigkeitsverbesserungen ein und brachte gleichzeitig strenge skalare Typen, Rückgabetypdeklarationen sowie moderne Operatoren wie Null-Coalescing. PHP 7.0 markiert einen monumentalen Sprung in der Geschichte von PHP und legt den Grundstein für moderne, typsichere und hochperformante Webanwendungen.

## Inhalt
* [Skalare Typdeklarationen](#scalar-types)
* [Rückgabetypdeklarationen](#return-types)
* [Null-Coalescing-Operator (`??`)](#null-coalescing)
* [Spaceship-Operator (`<=>`)](#spaceship-operator)
* [Konstante Arrays über `define()`](#constant-arrays)
* [Anonyme Klassen](#anonymous-classes)
* [Unicode-Codepoint-Escape-Syntax](#unicode-escape)
* [Gruppierte use-Deklarationen](#group-use)
* [Throwable-Interface & Engine-Exceptions](#throwable-exceptions)
* [CSPRNG-Funktionen](#csprng-functions)
* [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)

---

<a id="scalar-types"></a>
## Skalare Typdeklarationen

Skalare Parameter können Typen erzwingen: **`int`**, **`float`**, **`string`** und **`bool`**:

```php
// src/Math.php
declare(strict_types=1);

function add(int $a, int $b): int 
{
    return $a + $b;
}
```

> [!NOTE]
> Wussten Sie schon? Ohne `declare(strict_types=1);` am Anfang der Datei bleibt PHP im **Coercive-Modus** (toleranter Modus). Das bedeutet, dass es Strings wie `"5"` stillschweigend in Integer umwandelt, um die Parameterprüfung zu bestehen.

---

<a id="return-types"></a>
## Return type declarations

Definieren Sie, welchen Typ eine Funktion zurückgeben muss:

```php
// src/Generator.php
function generateId(): string 
{
    return uniqid();
}
```

Wenn eine `return`-Anweisung nicht diesem Typ entspricht, wirft PHP eine **`TypeError`**-Exception.

---

<a id="null-coalescing"></a>
## Null-Coalescing-Operator (`??`)

Syntaktischer Zucker für `isset()`-Prüfungen:

```php
// src/Config.php
$username = $_GET['user'] ?? 'anonymous';
```

Er kann verkettet werden: `$value = $a ?? $b ?? $default;`.

---

<a id="spaceship-operator"></a>
## Spaceship-Operator (`<=>`)

Drei-Wege-Vergleich, der `-1`, `0` oder `1` zurückgibt:

```php
// src/SortHelper.php
usort($list, function($a, $b) {
    return $a <=> $b;
});
```

Nützlich für Sortieroperationen, bei denen Standardvergleiche sonst eine umständliche bedingte Logik erfordern würden.

---

<a id="constant-arrays"></a>
## Konstante Arrays über `define()`

Array-Konstanten zur Laufzeit definieren:

```php
// src/Constants.php
define('ALLOWED_ROLES', ['admin', 'editor', 'guest']);
```

Zuvor konnten Arrays nur innerhalb von Klassen mithilfe von `const` als Konstanten definiert werden.

---

<a id="anonymous-classes"></a>
## Anonyme Klassen

Einfache Einweg-Objekte instanziieren:

```php
// src/LoggerProvider.php
$logger = new class {
    public function log(string $msg) {
        echo $msg;
    }
};
```

Sehr nützlich zum Mocken von Interfaces bei Unit-Tests.

---

<a id="unicode-escape"></a>
## Unicode-Codepoint-Escape-Syntax

Unicode-Symbole direkt in Strings einbetten:

```php
// src/Emoji.php
echo "\u{1F600}"; // Gibt ein lächelndes Emoji aus 😀
```

---

<a id="group-use"></a>
## Gruppierte use-Deklarationen

Mehrere Klassen sauber aus demselben Namespace importieren:

```php
// src/Controller.php
use App\Models\{User, Post, Comment};
```

---

<a id="throwable-exceptions"></a>
## Throwable-Interface & Engine-Exceptions

Fatale und behebbare Fehler werden nun als **`Error`**-Exceptions geworfen. Fangen Sie diese über das **`Throwable`**-Interface ab:

```php
// src/ErrorHandler.php
try {
    nonExistentFunction();
} catch (Throwable $t) {
    // Fängt sowohl Engine-Fehler als auch Benutzer-Exceptions ab
    echo "Caught: " . $t->getMessage();
}
```

> [!NOTE]
> Wussten Sie schon? `Error` erbt nicht von `Exception`. Das Abfangen von `Exception` verhindert nicht, dass Engine-Fehler wie der Aufruf einer undefinierten Funktion Ihr Skript zum Absturz bringen. Verwenden Sie stattdessen `Throwable`.

---

<a id="csprng-functions"></a>
## CSPRNG-Funktionen

Kryptographisch sichere Zufallswerte direkt vom Betriebssystem generieren:

```php
// src/TokenGenerator.php
$bytes = random_bytes(32);
$number = random_int(1, 100);
```

Diese Funktionen ersetzen unsichere Generatoren wie `rand()` oder `mt_rand()` in sicherheitskritischen Kontexten.

---

<a id="common-mistakes"></a>
## ⚠️ Häufige Fehler

Hier sind typische Stolpersteine bei der Migration auf PHP 7.0:

### 1. Vergessen, Strict Types zu deklarieren
Ohne die explizite Deklaration von Strict Types pro Datei läuft PHP im Coercive-Modus und konvertiert Argumentwerte stillschweigend.
```php
// src/BadStrict.php
// Schlecht: Coercive-Modus ist aktiv, String "10" wird stillschweigend zu int konvertiert
function setAge(int $age) {
    return $age;
}
setAge("10"); // Kein Fehler geworfen
```
```php
// src/GoodStrict.php
// Gut: Strict Types ganz oben in der Datei aktivieren
declare(strict_types=1);

function setAgeGood(int $age) {
    return $age;
}
// setAgeGood("10"); // Wirft TypeError
```

### 2. Abfangen von `Exception` bei Engine-Fehlern
Viele Entwickler fingen `Exception` ab und erwarteten, dass damit auch Fehler wie die Division durch Null abgefangen würden. Dies schlägt fehl, da Engine-Fehler die Klasse `Error` implementieren.
```php
// src/BadCatch.php
// Schlecht: Division durch Null wirft DivisionByZeroError (erbt von Error) und umgeht Exception
try {
    $value = 1 / 0;
} catch (Exception $e) {
    echo "Dieser Block wird nicht ausgeführt!";
}
```
```php
// src/GoodCatch.php
// Gut: Throwable oder Error abfangen, um Engine-Fehler zu erfassen
try {
    $value = 1 / 0;
} catch (Throwable $e) {
    echo "Fehler abgefangen: " . $e->getMessage();
}
```

---

<a id="limitations"></a>
## Einschränkungen

* **Skalare Typdeklarationen**: Können standardmäßig nicht nullable sein. Die Angabe von `int $x` und die Übergabe von `null` wirft einen TypeError (Nullable-Typen wurden in PHP 7.1 eingeführt).
* **Rückgabetypdeklarationen**: Können nicht als `void` (hinzugefügt in PHP 7.1) oder als mehrere Typen (Union-Typen hinzugefügt in PHP 8.0) deklariert werden.

---

<a id="backward-incompatible"></a>
## Rückwärtskompatibilität und BC-Breaks

### Core-Änderungen

* **ASP-Tags (`<% %>`) und Script-Tags (`<script language="php">`)** wurden vollständig entfernt.
* **`$HTTP_RAW_POST_DATA`** wurde entfernt; verwenden Sie stattdessen `php://input`.
* **Mehrere default-Blöcke in einem `switch`** werfen einen ParseError.
* **Globale Variablen und dynamische Aufrufe** werden strikt von links nach rechts analysiert (z. B. hat `$$foo['bar']` eine neue Auswertungsreihenfolge).

---

<a id="interactive-quiz"></a>
## Interaktives Quiz

Testen Sie Ihr Wissen über PHP 7.0:

1. **Welche Aussage trifft auf Strict Types in PHP 7.0 zu?**
   * A) Strict Types werden global über die php.ini aktiviert.
   * B) Strict Types müssen am Anfang jeder Datei deklariert werden, in der sie verwendet werden sollen.
   * C) PHP 7.0 läuft nur im Strict-Modus und hat keinen Coercive-Modus.
   * D) Strict Types gelten nur für Rückgabetypen, nicht für Parameter.

   <details>
   <summary>Klicken, um die Antwort anzuzeigen</summary>
   
   **Richtige Antwort: B**  
   Strict-Types werden dateiweise mittels `declare(strict_types=1);` deklariert.
   </details>

2. **Welche Klasse erbt in PHP 7.0 NICHT von Exception, implementiert aber Throwable?**
   * A) RuntimeException
   * B) Error
   * C) BadMethodCallException
   * D) InvalidArgumentException

   <details>
   <summary>Klicken, um die Antwort anzuzeigen</summary>
   
   **Richtige Antwort: B**  
   Die neue Klasse `Error` und ihre Unterklassen (wie `TypeError` oder `ParseError`) implementieren `Throwable`, erben aber nicht von `Exception`.
   </details>

3. **Was ist der Rückgabetyp des Spaceship-Operators (`<=>`)?**
   * A) Boolean
   * B) Float
   * C) Integer (`-1`, `0` oder `1`)
   * D) String

   <details>
   <summary>Klicken, um die Antwort anzuzeigen</summary>
   
   **Richtige Antwort: C**  
   Der Spaceship-Operator vergleicht zwei Werte und gibt `-1` zurück, wenn der linke kleiner ist, `0`, wenn sie gleich sind, und `1`, wenn der linke größer ist.
   </details>

---

<a id="closing-thoughts"></a>
## Schlussgedanken

PHP 7.0 ist ein **revolutionärer Meilenstein** in der Webentwicklung. Stellen Sie sicher, dass Ihr Server auf Zend Engine 3 läuft, rüsten Sie Ihre Legacy-Codebasis auf, indem Sie ASP-Tags entfernen, konvertieren Sie unsichere Zufallsfunktionen in CSPRNG-Äquivalente und schreiben Sie Exception-Catches auf Throwable um.