Readonly Properties

Properties are a way to store data within an object. For instance, if we were creating a Car object, we might have properties like color, make, model, and so on. These are pieces of data that describe the car.

Now, some of this data should not be changed after the car is created. For example, the make of the car won't change after the car is manufactured. In PHP, we can make such properties "readonly". A "readonly" property is a property that can be set only once when the object is first created and cannot be changed afterwards.

This is useful because it helps prevent accidental modifications to these properties. For instance, if you accidentally tried to change the "make" of the car after it was created, PHP would give you an error message, saving you from a potentially costly mistake.

Defining readonly properties

A readonly property can be defined by adding the readonly keyword after a public access modifier. Here is an example:

class Car {
  public readonly string $make;
 
  public function __construct(string $make) {
    $this->make = $make;
  }
}

In this example, the $make property of the Car class is defined as "readonly". This means that once a Car object is created and its $make is set, it cannot be changed. Attempting to change it, as the last line of the code does, will cause an error.

Alternatively, we can use constructor property promotion like so:

class Car {
  public function __construct(public readonly string $make) {
  }
}

We can read from this property like any other property:

$myCar = new Car("Toyota");
echo $myCar->make;  // This will output "Toyota"

However, if attempt to access this property like in this example:

$myCar->make = "Honda";  // This will cause an error, as "make" is readonly

PHP throws a fatal error:

Fatal error: Uncaught Error: Cannot modify readonly property Car::$make

Using a method to initialize a property

Aside from initializing the property from its definition or construct method, you can define a method to set the property. This is assuming you haven't assigned a default value. Let's say you wanted to set the $make property's value at a later point.

It's perfectly fine to have a readonly property uninitialized. You can always define a custom method to perform this task.

class Car {
  public readonly string $make;
 
  public function setMake(string $make) {
    $this->make = $make;
  }
}

We can instantiate the class and call the method to set the property.

$car = new Car();
$car->setMake("Honda");

This works without a problem. However, if we were to attempt to call the setMake() method a second time, we'll be given an error. After the property has been given a value, PHP throws an error.

Typed properties

Unlike regular properties, you must always assign a type to a readonly property. If you don't, PHP will throw an error. Take the following:

class Car {
  public readonly $make;
}

PHP throws the following error:

Fatal error: Readonly property Car::$make must have type

Difference from constants

Both readonly properties and constants in PHP share the feature of immutability, meaning that their value cannot be changed once it's set. However, they are used in different contexts and have different scopes and lifecycles. Here are some of the key differences:

Constants

Constants are defined using the define() function or the const keyword. They are not defined in the context of a class but rather in the global scope of a PHP script.
Once a constant is defined, it cannot be undefined or have its value changed.
Constants can be accessed anywhere in your script without an instance of a class.
Constants are often used for values that are known before execution begins and remain the same throughout the script, like database connection details, API keys, mathematical constants, etc.