Déclarations des types

À partir de PHP 7.4.0, les définitions de propriétés peuvent inclure une Déclarations de type, avec l'exception du type callable.

<?php

class User
{
    public int $id;
    public ?string $name;

    public function __construct(int $id, ?string $name)
    {
        $this->id = $id;
        $this->name = $name;
    }
}

$user = new User(1234, null);

var_dump($user->id);
var_dump($user->name);

?>

int(1234)
NULL

Les propriétés typées doivent être initialisées avant d'y accéder, sinon, une Error sera émise.

<?php

class Shape
{
    public int $numberOfSides;
    public string $name;

    public function setNumberOfSides(int $numberOfSides): void
    {
        $this->numberOfSides = $numberOfSides;
    }

    public function setName(string $name): void
    {
        $this->name = $name;
    }

    public function getNumberOfSides(): int
    {
        return $this->numberOfSides;
    }

    public function getName(): string
    {
        return $this->name;
    }
}

$triangle = new Shape();
$triangle->setName("triangle");
$triangle->setNumberOfSides(3);
var_dump($triangle->getName());
var_dump($triangle->getNumberOfSides());

$circle = new Shape();
$circle->setName("circle");
var_dump($circle->getName());
var_dump($circle->getNumberOfSides());
?>

string(8) "triangle"
int(3)
string(6) "circle"

Fatal error: Uncaught Error: Typed property Shape::$numberOfSides must not be accessed before initialization

Propriétés en lecture seule (readonly)

À partir de PHP 8.1.0, une propriété peut être déclarée avec le modificateur readonly, qui empêche la modification de la propriété après l'initialisation. Avant PHP 8.4.0 une propriété readonly est implicitement privée-modifiable, et ne peut être écrite que depuis la même classe. À partir de PHP 8.4.0, les propriétés readonly sont implicitement protected(set), elles peuvent donc être définies depuis des classes enfants. Cela peut être remplacé explicitement si désiré.

<?php

class Test {
   public readonly string $prop;

   public function __construct(string $prop) {
       // Initialisation légale.
       $this->prop = $prop;
   }
}

$test = new Test("foobar");
// Lecture légale.
var_dump($test->prop); // string(6) "foobar"

// Réaffectation illégale. Peu importe que la valeur assignée soit identique.
$test->prop = "foobar";
// Erreur : Cannot modify readonly property Test::$prop
?>

Note:

Le modificateur de lecture seule ne peut être appliqué qu'aux propriétés typées. Une propriété en lecture seule sans contrainte de type peut être créée en utilisant le type Mixed.

Note:

Les propriétés statiques en lecture seule ne sont pas supportées.

Une propriété en lecture seule ne peut être initialisée qu'une seule fois, et seulement depuis la portée dans laquelle elle a été déclarée. Toute autre affectation ou modification de la propriété résultera en une exception Error.

<?php
class Test1 {
    public readonly string $prop;
}

$test1 = new Test1;
// Initialisation illégale en dehors de la portée privée.
$test1->prop = "foobar";
// Erreur : Cannot initialize readonly property Test1::$prop from global scope
?>

Note:

Les propriétés en lecture seule ne peuvent être initialisées que par une assignation directe. Une propriété en lecture seule non initialisée ne peut pas être initialisée par référence, même depuis la portée où elle a été déclarée : la passer à un paramètre de fonction qui attend une référence, ou l'assigner par référence, lève une exception Error.

<?php

class Test {
    public readonly array $matches;

    public function __construct(string $subject) {
        // Initialisation illégale par référence.
        preg_match('/\d+/', $subject, $this->matches);
        // Erreur : Cannot indirectly modify readonly property Test::$matches
    }
}

new Test('abc 42');
?>

Note:

Spécifier une valeur par défaut explicite à une propriété en lecture seule n'est pas autorisé, car une propriété en lecture seule avec une valeur par défaut est essentiellement identique à une constante, et par conséquent pas particulièrement utile.

<?php

class Test {
    // Erreur fatale : Readonly property Test::$prop cannot have default value
    public readonly int $prop = 42;
}
?>

Note:

Les propriétés en lecture seule ne peuvent pas être unset() une fois qu'elles ont été initialisées. Cependant, il est possible de unset une propriété en lecture seule avant son initialisation, depuis la portée où la propriété a été déclarée.

Les modifications ne sont pas nécessairement des affectations simples, tous les exemples suivants résulteront en une exception Error :

<?php

class Test {
    public function __construct(
        public readonly int $i = 0,
        public readonly array $ary = [],
    ) {}
}

$test = new Test;
$test->i += 1;
$test->i++;
++$test->i;
$test->ary[] = 1;
$test->ary[0][] = 1;
unset($test->ary[0]);
$ref =& $test->i;
$test->i =& $ref;
byRef($test->i);
foreach ($test as &$prop);
?>

Cependant, les propriétés en lecture seule n'excluent pas la mutabilité intérieure. Les objets (ou ressources) stockés dans les propriétés en lecture seule peuvent toujours être modifiés en interne :

<?php

class Test {
    public function __construct(public readonly object $obj) {}
}

$test = new Test(new stdClass);
// Mutation interne légale.
$test->obj->foo = 1;
// Réaffectation illégale.
$test->obj = new stdClass;
?>

À partir de PHP 8.3.0, les propriétés en lecture seule peuvent être réinitialisées lors du clonage d'un objet en utilisant la méthode __clone().

<?php
class Test1 {
    public readonly ?string $prop;

    public function __clone() {
        $this->prop = null;
    }

    public function setProp(string $prop): void {
        $this->prop = $prop;
    }
}

$test1 = new Test1;
$test1->setProp('foobar');

$test2 = clone $test1;
var_dump($test2->prop); // NULL
?>

Note:

À partir de PHP 8.4.0, la modification indirecte d'une propriété readonly au sein de __clone(), comme l'obtention d'une référence vers celle-ci ($ref = &$this->prop), n'est plus autorisée. Cela était déjà interdit lors de l'initialisation d'une propriété readonly.

Propriétés dynamiques

Lors d'une tentative d'assignation à une propriété non existante sur un objet, PHP créera automatiquement une propriété correspondante. Cette propriété créée dynamiquement sera uniquement disponible sur cette instance de classe.

Les propriétés dynamiques sont supportées par stdClass et ses classes filles. Les autres classes peuvent activer un comportement similaire avec AllowDynamicProperties ou la surcharge de propriétés.