Modern PHP

Modern PHP

Explore PHP's modern features like constructor property promotion, match expressions, and nullsafe operators. 

PHP has evolved significantly in recent years. Let's look at some modern features that make PHP code cleaner, safer, and more enjoyable to write. These features are especially relevant when working with frameworks like Laravel.

Performance Improvements

PHP 8 brought significant performance improvements through various optimizations in its core engine. Modern PHP applications run noticeably faster, making PHP a strong choice for web development in 2025.

Constructor Property Promotion (PHP 8.0)

One of the most welcome improvements in modern PHP is constructor property promotion. It eliminates the boilerplate code of declaring properties and then assigning them in the constructor. This is particularly useful for data objects and simple classes:

 1// Old way
 2class User {
 3    public string $name;
 4    public string $email;
 5 
 6    public function __construct(string $name, string $email) {
 7        $this->name = $name;
 8        $this->email = $email;
 9    }
10 
11}
12 
13// Modern way
14class User {
15    public function __construct(
16        public string $name,
17        public string $email,
18    ) {}
19}

// Old way
class User {
    public string $name;
    public string $email;

    public function __construct(string $name, string $email) {
        $this->name = $name;
        $this->email = $email;
    }

}

// Modern way
class User {
    public function __construct(
        public string $name,
        public string $email,
    ) {}
}

Readonly Properties (PHP 8.1)

Readonly properties add an extra layer of safety to your code. Once a property is set in the constructor, it cannot be changed. This is great for values that should remain constant throughout an object's lifetime, like IDs, dates of creation, or configuration values:

1class Price {
2    public function __construct(
3        public readonly float $amount,
4        public readonly string $currency
5    ) {}
6}

class Price {
    public function __construct(
        public readonly float $amount,
        public readonly string $currency
    ) {}
}

Match Expression (PHP 8.0)

The match expression is a modern replacement for the switch statement. It's more concise, returns values directly, and does strict comparisons by default. It's perfect for mapping values or handling different cases:

 1// Old way with switch
 2switch ($status) {
 3    case 200:
 4        $result = 'success';
 5        break;
 6    case 404:
 7        $result = 'not found';
 8        break;
 9    case 500:
10        $result = 'server error';
11        break;
12    default:
13        $result = 'unknown status';
14}
15 
16// Modern way with match
17$result = match ($status) {
18    200 => 'success',
19    404 => 'not found',
20    500 => 'server error',
21    default => 'unknown status'
22};

// Old way with switch
switch ($status) {
    case 200:
        $result = 'success';
        break;
    case 404:
        $result = 'not found';
        break;
    case 500:
        $result = 'server error';
        break;
    default:
        $result = 'unknown status';
}

// Modern way with match
$result = match ($status) {
    200 => 'success',
    404 => 'not found',
    500 => 'server error',
    default => 'unknown status'
};

Nullsafe Operator (PHP 8.0)

The nullsafe operator (?->) helps prevent null reference errors when accessing properties or methods in a chain. It's particularly useful when working with optional relationships or nested data structures:

 1// Old way
 2$country = null;
 3 
 4if ($user !== null) {
 5    if ($user->getAddress() !== null) {
 6        $country = $user->getAddress()->getCountry();
 7    }
 8}
 9 
10// Modern way
11$country = $user?->getAddress()?->getCountry();

// Old way
$country = null;

if ($user !== null) {
    if ($user->getAddress() !== null) {
        $country = $user->getAddress()->getCountry();
    }
}

// Modern way
$country = $user?->getAddress()?->getCountry();

Named Arguments (PHP 8.0)

Named arguments make function and method calls more explicit and self-documenting. They're especially useful when dealing with multiple optional parameters or when the parameter names are important for understanding:

1$user = new User("John", "[[email protected]](<mailto:[email protected]>)");
2 
3// Works the same
4$user = new User(
5    name: "John",
6    email: "[[email protected]](<mailto:[email protected]>)"
7);

$user = new User("John", "[[email protected]](<mailto:[email protected]>)");

// Works the same
$user = new User(
    name: "John",
    email: "[[email protected]](<mailto:[email protected]>)"
);

Typed Properties (PHP 7.4)

Type declarations for properties help catch errors early and make code more reliable. PHP will ensure that only values of the correct type can be assigned to these properties:

1class User {
2    public string $name;
3    public int $age;
4    public ?string $email = null;  // Nullable string
5}

class User {
    public string $name;
    public int $age;
    public ?string $email = null;  // Nullable string
}

These modern features make PHP code:

More concise and expressive
Safer with better type checking
Easier to read and maintain
Less prone to errors