What major features did PHP 8.x add?

Question

Accepted Answer

**PHP 8.x** (8.0–8.3) brought major improvements that modernized the language — performance (JIT), new syntax conveniences, and stronger typing. Knowing these features is important for writing current, idiomatic PHP and recognizing them in modern codebases.

## Key PHP 8.0 features

```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 features

```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 and 8.3 features

```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
```

## Why these matter (the themes)

```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
```

## Why it matters

Understanding PHP 8.x's major features is important for writing modern, idiomatic PHP and for recognizing these constructs in current codebases — the 8.x releases represent a significant modernization of the language that dramatically improved its expressiveness, type safety, and performance, helping shed PHP's dated reputation.

Several features are now everyday tools in modern PHP: **constructor property promotion** (eliminating repetitive boilerplate), **named arguments** (readable, flexible calls), the **`match` expression** (a safer, value-returning alternative to switch), the **nullsafe operator** (`?->`, clean null handling in chains), and especially **enums** (PHP 8.1 — first-class enumerated types, widely used for type-safe constant sets) and **readonly properties/classes** (for immutability).

These reduce boilerplate, strengthen typing, and make code more expressive and safer.

Knowing these features is essential for reading and writing current PHP (since modern frameworks and codebases use them extensively), for choosing the idiomatic modern approach over older patterns, and for understanding why modern PHP is a capable, well-designed language rather than the inconsistent one of its early reputation.

Staying current with the language's evolution — knowing what each 8.x release added and using these features appropriately — is important knowledge that distinguishes developers writing modern, professional PHP from those stuck in outdated patterns, and reflects fluency with the contemporary state of the language.