Recap PHP 8.4 Property Hooks in 2025

Last year in April, I wrote about the Property Hooks RFC added to PHP 8.4 and my thoughts about it. The blog post appeared one day after the RFC was accepted and that is why the post was more theoretical. Now, almost two month after release, I want to address this topic again and want to share my thoughts after working with Property Hooks in practice. I want also express my opinion regarding to Property Hooks since I ended my last post with:

Since the RFC includes declaring properties, I think it is worth to give it a chance. I know that many programmers will have a pain in the stomach juggling with properties publicly, but technically, the getters and setters are not away – they are just handled differently.
Property Hooks RFC for PHP 8.4

Understanding Property Hooks

A short profiling: what are Property Hooks? The feature allows developers to define custom behavior directly within class properties, shrinking code and reducing the need for boilerplate getter and setter methods.

Property Hooks enable the definition of get and set operations within a property’s declaration. This approach offers a more intuitive and concise method to manage property access and mutation, enhancing code readability and maintainability.

The get Hook

The get hook is invoked when a property’s value is accessed. For instance, consider a Car class where we want to compute the car’s description dynamically:

class Car
{
    public string $description {
        get => $this->model . ' of ' . $this->year;
    }

    public function __construct(
        private string $model,
        private int $year
    ) {}
}

$car = new Car('Mercedes', 2015);
echo $car->description; // Outputs: Mercedes of 2015

class Car

{

public string $description {

get => $this->model . ' of ' . $this->year;

}

public function __construct(

private string $model,

private int $year

) {}

}

$car = new Car('Mercedes', 2015);

echo $car->description; // Outputs: Mercedes of 2015

In this example, accessing $car->description triggers the get hook, which concatenates the model and year properties.

The set Hook

The set hook is executed when a property’s value is assigned. For example, to ensure that a car’s model is always stored in uppercase:

class Car
{
    public string $model {
        set => $this->model = strtoupper($value);
    }
}

$car = new Car();
$user->model = 'mercedes';
echo $user->model; // Outputs: MERCEDES

class Car

{

public string $model {

set => $this->model = strtoupper($value);

}

$car = new Car();

$user->model = 'mercedes';

echo $user->model; // Outputs: MERCEDES

Here, assigning a value to $car->model invokes the set hook, which converts the input to uppercase before storing it.

Combining get and set Hooks

Property Hooks can be combined to manage both reading and writing operations. Consider a Car class where the age property is calculated based on the birthdate, and setting the age adjusts the birthdate accordingly:

class Car
{
    public int $age {
        get => (new DateTime())->diff($this->constructionDate)->y;
        set(int $years) => $this->constructionDate = (new DateTime())->sub(new DateInterval("P{$years}Y"));
    }

    private DateTime $constructionDate;

    public function __construct(DateTime $constructionDate)
    {
        $this->constructionDate = $constructionDate;
    }
}

$car = new Car(new DateTime('2000-01-01'));
echo $car->age; // Outputs: 25 (as of 2025)

$car->age = 30;
echo $car->age; // Outputs: 30

class Car

{

public int $age {

get => (new DateTime())->diff($this->constructionDate)->y;

set(int $years) => $this->constructionDate = (new DateTime())->sub(new DateInterval("P{$years}Y"));

}

private DateTime $constructionDate;

public function __construct(DateTime $constructionDate)

{

$this->constructionDate = $constructionDate;

}

$car = new Car(new DateTime('2000-01-01'));

echo $car->age; // Outputs: 25 (as of 2025)

$car->age = 30;

echo $car->age; // Outputs: 30

In this scenario, accessing $car->age calculates the age based on the constructionDate, while setting $car->age adjusts the constructionDate accordingly.

Best Practices

Type Consistency: Ensure that the types returned by get hooks and accepted by set hooks match the property’s declared type. PHP will attempt type coercion if strict types are not enabled, but it’s prudent to maintain type consistency to prevent unexpected behavior.

Avoid Overcomplication: While Property Hooks offer powerful capabilities, it’s essential to use them judiciously. Overusing hooks or embedding complex logic within them can lead to code that is difficult to understand and maintain.

Visibility Control: Leverage PHP 8.4’s asymmetric visibility feature to define properties that are publicly readable but privately writable, enhancing encapsulation.

Testing: Thoroughly test classes utilizing Property Hooks to ensure that the custom get and set behaviors function as intended, especially when dealing with edge cases.

UPDATE 04.03.25: This post exists now in video format on YouTube: https://youtu.be/xAHpl_QPq6k

PHP 8.4 Property Hooks - Real-World Insights -Cover — PHP 8.4 Property Hooks – Real-World Insights -Cover

Conclusion

Property Hooks in PHP 8.4 represent a significant advancement in the language’s object-oriented features, offering a more streamlined and expressive approach to property management. By adopting best practices and being mindful of potential pitfalls, developers can leverage this feature to write cleaner, more maintainable code.

I have softened my previous concerns, particularly regarding strong OOP advocates’ reservations about Property Hooks. The reduction in syntax and boilerplate is a huge benefit for writing cleaner, more efficient code. However, we must be cautious not to misuse this feature, as it could lead to confusion and reduce code readability—especially for junior developers. Striking a balance between conciseness and maintainability is key to using Property Hooks effectively.