You can do it like this:

class Example {
    private $__readOnly = 'hello world';
    function __get($name) {
        if($name === 'readOnly')
            return $this->__readOnly;
        user_error("Invalid property: " . __CLASS__ . "->$name");
    }
    function __set($name, $value) {
        user_error("Can't set property: " . __CLASS__ . "->$name");
    }
}

Only use this when you really need it - it is slower than normal property access. For PHP, it's best to adopt a policy of only using setter methods to change a property from the outside.

One advantage of the "old" way is that you can choose different access levels for the getter and setter, whereas a readonly field has only a single access level. E.g. when you want your setter to be protected.

Another advantage of using getters is that it allows you to change the implementation without changing the class interface.

Furthermore readonly properties as the name suggests can be set only once very much like JavaScript const variables. Depending on context this might be a desirable or a bad thing. Certain properties should be only set once and attempts to set them again should be flagged.

Although being "syntax candy" public readonly properties do have their merit.

readonly properties allow you to create immutable objects, or at the very least immutable properties (since 8.2 we also have readonly for classes, which allow creating immutable objects without having to apply the keyword to each of the class properties).

That way, you can be sure that a value won't be changed by accident after being initialized, throughout the object's life.

It's a very similar concept to constants (set via const or define), albeit with two important differences:

• constants need to be defined on "compilation" time, whereas readonly properties will be set during runtime, usually during on object instantiation (so multiple instances will be able to hold different values*)
• constants live in the global scope; and in case of class constants, their value is tied to the class and not to the instance.

You could achieve the same with a private property only accessible via a getter. E.g., in "the olden days":

class Foo {

    private DateTimeImmutable $createAt;

    public function __construct() {
        $this->createdAt = new DateTimeImmutable();
    }

    public function getCreatedAt(): DateTimeImmutable
    {
        return $this->createdAt;
    }
}

$f = new Foo();
echo $f->getCreatedAt()->format('Y-m-d H:i:s');

The only problem with this is that it requires a lot of boilerplate code.

With PHP 8.1, almost the same could be achieved by doing:

class Foo
{

    public function __construct(
        public readonly DateTimeImmutable $createdAt = new DateTimeImmutable()
    )
    { }

}

$f = new Foo();
echo $f->createdAt->format('Y-m-d H:i:s')

And since PHP 8.2 add readonly classes, it gets even better, since one can do:

readonly class Foo
{

    public function __construct(
        public string $name,
        public DateTimeImmutable $createdAt = new DateTimeImmutable()
    )
    { }

}

And now both Foo::name and Foo::createdAt are readonly, and can only be set during object instantiation.