PHP 8.1 introduces read-only attributes to declare class attributes that cannot be changed after initialization. Developers can initialize read-only attributes when constructors or declarations, and cannot be modified afterwards. This applies to scenarios where data integrity is required, such as entities, DTOs, and configuration values. Note when using: read-only attributes cannot be assigned outside the constructor, cannot be used with var or non-access modifiers, and only prevent reassignment of arrays or objects, and do not prevent internal state changes. Not suitable for scenarios where frequent updates of attributes or performance-sensitive scenarios are required. Common usages include: 1) Entity ID in the domain-driven design; 2) Data transmission objects that are responding to by API; 3) Configuration items that should not be changed after loading. Limitations include: 1) No reassignment after construction; 2) No var keyword is supported; 3) No object or array content changes.

In PHP 8.1, readonly properties are a new feature that allows developers to declare class properties that cannot be modified after being initialized. This means once you set the value of a readonly property during object creation or within the constructor, it remains fixed and cannot be changed later in the code.

This is especially useful when working with value objects or entities where immutability is desired — for example, mapping database records or API responses where fields like IDs or timestamps shouldn't change after being set.

How to Declare Readonly Properties

To declare a readonly property, you simply add the readonly modifier before the property declaration in a class:

 class User {
    public function __construct(
        private readonly string $id,
        private readonly string $name
    ) {}
}

You can also declare them individually inside the class body if you're not using the constructor promotion syntax:

 class Product {
    public readonly string $sku;

    public function __construct(string $sku) {
        $this->sku = $sku;
    }
}

A few key things to know:

• Readonly properties must be initialized either in the declaration or in the constructor.
• You can read them from anywhere (inside or outside the class), but you can't write to them once set.
• They can be used with any visibility: public , protected , or private .

Common Use Cases

Readonly properties are ideal for scenarios where data integrity is important. Here are a few practical examples:

• Entities in domain-driven design : For example, an Order entity might have a readonly orderId to ensure it doesn't accidentally change during processing.
• Data transfer objects (DTOs) : These often represented structured data coming from APIs or databases, where fields should stay constant after parsing.
• Configuration values ??: Once loaded from a config file, certain settings might need to remain unchanged throughout the application lifecycle.

These use cases benefit from the clarity and safety that readonly properties provide.

Limitations and Things to Watch Out For

While readonly properties are powerful, there are a few limitations and gotchas to keep in mind:

• You cannot reassign the property anywhere after construction — not even inside the class methods.
• You can't use readonly on properties declared with var or without visibility keywords.
• It only applies to simple variables — if the property is an object or array, its internal state can still change unless you deeply protect it manually.

For example:

 class Example {
    public function __construct(
        public readonly array $data
    ) {}
}

$ex = new Example(['tags' => ['a', 'b']]);
$ex->data['tags'][] = 'c'; // This is allowed!

So while $data itself can't be replaced, its contents can still be modified.

When Not to Use Them

Although readonly properties help enforce immutability, they aren't always the right choice:

• If your class needs to update certain properties during its lifecycle (like status flags or counters), readonly won't work.
• In performance-sensitive contexts where you're instantiating many objects and want flexibility in updating properties without creating new instances.

In these cases, standard mutable properties are better suited.

So yeah, readonly properties in PHP 8.1 gives you a clean way to define immutable class members — great for data models where consistency matters. Just remember to use them where appropriate, and watch out for their limitations.

The above is the detailed content of What is readonly properties in PHP 8.1?. For more information, please follow other related articles on the PHP Chinese website!