A Beginner’s Guide to Constructor Property Promotion in PHP

PHP 8 introduced a fantastic feature called Constructor property promotion. If you're new to PHP or programming in general, this might sound a bit complex. But don’t worry! This blog will walk you through what it is, why it's useful, and how you can use it with plenty of coding examples. Let’s get started!

What is constructor property promotion?

Before PHP 8, creating a class with properties and initializing them in a constructor required quite a bit of repetitive code. With Constructor Property Promotion, PHP 8 simplifies this process by letting you declare and initialize class properties directly in the constructor parameters.

Why should you care?

Constructor Property Promotion isn’t just about saving a few lines of code—it’s about making your code cleaner, easier to read, and simpler to maintain. This is especially valuable for beginners who might find the traditional way of writing constructors a bit daunting.

Traditional Way vs. Constructor Property Promotion

Let’s start by comparing the traditional way of writing classes and constructors with the new way introduced in PHP 8.

Before PHP 8 (Traditional Way)

class Car {
    public string $make;
    public string $model;
    public int $year;

    public function __construct(string $make, string $model, int $year) {
        $this->make = $make;
        $this->model = $model;
        $this->year = $year;
    }
}

$car = new Car('Toyota', 'Corolla', 2020);

In this example, we have to declare the properties ($make, $modeland $year) and then assign them inside the constructor. It’s a lot of repetition, especially when dealing with classes that have many properties.

With PHP 8 (Constructor Property Promotion),

class Car {
    public function __construct(
        public string $make,
        public string $model,
        public int $year
    ) {}
}

$car = new Car('Toyota', 'Corolla', 2020);

With Constructor Property Promotion, you declare and assign the properties in the constructor parameters. The result is a more concise and readable class definition.

More Coding Examples

To fully understand the power of Constructor Property Promotion, let’s explore more examples in different scenarios.

Example 1: Defining a Book Class

class Book {
    public function __construct(
        public string $title,
        public string $author,
        public int $pages,
        public bool $isAvailable = true
    ) {}
}

$book = new Book('1984', 'George Orwell', 328);
echo $book->title; // Output: 1984
echo $book->isAvailable; // Output: 1 (true)

In this Book class, the isAvailable property has a default value of true. If you don't specify this parameter when creating an instance of the class, it will automatically be set to true.

Example 2: Creating an Order Class

class Order {
    public function __construct(
        public int $orderId,
        public string $product,
        public float $price,
        public string $status = 'pending'
    ) {}
}

$order = new Order(123, 'Laptop', 999.99);
echo $order->status; // Output: pending

$order2 = new Order(124, 'Smartphone', 599.99, 'shipped');
echo $order2->status; // Output: shipped

Here, the Order class includes a status property with a default value of pending. However, you can override this value by providing a different status when creating the order.

Example 3: Building a User Profile Class

class UserProfile {
    public function __construct(
        public string $username,
        public string $email,
        public int $age,
        private string $password,
        protected string $role = 'user'
    ) {}

    public function getPassword(): string {
        return $this->password;
    }
}

$userProfile = new UserProfile('johndoe', 'john@example.com', 25, 'secret');
echo $userProfile->username; // Output: johndoe
echo $userProfile->getPassword(); // Output: secret
echo $userProfile->role; // Error: Cannot access protected property

In the UserProfile class, the password property is private, meaning it can’t be accessed directly outside the class. Instead, you use the getPassword() method to retrieve it. The role property is protected, so it can be accessed only within the class itself or by subclasses.

Example 4: A Product Class with Constructor Property Promotion

class Product {
    public function __construct(
        public string $name,
        public float $price,
        public int $stock = 0
    ) {}
}

$product = new Product('Laptop', 999.99, 10);
echo $product->name; // Output: Laptop
echo $product->stock; // Output: 10

This example shows how you can use Constructor Property Promotion to create a Product class that includes a default value for the stock property.

Benefits of Constructor Property Promotion

• Less Boilerplate Code: You don’t need to write repetitive code to declare and initialize properties.

• Increased Readability: The class definition is more concise and easier to understand at a glance.

• Reduced Errors: By combining property declaration and initialization, there’s less room for mistakes.

Conclusion

Constructor Property Promotion in PHP 8 is a powerful feature that can significantly improve the way you write classes. By reducing boilerplate code, increasing readability, and making your code more maintainable, it’s a feature that both new and experienced developers will appreciate.

Whether you're building a small project or a large application, Constructor Property Promotion will help you write cleaner, more efficient PHP code. So go ahead, give it a try in your next project, and enjoy the benefits of this awesome feature!