Welche Hauptfunktionen fügte PHP 8.x hinzu?

Question

Accepted Answer

**PHP 8.x** (8.0–8.3) brachte bedeutende Verbesserungen, die die Sprache modernisierten — Leistung (JIT), neue Syntax-Annehmlichkeiten und stärkere Typisierung. Die Kenntnis dieser Funktionen ist wichtig für das Schreiben von modernem, idiomatischem PHP und für deren Erkennung in modernen Codebasen.

## Wichtige PHP 8.0-Funktionen

```php
// 1. Named arguments — pass by parameter name, skip optional ones
setCookie(name: "theme", value: "dark", httponly: true);

// 2. Constructor property promotion — declare + assign properties in the signature
class Point {
    public function __construct(public int $x, public int $y) {}   // no boilerplate
}

// 3. Union types
function process(int|string $id): void {}

// 4. The match expression — value-returning, strict, no fall-through
$result = match($status) {
    200, 201 => "success",
    404 => "not found",
    default => "unknown",
};

// 5. Nullsafe operator — short-circuit on null in a chain
$city = $user?->address?->city;   // null if any link is null (no error)

// 6. The JIT compiler (performance for CPU-bound code)
```

## PHP 8.1-Funktionen

```php
// Enums — first-class enumerated types (finally!)
enum Status: string {
    case Active = 'active';
    case Inactive = 'inactive';
}

// Readonly properties — immutable after initialization
class User { public function __construct(public readonly string $id) {} }

// First-class callable syntax
$fn = strlen(...);    // create a closure from a function

// Pure intersection types: function f(A&B $x)
// Fibers (low-level async primitive)
```

## PHP 8.2 und 8.3-Funktionen

```php
// 8.2: readonly classes, disjunctive normal form (DNF) types, null/false/true as types
readonly class DTO { public function __construct(public string $name) {} }

// 8.3: typed class constants, #[\Override] attribute, json_validate(), dynamic class constant fetch
class Config { const string VERSION = "1.0"; }   // typed constant
```

## Warum das wichtig ist (die Themen)

```text
✓ Less boilerplate — constructor promotion, named args, match, nullsafe
✓ Stronger typing — union/intersection types, enums, readonly, typed constants
✓ Better performance — JIT, plus general engine speedups each release
✓ More expressive, safer, modern syntax overall
```

## Warum es wichtig ist

Das Verständnis der Hauptfunktionen von PHP 8.x ist wichtig für das Schreiben von modernem, idiomatischem PHP und für die Erkennung dieser Konstrukte in aktuellen Codebasen — die 8.x-Releases stellen eine signifikante Modernisierung der Sprache dar, die ihre Ausdruckskraft, Typsicherheit und Leistung dramatisch verbessert hat und PHPs angestaubtem Ruf entgegenwirkt.

Mehrere Funktionen sind jetzt alltägliche Werkzeuge in modernem PHP: **Constructor-Property-Promotion** (Beseitigung repetitiven Boilerplate-Codes), **benannte Argumente** (lesbare, flexible Aufrufe), **`match`-Ausdrücke** (eine sicherere, wertverarbeitende Alternative zu switch), der **nullsafe-Operator** (`?->`, saubere Null-Behandlung in Ketten), und besonders **Enums** (PHP 8.1 — erstklassige enumerierte Typen, weit verbreitet für typsichere Konstantenmengen) und **readonly-Eigenschaften/Klassen** (für Unveränderlichkeit).

Diese reduzieren Boilerplate, verstärken Typisierung und machen Code aussagekräftiger und sicherer.

Die Kenntnis dieser Funktionen ist wesentlich für das Lesen und Schreiben von aktuellem PHP (da moderne Frameworks und Codebasen sie umfangreich nutzen), für die Wahl des idiomatischen modernen Ansatzes gegenüber älteren Mustern und zum Verständnis, warum modernes PHP eine fähige, gut gestaltete Sprache ist, anstelle der inkonsistenten Sprache mit seinem früheren Ruf.

Mit der Entwicklung der Sprache Schritt zu halten — zu wissen, was jedes 8.x-Release hinzugefügt hat, und diese Funktionen angemessen zu nutzen — ist wichtiges Wissen, das Entwickler auszeichnet, die modernes, professionelles PHP schreiben, von denen, die in veralteten Mustern stecken, und widerspiegelt Vertrautheit mit dem zeitgenössischen Stand der Sprache.