PHP versions 8.0 to 8.3 introduce a number of new features to improve language capabilities. 1. PHP 8.1 supports Union Types, allowing function parameters or return values ??to declare multiple types, such as int|float; 2. Introduce read-only attributes and classes to ensure immutability after initialization; 3. Add enumeration types to reduce the use of magic strings; 4. Support first-class citizen callable syntax to simplify functional programming; 5. Introduce Fiber to implement collaborative multitasking; 6. Add never return type, making it clear that the function does not return; 7. PHP 8.0 has added str_contains() function to improve string judgment readability; 8. Introduce match expressions to replace switch statements to make it more concise and safe; 9. Constructor attributes improve and reduce boilerplate code; 10. Each version continuously optimizes performance to improve execution speed and memory efficiency.

PHP has been evolving steady, and since the release of PHP 8.0 in late 2020, each minor version (8.1, 8.2, and now 8.3) has brought useful features, performance improvements, and better developer ergonomics. If you're maintaining or building modern PHP applications, it's worth knowing what's new across these versions — especially if you're considering upgrading.

Union Types (PHP 8.1)

One of the more impactful additions in PHP 8.1 is union types . Before this, if a function could accept multiple types, you had to rely on docblocks or just use mixed . Now, you can explicitly declare that a parameter or return value supports multiple types directly in the function signature.

Example:

 function setLength(int|float $length): void {
    // ...
}

This helps with code clarity and allow static analyzers and IDEs to catch issues earlier. It also plays well with type-safe frameworks and tools.

Note: There's also a | syntax for separating types, and null can be included like string|null .

Readonly Properties and Classes (PHP 8.1 & 8.2)

PHP 8.1 introduced readonly properties , which prevent property mutation after initialization. This is great for immutable data structures:

 class User {
    public function __construct(
        public readonly string $name,
        public readonly int $id
    ) {}
}

In PHP 8.2, this was extended to readonly classes , where all properties are implicitly readonly:

 readonly class User {
    public function __construct(
        public string $name,
        public int $id
    ) {}
}

These features help enforce immutability without boilerplate code, making models safer and easier to reason about.

Enums (PHP 8.1)

Enums are one of those features that make your code cleaner when dealing with fixed sets of values. PHP 8.1 added backed and pure enums .

Example of a backed enum:

 enum Status: string {
    case DRAFT = 'draft';
    case PUBLISHED = 'published';
}

You can access the value via Status::DRAFT->value , and even match against cases. Pure enums don't have backing values ??and are used more as symbolic constants.

Enums reduce magic strings in your codebase and allow for better validation and autocomplete in IDEs.

First-Class Callable Syntax (PHP 8.1)

This feature simplifies how you pass functions as calls. Instead of writing:

 array_map(fn($x) => strlen($x), $arr);

Now you can write:

 array_map(strlen(...), $arr);

Behind the scenes, it converts strlen(...) into a closure. This makes functional-style programming cleaner and less verbose, especially when chaining operations.

Fiber Support (PHP 8.1)

Fibers enable cooperative multitasking , which opens the door for async programming patterns in PHP. While PHP traditionally follows a synchronous request-response model, Fibers provides a foundation for future event-driven frameworks.

They're not widely used yet in most applications, but they're an important under-the-hood improvement that may shape how long-running PHP scripts behave in the future.

Never Return Type (PHP 8.1)

The never return type indicates that a function does not return — either because it throws an exception or terminates execution.

Example:

 function redirect(string $url): never {
    header("Location: $url");
    exit();
}

This helps static analysis tools understand your intent better and avoid false positives in code inspection.

New str_contains() Function (PHP 8.0)

Before PHP 8.0, checking if a string contains another string required using strpos() and comparing to false . Now, there's a clean built-in helper:

 if (str_contains('Hello World', 'World')) {
    // true
}

It's small but improves readability and reduces bugs from incorrect comparisons.

Match Expressions (PHP 8.0)

Match expressions are like enhanced switch statements. They return a value and do strict comparisons automatically.

Example:

 $status = match($code) {
    200 => 'OK',
    404 => 'Not Found',
    default => 'Unknown'
};

It's shorter than a traditional switch and avoids common pitfalls like missing break statements.

Constructor Property Promotion (PHP 8.0)

This cuts down on boilerplate in classes by allowing you to define and assign properties directly in the constructor:

 class Point {
    public function __construct(
        public float $x,
        public float $y,
        private float $z
    ) {}
}

No need to separately declare properties and assign them — it's done in one step.

Performance Improvements

Each new PHP 8 version includes optimizations that improve speed and reduce memory usage. For example, PHP 8.1 saw improvements in array handling and internal function calls, while PHP 8.2 optimized JIT compilation further. You might see up to 10–20% performance gains over older PHP 7.x versions depending on your workload.

If you're running older PHP versions, simply upgrading to 8.x can give a noticeable performance boost — especially for high-traffic apps.

That's a broad overview of what's new in PHP 8.0 through 8.3. These changes aren't flashy, but they make writing and maintaining PHP code smoother and safer. Whether it's better typing, cleaner syntax, or improved runtime behavior, the updates add up to a more modern and capable language.

The above is the detailed content of What are the new features in PHP 8 (8.0, 8.1, 8.2, 8.3)?. For more information, please follow other related articles on the PHP Chinese website!