# PHP 8.0 bis 8.5: Die wichtigsten Neuerungen

> PHP 8 Neuerungen von 8.0 bis 8.5: wichtigste Funktionen je Version, Codebeispiele, Abkündigungen mit Upgrade-Risiko und was sicherheitlich relevant ist.

Quelle: https://phpsos.de/php/php-8-neuerungen/  
Stand: 25.10.2026  
Anbieter: PHP SOS, PHP-Notfallhilfe und Server-Sicherheit. Soforthilfe per WhatsApp: https://wa.me/491736494914?text=Hallo%20PHP%20SOS%2C%20wir%20brauchen%20Hilfe%20mit%20unserem%20PHP-Server.%20Firma%3A%20%E2%80%A6%20Website%3A%20%E2%80%A6

**Kurz gesagt:** PHP 8.0 (November 2020) brachte benannte Argumente, Attribute, Union-Typen, `match`, den Nullsafe-Operator und einen JIT-Compiler. Danach folgten jährlich: 8.1 mit Enums und Fibers, 8.2 mit readonly-Klassen, 8.3 mit typisierten Klassenkonstanten, 8.4 mit Property Hooks und 8.5 mit Pipe-Operator und URI-Erweiterung. Jede Version kündigt auch Altes ab. Beim Upgrade zählen deshalb Tests, und für die Sicherheit zählt vor allem, einen unterstützten Zweig mit aktuellem Patch-Stand zu betreiben.

## Die PHP-8-Neuerungen im Überblick

Die Tabelle fasst die Kernpunkte der Release-Seiten von php.net zusammen. Daten der Erstveröffentlichung laut php.net.

| Version | Erschienen | Wichtigste Neuerungen | Auswahl Abkündigungen und Brüche |
|---|---|---|---|
| 8.0 | 26.11.2020 | benannte Argumente, Attribute, Constructor Property Promotion, Union-Typen, `match`, `?->`, JIT | `0 == 'foobar'` ist jetzt `false`, Typfehler statt Warnungen |
| 8.1 | 25.11.2021 | Enums, readonly-Eigenschaften, First-Class-Callables `strlen(...)`, `new` in Initialisierern, Intersection-Typen, `never`, Fibers | – |
| 8.2 | 08.12.2022 | readonly-Klassen, DNF-Typen, `null`/`false`/`true` als Typen, Random-Erweiterung, Konstanten in Traits, `#[\SensitiveParameter]` | dynamische Eigenschaften abgekündigt |
| 8.3 | 23.11.2023 | typisierte Klassenkonstanten, `#[\Override]`, `json_validate()`, `mb_str_pad()`, `php -l` für mehrere Dateien | – |
| 8.4 | 21.11.2024 | Property Hooks, asymmetrische Sichtbarkeit, `#[\Deprecated]`, neue DOM-API mit HTML5, `BcMath\Number`, `array_find()`, Lazy Objects | implizit nullable Parameter abgekündigt; IMAP, OCI8, PDO_OCI, pspell nach PECL |
| 8.5 | 20.11.2025 | Pipe-Operator, URI-Erweiterung, Clone With, `#[\NoDiscard]`, `array_first()`/`array_last()` | Backtick-Operator abgekündigt, `disable_classes` entfernt |

## PHP 8.0 und 8.1: der große Schritt

PHP 8.0 hat die Sprache spürbar strenger und ausdrucksstärker gemacht. Laut Release-Seite werfen interne Funktionen nun konsequent `TypeError` oder `ValueError`, statt nur Warnungen auszugeben. Vergleiche zwischen Zahlen und Zeichenketten folgen saubereren Regeln.

```php
<?php
// PHP 8.0: match vergleicht strikt und braucht kein break
$status = 404;
echo match (true) {
    $status >= 500 => 'Serverfehler',
    $status >= 400 => 'Anfragefehler',
    default        => 'in Ordnung',
};

// PHP 8.0: Nullsafe-Operator
$land = $bestellung?->kunde?->adresse?->land;
```

PHP 8.1 brachte Enums, also Aufzählungstypen mit festen Werten, und readonly-Eigenschaften, die nur einmal gesetzt werden können:

```php
<?php
enum Rolle: string {
    case Leser = 'leser';
    case Redakteur = 'redakteur';
    case Admin = 'admin';
}

final class Benutzer {
    public function __construct(
        public readonly string $name,
        public readonly Rolle $rolle,
    ) {}
}

$b = new Benutzer('Erika', Rolle::from('redakteur'));
```

`Rolle::from()` wirft einen Fehler bei unbekannten Werten. Das verhindert, dass beliebige Zeichenketten aus Formularen als Rolle durchrutschen. Wer statt eines Fehlers einen leeren Wert braucht, nutzt `Rolle::tryFrom()`, das bei unbekannten Werten `null` zurückgibt.

Ebenfalls neu in 8.1 sind Fibers, eine Grundlage für nebenläufige Abläufe, auf der Bibliotheken für asynchrone Verarbeitung aufbauen. Im normalen Website-Betrieb bemerkt man davon wenig, in modernen Frameworks und Warteschlangen dagegen schon.

## PHP 8.2 und 8.3: Aufräumen und Absichern

PHP 8.2 kündigte dynamische Eigenschaften ab. Wer einem Objekt eine nicht deklarierte Eigenschaft zuweist, erhält einen Hinweis; mit `#[\AllowDynamicProperties]` lässt sich das für einzelne Klassen erlauben. Ältere Plugins erzeugen deshalb oft viele Meldungen im Log.

Für die Sicherheit interessant sind die neue Random-Erweiterung, deren Standard-Randomizer laut Release-Seite einen kryptografisch sicheren Zufallsgenerator nutzt, und das Attribut `#[\SensitiveParameter]`, das Werte wie Passwörter in Stacktraces verbirgt. Mehr zu sicheren Zufallswerten unter [Sichere Zufallszahlen und Tokens in PHP](https://phpsos.de/blog/sichere-tokens-php/).

PHP 8.3 ergänzte typisierte Klassenkonstanten, das Attribut `#[\Override]` gegen Tippfehler beim Überschreiben von Methoden und `json_validate()`, das JSON prüft, ohne es vollständig zu dekodieren.

## PHP 8.4 und 8.5: moderne Sprachmittel

PHP 8.4 führte Property Hooks ein, also Logik direkt an Eigenschaften, und asymmetrische Sichtbarkeit wie `public private(set)`. Dazu kamen eine neue DOM-API mit HTML5-Unterstützung und Funktionen wie `array_find()`, `array_any()` und `array_all()`. Laut Release-Seite wurden die Erweiterungen IMAP, OCI8, PDO_OCI und pspell aus dem Kern nach PECL verschoben. Anwendungen, die etwa IMAP nutzen, brauchen dann ein separates Paket.

PHP 8.5 brachte den Pipe-Operator, der Aufrufe von links nach rechts verkettet:

```php
<?php
$slug = '  Neue Produkte 2026  '
    |> trim(...)
    |> strtolower(...)
    |> (fn(string $s): string => str_replace(' ', '-', $s));
// Ergebnis: "neue-produkte-2026"
```

Neu ist auch eine URI-Erweiterung, die Adressen nach RFC 3986 und dem WHATWG-URL-Standard zerlegt. Das ist sicherheitlich relevant, weil uneinheitlich geparste URLs eine bekannte Ursache für umgangene Prüfungen sind. Der Backtick-Operator als Kurzform von `shell_exec()` ist abgekündigt, die Einstellung `disable_classes` wurde entfernt. Wer sie nutzte, sollte seine Härtung anpassen.

## Neuerungen, Upgrades und PHP2Shell

Neue Sprachfunktionen schließen keine Lücken im Interpreter. Gegen PHP2Shell hilft nur der aktuelle Patch-Stand des jeweiligen Zweigs: 8.5.12, 8.4.27, 8.3.36 oder 8.2.35. Für PHP 8.1 und 8.0 gibt es keine offiziellen Updates mehr. Wer dort festhängt, muss upgraden, und dabei helfen die Neuerungen wenig, die Brüche dagegen viel.

Ein sicherer Upgrade-Weg in fünf Schritten:

1. Zielversion festlegen, passend zu den Systemanforderungen des Herstellers und zum [Release-Zyklus](https://phpsos.de/php/release-zyklus/).
2. Abhängigkeiten per Composer und Plugins auf kompatible Stände bringen.
3. Code mit statischer Analyse und Tests gegen die Zielversion prüfen.
4. In einer Testumgebung mit Produktionsdaten-Kopie ausprobieren, Logs auf Abkündigungen auswerten.
5. Umstellen, alle PHP-Prozesse neu starten und den Stand dokumentieren.

Hintergründe zu Typen liefert [Das Typsystem von PHP](https://phpsos.de/php/typsystem/).

## Wie hilft PHP SOS konkret?

- **Kompatibilität prüfen:** Wir analysieren Ihren Code und Ihre Erweiterungen auf Brüche zur Zielversion.
- **Upgrade durchführen:** Mit der [Migration auf eine unterstützte PHP-Version](https://phpsos.de/leistungen/php-migration-legacy/) heben wir Anwendungen getestet an.
- **Härtung anpassen:** Wir ersetzen entfernte Einstellungen wie `disable_classes` durch wirksame Alternativen.
- **Patch-Stand halten:** Nach dem Upgrade halten wir den Zweig aktuell und belegen jeden Neustart.


## Häufige Fragen

**Welche PHP-8-Version sollte ich heute einsetzen?**  
Für neue Projekte PHP 8.4 oder 8.5, weil sie am längsten unterstützt werden: 8.4 bis Ende 2028, 8.5 bis Ende 2029. Entscheidend ist, was Ihre Anwendung laut Systemanforderungen des Herstellers unterstützt. PHP 8.2 endet am 31. Dezember 2026.

**Was bricht beim Wechsel von PHP 7.4 auf PHP 8 am häufigsten?**  
Oft sind es strengere Typprüfungen: Interne Funktionen werfen in PHP 8 TypeError oder ValueError statt nur Warnungen auszugeben. Auch geänderte Vergleiche zwischen Zahlen und Zeichenketten fallen auf. Statische Analyse und Tests decken das meiste vorab auf.

**Macht der JIT meine Website schneller?**  
Meist kaum. Laut Release-Seite zu PHP 8.0 liegt die Leistung typischer Webanwendungen etwa auf dem Niveau von PHP 7.4, während rechenintensive Aufgaben deutlich profitieren können. Seit PHP 8.4 ist der JIT standardmäßig abgeschaltet.

**Welche Neuerungen helfen der Sicherheit?**  
Unter anderem die neue Random-Erweiterung in PHP 8.2 mit kryptografisch sicherem Standard, das Attribut SensitiveParameter gegen Passwörter in Stacktraces, Enums und readonly-Eigenschaften für eindeutigere Daten sowie die konsequenteren Typfehler seit PHP 8.0.

## Quellen

- [php.net: PHP 8.0 Release](https://www.php.net/releases/8.0/en.php)
- [php.net: PHP 8.4 Release](https://www.php.net/releases/8.4/en.php)
- [php.net: PHP 8.5 Release](https://www.php.net/releases/8.5/en.php)
- [PHP 8 ChangeLog](https://www.php.net/ChangeLog-8.php)
- [php.net: Unterstützte Versionen](https://www.php.net/supported-versions.php)