Constructeur PHP : __construct et promotion de propriétés

Un constructeur PHP est une méthode nommée __construct(). PHP l'appelle automatiquement quand vous écrivez new ClassName(...), et les arguments entre les parenthèses deviennent ses paramètres, si bien que l'objet commence sa vie avec ses valeurs déjà définies.

<?php
class User
{
    public string $name;
    public int $age;

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

$ada = new User('Ada', 36);
echo "{$ada->name} is {$ada->age}\n";

Sans constructeur, vous créeriez un objet vide puis définiriez chaque propriété ensuite, et rien ne vous empêcherait d'en oublier une. Avec un constructeur, new User() sans arguments est une ArgumentCountError.

Promotion des propriétés dans le constructeur

Déclarer une propriété, la lister en paramètre et affecter $this->name = $name répète chaque nom trois fois. Depuis PHP 8.0, un mot-clé de visibilité devant un paramètre du constructeur fait les trois d'un coup :

<?php
class User
{
    public function __construct(
        public string $name,
        public int $age,
        private string $email = '',
    ) {}

    public function contact(): string
    {
        return $this->email !== '' ? $this->email : 'no email';
    }
}

$u = new User('Grace', 45, 'grace@example.com');
echo $u->name, ', ', $u->age, ', ', $u->contact(), "\n";

$v = new User('Linus', 28);
echo $v->name, ', ', $v->contact(), "\n";

Un paramètre promu peut aussi être readonly (public readonly string $id), la façon la plus courte d'écrire un objet valeur immuable. Vous pouvez mélanger paramètres promus et paramètres normaux, et le corps du constructeur peut toujours contenir du code qui s'exécute après l'affectation des propriétés promues.

Valeurs par défaut et arguments nommés

Les paramètres du constructeur acceptent des valeurs par défaut comme toute fonction. Les paramètres avec valeur par défaut se placent après les obligatoires. Avec les arguments nommés (PHP 8.0), l'appelant peut aller directement à l'option qu'il veut au lieu de répéter toutes les valeurs par défaut qui la précèdent :

<?php
class Button
{
    public function __construct(
        public string $label,
        public string $color = 'blue',
        public string $size = 'medium',
        public bool $disabled = false,
    ) {}

    public function render(): string
    {
        $attr = $this->disabled ? ' disabled' : '';
        return "<button class=\"{$this->color} {$this->size}\"{$attr}>{$this->label}</button>";
    }
}

echo (new Button('Save'))->render(), "\n";
echo (new Button('Delete', 'red'))->render(), "\n";
echo (new Button('Wait', disabled: true))->render(), "\n";

Exécutez-le : la sortie contient du HTML, donc l'onglet Page affiche les trois boutons rendus, et l'onglet Output les balises affichées par PHP. Remarquez les parenthèses dans (new Button('Save'))->render() : depuis PHP 8.4 elles sont facultatives, mais PHP 8.3 en a besoin.

Valider les arguments dans le constructeur

Un constructeur ne peut pas renvoyer false ni un code d'erreur : ce qu'il renvoie est ignoré. Pour refuser une entrée invalide, levez une exception. L'objet n'est alors jamais créé, donc le reste du programme peut se fier à chaque Temperature qu'il reçoit.

<?php
class Temperature
{
    public function __construct(public readonly float $celsius)
    {
        if ($celsius < -273.15) {
            throw new InvalidArgumentException("Below absolute zero: $celsius");
        }
    }

    public function fahrenheit(): float
    {
        return $this->celsius * 9 / 5 + 32;
    }
}

echo (new Temperature(21.5))->fahrenheit(), "\n";

try {
    $t = new Temperature(-300);
} catch (InvalidArgumentException $e) {
    echo 'Rejected: ', $e->getMessage(), "\n";
}

La page try catch explique plus en détail comment intercepter ces exceptions.

Plusieurs constructeurs avec des méthodes de fabrique statiques

PHP n'a pas de surcharge de constructeur : une classe, un __construct. Quand un objet peut être construit à partir d'entrées différentes (une date en chaîne, un tableau, un timestamp), ajoutez des méthodes statiques nommées qui préparent les arguments et appellent new static(...). Rendre le constructeur private oblige tout le monde à passer par les fabriques.

<?php
class Color
{
    private function __construct(
        public readonly int $r,
        public readonly int $g,
        public readonly int $b,
    ) {}

    public static function fromRgb(int $r, int $g, int $b): static
    {
        return new static($r, $g, $b);
    }

    public static function fromHex(string $hex): static
    {
        [$r, $g, $b] = sscanf(ltrim($hex, '#'), '%02x%02x%02x');
        return new static($r, $g, $b);
    }

    public function css(): string
    {
        return "rgb({$this->r}, {$this->g}, {$this->b})";
    }
}

echo Color::fromRgb(255, 128, 0)->css(), "\n";
echo Color::fromHex('#1e90ff')->css(), "\n";

new Color(1, 2, 3) depuis l'extérieur de la classe lève désormais une Error (« Call to private Color::__construct() from global scope »). La page static explique pourquoi on utilise ici new static plutôt que new self.

Appeler le constructeur parent avec parent::__construct

Quand une classe enfant définit son propre constructeur, celui du parent ne s'exécute pas tout seul. Appelez-le avec parent::__construct(...), en général en premier, pour que les propriétés du parent soient définies avant que l'enfant ajoute les siennes :

<?php
class Vehicle
{
    public function __construct(
        protected string $brand,
        protected int $wheels = 4,
    ) {}

    public function describe(): string
    {
        return "{$this->brand} with {$this->wheels} wheels";
    }
}

class Truck extends Vehicle
{
    public function __construct(string $brand, private int $capacityKg)
    {
        parent::__construct($brand, 6);
    }

    public function describe(): string
    {
        return parent::describe() . ", carries {$this->capacityKg} kg";
    }
}

echo (new Vehicle('Fiat'))->describe(), "\n";
echo (new Truck('Volvo', 18000))->describe(), "\n";

Si l'enfant n'a aucun constructeur, PHP utilise celui du parent, et new Truck('Volvo') passerait ses arguments directement à Vehicle::__construct. Plus de détails dans l'héritage.

Oublier parent::__construct

Cette erreur ne produit aucun message à la ligne où elle se produit. Le constructeur enfant s'exécute, les propriétés typées du parent restent non initialisées, et le programme échoue plus tard, là où a lieu la première lecture :

<?php
class Model
{
    protected array $attributes;

    public function __construct()
    {
        $this->attributes = ['created' => '2026-03-14'];
    }

    public function get(string $key): mixed
    {
        return array_key_exists($key, $this->attributes) ? $this->attributes[$key] : null;
    }
}

class Post extends Model
{
    public function __construct(public string $title)
    {
        // parent::__construct() is missing
    }
}

$post = new Post('Hello');
try {
    echo $post->get('created'), "\n";
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

Ajoutez parent::__construct(); en première ligne de Post::__construct et relancez : la date s'affiche. Une méthode voisine, __destruct(), s'exécute quand la dernière référence à un objet disparaît ou que le script se termine. On en a rarement besoin dans le code courant, car PHP ferme les fichiers et libère la mémoire tout seul à la fin de chaque requête.