Readonly classes in PHP - Deep Dive

Overview - Readonly classes

What is it?

Readonly classes in PHP are classes where all properties are automatically readonly, meaning their values can only be set once and cannot be changed afterward. This feature helps create objects that are immutable, ensuring their state stays constant after creation. It simplifies writing safer code by preventing accidental changes to object data. Readonly classes were introduced to make immutability easier and clearer in PHP code.

Why it matters

Without readonly classes, developers must manually declare each property as readonly or write extra code to prevent changes, which can be error-prone and verbose. Readonly classes solve this by making the entire class immutable by default, reducing bugs caused by unexpected data changes. This is especially important in large applications where data consistency and predictability are critical. Without this, programs might behave unpredictably or have hidden bugs due to changing object states.

Where it fits

Before learning readonly classes, you should understand basic PHP classes, properties, and the readonly property feature introduced in PHP 8.1. After mastering readonly classes, you can explore advanced immutability patterns, value objects, and functional programming concepts in PHP.

Mental Model

Core Idea

A readonly class is like a sealed box where you can put items only once, and then the box cannot be opened or changed.

Think of it like...

Imagine writing a letter and sealing it in an envelope. Once sealed, you cannot change the letter inside. A readonly class works the same way: once you set the data, it stays fixed and cannot be altered.

┌─────────────────────────────┐
│        Readonly Class       │
│ ┌───────────────┐           │
│ │ Property 1    │───┐       │
│ │ (set once)    │   │       │
│ └───────────────┘   │       │
│ ┌───────────────┐   │       │
│ │ Property 2    │───┼───> Immutable Object
│ │ (set once)    │   │       │
│ └───────────────┘   │       │
│ ┌───────────────┐   │       │
│ │ Property 3    │───┘       │
│ │ (set once)    │           │
│ └───────────────┘           │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding PHP Classes and Properties

Concept: Learn what classes and properties are in PHP and how they store data.

In PHP, a class is like a blueprint for creating objects. Properties are variables inside a class that hold data. For example: class Person { public string $name; public int $age; } You can create a Person object and set its properties: $person = new Person(); $person->name = 'Alice'; $person->age = 30;

Result

You can create objects with properties that hold data you can read and change.

Understanding classes and properties is essential because readonly classes build on these concepts by restricting how properties can be changed.

2

Foundation

Introducing Readonly Properties in PHP

Concept: Learn how to make individual properties readonly so they can only be set once.

PHP 8.1 introduced readonly properties. When a property is readonly, you can set it only once, usually in the constructor. After that, trying to change it causes an error. Example: class User { public readonly string $email; public function __construct(string $email) { $this->email = $email; } } $user = new User('[e-mail]'); // $user->email = '[e-mail]'; // This will cause an error!

Result

Properties marked readonly cannot be changed after initial assignment.

Readonly properties help create safer objects by preventing accidental changes to important data.

3

Intermediate

What Are Readonly Classes in PHP?

Concept: Learn that readonly classes automatically make all properties readonly without declaring each one.

PHP 8.2 introduced readonly classes. When you declare a class as readonly, all its properties become readonly by default. Example: readonly class Point { public int $x; public int $y; public function __construct(int $x, int $y) { $this->x = $x; $this->y = $y; } } $point = new Point(10, 20); // $point->x = 30; // Error: Cannot modify readonly property

Result

All properties in a readonly class are immutable after construction.

Readonly classes simplify immutability by removing the need to mark each property readonly individually.

4

Intermediate

Using Readonly Classes for Immutable Data Objects

Concept: Understand how readonly classes help create objects whose data never changes, improving reliability.

Immutable objects are useful when you want to ensure data stays consistent. Readonly classes make this easy: readonly class Config { public string $host; public int $port; public function __construct(string $host, int $port) { $this->host = $host; $this->port = $port; } } $config = new Config('localhost', 8080); // Trying to change $config->host later will cause an error.

Result

Immutable objects prevent bugs caused by unexpected data changes.

Using readonly classes for immutable data helps maintain predictable program behavior.

5

Intermediate

Readonly Classes and Inheritance Rules

Concept: Learn how readonly classes behave with inheritance and property overrides.

When a class is declared readonly, all its properties are readonly. If you extend a readonly class, the child class is also readonly automatically. Example: readonly class Base { public int $id; public function __construct(int $id) { $this->id = $id; } } // This class is also readonly class Child extends Base { public string $name; public function __construct(int $id, string $name) { parent::__construct($id); $this->name = $name; } } $child = new Child(1, 'Test'); // $child->name = 'New'; // Error: readonly property

Result

Readonly behavior is inherited, ensuring immutability across class hierarchies.

Understanding inheritance rules prevents accidental mutable subclasses breaking immutability.

6

Advanced

Readonly Classes with Mutable Properties Exception

🤔Before reading on: do you think readonly classes allow any mutable properties inside them? Commit to yes or no.

Concept: Explore how readonly classes can contain properties typed as mutable objects, which can still change internally.

Readonly classes make their properties readonly, but if a property holds an object, the object itself can still be changed unless it is also immutable. Example: readonly class Wrapper { public DateTime $date; public function __construct(DateTime $date) { $this->date = $date; } } $wrapper = new Wrapper(new DateTime()); $wrapper->date->modify('+1 day'); // This works because DateTime is mutable // The property $date cannot be reassigned, but the object it points to can change.

Result

Readonly classes do not guarantee deep immutability unless contained objects are also immutable.

Knowing this prevents false assumptions about immutability and helps design truly immutable data structures.

7

Expert

Performance and Memory Implications of Readonly Classes

🤔Before reading on: do you think readonly classes improve, worsen, or have no effect on PHP performance? Commit to your answer.

Concept: Understand how readonly classes affect PHP's memory usage and performance at runtime.

Readonly classes can improve performance by enabling PHP to optimize memory usage since objects do not change after creation. This can reduce copying and improve cache efficiency. However, the actual impact depends on the PHP engine and usage patterns. Also, readonly classes help developers avoid defensive copying in code, which can improve overall efficiency. But if mutable objects are stored inside readonly classes, the benefits may be limited.

Result

Readonly classes can lead to more efficient and predictable code but are not a silver bullet for performance.

Understanding performance tradeoffs helps experts decide when to use readonly classes for optimization.

Under the Hood

Readonly classes work by marking all properties internally with a readonly flag during object construction. PHP's engine enforces that after the constructor finishes, any attempt to modify these properties throws an error. This enforcement happens at runtime by checking property access and assignment operations. The readonly flag is stored in the object's metadata, and the engine uses it to prevent writes after initialization.

Why designed this way?

Readonly classes were designed to simplify immutability by avoiding repetitive readonly declarations on each property. Before this, developers had to mark each property readonly manually, which was error-prone and verbose. The design balances ease of use with PHP's dynamic nature, enforcing immutability at runtime rather than compile-time, fitting PHP's interpreted model.

┌───────────────────────────────┐
│       PHP Engine Runtime       │
│ ┌───────────────────────────┐ │
│ │ Object Metadata           │ │
│ │ ┌───────────────────────┐ │ │
│ │ │ Property Flags         │ │ │
│ │ │ ┌───────────────────┐ │ │ │
│ │ │ │ readonly = true   │ │ │ │
│ │ │ └───────────────────┘ │ │ │
│ │ └───────────────────────┘ │ │
│ └───────────────────────────┘ │
│                               │
│ Property Assignment Attempt → │
│ ┌───────────────────────────┐ │
│ │ Check readonly flag       │ │
│ │ If true and after __construct │
│ │ → Throw Error             │ │
│ └───────────────────────────┘ │
└───────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does declaring a class readonly make the objects deeply immutable? Commit to yes or no.

Common Belief: Readonly classes make objects completely immutable, including all nested objects.

Reality: Readonly classes only make the properties themselves readonly; if a property holds a mutable object, that object can still be changed.

Why it matters: Assuming deep immutability can lead to bugs when nested objects are modified unexpectedly, breaking data consistency.

Quick: Can you change a readonly property inside the constructor after setting it once? Commit to yes or no.

Common Belief: Readonly properties can be changed multiple times inside the constructor.

Reality: Readonly properties can only be assigned once, even inside the constructor. Trying to assign again causes an error.

Why it matters: Misunderstanding this can cause runtime errors and confusion during object initialization.

Quick: Does extending a readonly class allow the child class to have writable properties? Commit to yes or no.

Common Belief: Child classes of readonly classes can have writable properties.

Reality: Child classes of readonly classes are also readonly; all their properties are readonly by default.

Why it matters: Incorrect assumptions about inheritance can lead to mutable subclasses, breaking immutability guarantees.

Quick: Does using readonly classes always improve performance? Commit to yes or no.

Common Belief: Readonly classes always make PHP code run faster.

Reality: Readonly classes can improve performance in some cases but do not guarantee faster code universally.

Why it matters: Expecting automatic performance gains may lead to ignoring other optimization needs.

Expert Zone

1

Readonly classes enforce immutability only at the property level, not deep immutability; developers must ensure contained objects are immutable for full effect.

2

Readonly classes interact with PHP's serialization and cloning mechanisms in subtle ways that can affect object state and require careful handling.

3

Readonly classes can simplify thread-safe programming patterns by guaranteeing object state does not change, which is valuable in concurrent environments.

When NOT to use

Readonly classes are not suitable when objects need to change state after creation, such as entities in ORM systems or UI components with dynamic behavior. In such cases, use mutable classes with controlled setters or state management patterns instead.

Production Patterns

In production, readonly classes are often used for value objects, configuration data, and DTOs (Data Transfer Objects) where immutability improves reliability. They are combined with immutable collections and functional programming techniques to build robust systems.

Connections

Immutable Data Structures

Readonly classes implement immutability at the object level, which is a core idea in immutable data structures.

Understanding readonly classes helps grasp how immutability can be enforced in programming languages, improving data safety and predictability.

Functional Programming

Readonly classes support functional programming principles by enabling immutable state and pure functions.

Knowing readonly classes aids in adopting functional programming styles in PHP, leading to fewer side effects and easier debugging.

Legal Contracts

Readonly classes are like legal contracts that once signed cannot be changed, ensuring agreed terms remain fixed.

This cross-domain connection shows how immutability in code mirrors real-world agreements, emphasizing trust and consistency.

Common Pitfalls

#1 Trying to modify a readonly property after object creation.

Wrong approach:

$obj->property = 'new value'; // Error: Cannot modify readonly property

Correct approach:

Set the property only once in the constructor and avoid changing it later.

Root cause:

Misunderstanding that readonly means 'set once' and expecting to change properties anytime.

#2 Assuming nested objects inside readonly classes are also immutable.

Wrong approach:

$obj->nestedObject->changeState(); // Allowed, but breaks immutability assumption

Correct approach:

Use immutable objects for nested properties or clone before modification.

Root cause:

Confusing property immutability with deep object immutability.

#3 Declaring a class readonly but then trying to add writable properties in a subclass.

Wrong approach:

class Child extends readonly Parent { public string $name; } // Error or unexpected behavior

Correct approach:

Declare subclass as readonly or avoid adding writable properties.

Root cause:

Not understanding inheritance rules for readonly classes.

Key Takeaways

Readonly classes in PHP make all properties readonly by default, ensuring objects are immutable after creation.

This immutability helps prevent bugs caused by unexpected changes to object state, improving code safety and predictability.

Readonly classes do not guarantee deep immutability; contained objects can still be mutable unless designed otherwise.

Inheritance of readonly classes enforces immutability across subclasses, maintaining consistent behavior.

Using readonly classes wisely can improve code reliability and align with functional programming principles.