Categories

PHP 8.x Features That Will Actually Make Your Code Better (No Fluff)

Donate with

Donate BAT now

Verified BAT publisher

Introduction

PHP 8 brought a massive wave of changes to the language, but let's be honest—not all features are created equal. Some are incredibly useful in your day-to-day coding, while others are niche or overly complex. If you're a junior developer trying to level up your PHP skills, this guide will show you the features that actually matter and how they'll make your code cleaner, safer, and easier to maintain.

We'll skip the academic examples and focus on real-world improvements you can start using today. For each feature, you'll see a "before" and "after" comparison so you can understand exactly what problem it solves.

Union Types: Stop Guessing What Your Function Returns

Before PHP 8, if a function could return multiple types, you had to document it in a comment or just hope other developers would figure it out. Union types let you declare that a parameter or return value can be one of several types, making your code self-documenting and type-safe.

Before PHP 8:

/**
 * @return array|false
 */
function getUserData(int $id) {
    $user = findUser($id);
    if (!$user) {
        return false;
    }
    return $user;
}

With PHP 8 Union Types:

function getUserData(int $id): array|false {
    $user = findUser($id);
    if (!$user) {
        return false;
    }
    return $user;
}

The difference might seem small, but it's huge for reliability. Your IDE will now understand the return type and warn you if you're using it incorrectly. Plus, PHP will throw an error if you accidentally return the wrong type, catching bugs before they reach production.

Real-World Tip

Union types are especially useful for functions that return data or null, like int|null or string|null. This is cleaner than using the older ?int syntax when you need more than two types.

Named Arguments: Make Function Calls Self-Explanatory

Have you ever looked at a function call like createUser('John', true, false, 25) and wondered what those booleans mean? Named arguments solve this problem by letting you specify parameter names when calling a function.

Before PHP 8:

function createUser(string $name, bool $isActive, bool $isAdmin, int $age) {
    // ... implementation
}

// What do these booleans mean?
createUser('John', true, false, 25);

With PHP 8 Named Arguments:

createUser(
    name: 'John',
    isActive: true,
    isAdmin: false,
    age: 25
);

Now it's crystal clear what each value represents. Even better, you can skip optional parameters in the middle without having to pass null for them. If isAdmin has a default value, you can just omit it entirely.

When to Use Named Arguments

Named arguments shine when working with functions that have many parameters, especially boolean flags. They're also great for config arrays and builder patterns where clarity matters more than brevity.

Constructor Property Promotion: Less Boilerplate, More Productivity

Creating a class in PHP used to involve a lot of repetitive typing: declare properties, then assign them in the constructor. Constructor property promotion cuts this boilerplate in half.

Before PHP 8:

class User {
    private string $name;
    private string $email;
    private int $age;
    
    public function __construct(string $name, string $email, int $age) {
        $this->name = $name;
        $this->email = $email;
        $this->age = $age;
    }
}

With PHP 8 Constructor Property Promotion:

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

That's it! By adding visibility modifiers (private, public, protected) to constructor parameters, PHP automatically creates the properties and assigns them. You save lines of code and reduce the chance of typos.

Match Expression: A Better Switch Statement

The switch statement has always been a bit clunky in PHP—it requires break statements, falls through unexpectedly, and doesn't return values directly. The match expression fixes all of this.

Before PHP 8 (using switch):

switch ($status) {
    case 'pending':
        $message = 'Your order is being processed';
        break;
    case 'shipped':
        $message = 'Your order is on the way';
        break;
    case 'delivered':
        $message = 'Your order has arrived';
        break;
    default:
        $message = 'Unknown status';
}

With PHP 8 Match Expression:

$message = match($status) {
    'pending' => 'Your order is being processed',
    'shipped' => 'Your order is on the way',
    'delivered' => 'Your order has arrived',
    default => 'Unknown status'
};

The match expression is more concise, returns a value directly, and uses strict comparison (===) by default. No more forgetting break statements and causing bugs!

Important Difference

Unlike switch, match throws an error if no case matches and there's no default. This is actually a good thing—it forces you to handle all possible cases explicitly.

Enums: Stop Using Magic Strings and Constants

PHP 8.1 introduced enums (enumerations), which let you define a set of named values. If you've been using class constants or strings to represent status codes, payment methods, or user roles, enums are a massive upgrade.

Before PHP 8.1:

class OrderStatus {
    const PENDING = 'pending';
    const SHIPPED = 'shipped';
    const DELIVERED = 'delivered';
}

function updateOrder(string $status) {
    // You could pass any string here, even invalid ones
    if ($status === OrderStatus::PENDING) {
        // ...
    }
}

updateOrder('invalid'); // This won't cause an error!

With PHP 8.1 Enums:

enum OrderStatus: string {
    case PENDING = 'pending';
    case SHIPPED = 'shipped';
    case DELIVERED = 'delivered';
}

function updateOrder(OrderStatus $status) {
    if ($status === OrderStatus::PENDING) {
        // ...
    }
}

updateOrder(OrderStatus::PENDING); // Type-safe!
// updateOrder('invalid'); // This will cause a type error!

Enums make your code type-safe and prevent invalid values from sneaking in. Your IDE will also provide autocomplete for all possible enum values, making development faster.

Readonly Properties: Immutable by Design

PHP 8.1 added readonly properties, and PHP 8.2 took it further with readonly classes. This feature ensures that once a property is set (usually in the constructor), it can never be changed. This is perfect for value objects and DTOs (Data Transfer Objects).

Before PHP 8.1:

class Money {
    private float $amount;
    private string $currency;
    
    public function __construct(float $amount, string $currency) {
        $this->amount = $amount;
        $this->currency = $currency;
    }
    
    // Need getters, but no setters to enforce immutability
    public function getAmount(): float {
        return $this->amount;
    }
}

With PHP 8.1 Readonly Properties:

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

$money = new Money(100.00, 'USD');
echo $money->amount; // Works fine
// $money->amount = 200; // Error! Cannot modify readonly property

Combining readonly with constructor property promotion creates incredibly concise, immutable value objects. No need to write getters—the properties are public but can't be changed.

PHP 8.2: Readonly Classes

In PHP 8.2, you can mark an entire class as readonly, which makes all its properties readonly automatically:

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

Nullsafe Operator: Chain Calls Without Fear

How many times have you written code like if ($user && $user->getProfile() && $user->getProfile()->getAddress())? The nullsafe operator (?->) makes this much cleaner.

Before PHP 8:

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

With PHP 8 Nullsafe Operator:

$country = $user?->getProfile()?->getAddress()?->getCountry();

If any part of the chain returns null, the entire expression short-circuits and returns null. No more nested if statements or temporary variables.

String Functions: str_contains, str_starts_with, str_ends_with

PHP 8 finally added functions that developers have wanted for years. Instead of using strpos() or regex for simple string checks, you now have intuitive, readable functions.

Before PHP 8:

// Check if string contains another string
if (strpos($email, '@') !== false) {
    // Contains @
}

// Check if string starts with something
if (substr($filename, 0, 4) === 'img_') {
    // Starts with img_
}

With PHP 8 String Functions:

if (str_contains($email, '@')) {
    // Contains @
}

if (str_starts_with($filename, 'img_')) {
    // Starts with img_
}

if (str_ends_with($filename, '.jpg')) {
    // Ends with .jpg
}

These functions return boolean values directly and are much more readable. No more checking for !== false or calculating string lengths for substr.

Practical Advice: Start Small, Refactor Gradually

You don't need to rewrite your entire codebase to take advantage of PHP 8 features. Start by using them in new code you write. When you're refactoring existing code, look for opportunities to replace old patterns:

• Replace class constants with enums when you have a fixed set of values
• Use constructor property promotion in new classes
• Convert switch statements to match expressions where it makes sense
• Add union types to function signatures for better type safety
• Replace strpos checks with str_contains, str_starts_with, and str_ends_with

Conclusion: Modern PHP is Worth Learning

PHP 8 and its subsequent versions have transformed PHP from a loosely-typed scripting language into a modern, type-safe programming language. These features aren't just syntactic sugar—they prevent bugs, make your code more maintainable, and improve the developer experience significantly.

As a junior developer, getting comfortable with these features will make you more productive and your code more professional. Start experimenting with them in your next project, and you'll quickly wonder how you ever lived without them.

The best part? We're still in the PHP 8.x era, which means more improvements are coming. But master these core features first, and you'll have a solid foundation for whatever comes next in the PHP ecosystem.