New Features in PHP 8.0: A Developer’s Guide with Code Examples

`PHP 8.0`, released in November 2020, introduced a host of powerful new features and optimizations. These changes not only improve performance but also modernize the language, making it more expressive and developer-friendly. Here’s a detailed look at the most significant additions, complete with code examples to help you get started.

Named Arguments

Named arguments allow you to pass values to function parameters by name, instead of relying solely on their position. This enhances readability and flexibility, especially for functions with many parameters or optional values.

function greet(string $name, int $age): void {
    echo "Hello, $name! You are $age years old.";
}

// Traditional way
greet('Alice', 30);

// Using named arguments
greet(age: 30, name: 'Alice');

Named arguments also let you skip optional parameters easily.

Union Types

Union types enable a parameter, property, or return type to accept multiple types, separated by the vertical bar (`|`). This is a major step towards stronger type safety.

class Number {
    private int|float $value;

    public function setValue(int|float $value): void {
        $this->value = $value;
    }

    public function getValue(): int|float {
        return $this->value;
    }
}

$num = new Number();
$num->setValue(5);
echo $num->getValue(); // 5
$num->setValue(11.54);
echo $num->getValue(); // 11.54

You can also declare `nullable` union types using `type|null`.

Attributes (Annotations)

Attributes provide a native way to add metadata to classes, functions, properties, and parameters, replacing the need for `PHPDoc` comments for certain use cases.

#[Route('/home', methods: ['GET'])]
function home() {
    // ...
}

Attributes are accessible via reflection, making them powerful for frameworks and libraries.

Constructor Property Promotion

This feature streamlines class property declaration and initialization, reducing boilerplate code in constructors.

class User {
    public function __construct(
        private string $name,
        private int $age
    ) {}
}

$user = new User('Bob', 25);

Properties are automatically declared and initialized from the constructor parameters.

Match Expressions

Match expressions are a concise, safer alternative to switch. They support strict type comparisons and can return values directly.

$status = 2;

$message = match ($status) {
    1 => 'Pending',
    2 => 'Approved',
    3 => 'Rejected',
    default => 'Unknown',
};

echo $message; // Approved

Match expressions do not require break statements and are less error-prone.

Nullsafe Operator

The nullsafe operator (`?->`) simplifies chained property or method access, avoiding verbose null checks.

// Instead of:
if ($user !== null && $user->profile !== null) {
    $bio = $user->profile->getBio();
}

// Use:
$bio = $user?->profile?->getBio();

If any part of the chain is `null`, the expression returns `null`.

New String Functions

`PHP 8.0` adds several handy string functions:

• `str_contains($haystack, $needle)` – Checks if a string contains a substring.
• `str_starts_with($haystack, $needle)` – Checks if a string starts with a substring.
• `str_ends_with($haystack, $needle)` – Checks if a string ends with a substring.

str_contains('Managed WordPress Hosting', 'WordPress'); // true
str_starts_with('PHP 8.0', 'PHP'); // true
str_ends_with('PHP 8.0', '8.0'); // true

These functions improve code clarity and reduce reliance on less intuitive functions like `strpos`.

Just-In-Time (`JIT`) Compiler

The `JIT` compiler brings significant performance improvements by compiling parts of the code at runtime. While it doesn’t always affect typical web requests, it can greatly speed up CPU-intensive tasks.

Other Notable Features

• Non-capturing catches: You can now catch exceptions without assigning them to a variable.

try {
    // code
} catch (Exception) {
    // handle
}

Trailing commas in parameter lists: You can add a trailing comma in function parameter lists and closure use lists.

function foo(
    $a,
    $b,
) {}

New functions: `fdiv()`, `get_debug_type()`, and `get_resource_id()` provide more robust and type-safe operations.

`PHP 8.0` is a landmark release that modernizes the language and boosts productivity. Whether you’re building new applications or maintaining legacy code, these features make `PHP` more expressive, safer, and enjoyable to use.