Costruttore in PHP: __construct e promozione delle proprietà

Un costruttore PHP è un metodo chiamato __construct(). PHP lo chiama automaticamente quando scrivi new ClassName(...), e gli argomenti tra le parentesi diventano i suoi parametri, così l'oggetto nasce con i suoi valori già impostati.

<?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";

Senza un costruttore creeresti un oggetto vuoto e imposteresti ogni proprietà dopo, e nulla ti impedirebbe di dimenticarne una. Con un costruttore, new User() senza argomenti è un ArgumentCountError.

Promozione delle proprietà nel costruttore

Dichiarare una proprietà, elencarla come parametro e assegnare $this->name = $name ripete ogni nome tre volte. Da PHP 8.0, una parola chiave di visibilità davanti a un parametro del costruttore fa tutte e tre le cose insieme:

<?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 parametro promosso può anche essere readonly (public readonly string $id), il modo più breve di scrivere un oggetto valore immutabile. Puoi mescolare parametri promossi e normali, e il corpo del costruttore può comunque contenere codice eseguito dopo l'assegnazione delle proprietà promosse.

Valori di default e argomenti con nome

I parametri del costruttore accettano default come qualsiasi funzione. I parametri con default vanno dopo quelli obbligatori. Con gli argomenti con nome (PHP 8.0) chi chiama può saltare direttamente all'opzione che vuole invece di ripetere tutti i default che la precedono:

<?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";

Eseguilo: l'output contiene HTML, quindi la scheda Page mostra i tre pulsanti, e la scheda Output mostra i tag stampati da PHP. Nota le parentesi in (new Button('Save'))->render(): da PHP 8.4 sono facoltative, ma PHP 8.3 le richiede.

Validare gli argomenti nel costruttore

Un costruttore non può restituire false o un codice di errore: ciò che restituisce viene ignorato. Per rifiutare un input non valido, lancia un'eccezione. L'oggetto allora non viene mai creato, quindi il resto del programma può fidarsi di ogni Temperature che riceve.

<?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 pagina su try catch spiega più in dettaglio come catturare queste eccezioni.

Più costruttori con metodi factory statici

PHP non ha l'overloading del costruttore: una classe, un __construct. Quando un oggetto si può costruire da input diversi (una stringa di data, un array, un timestamp), aggiungi metodi statici con un nome che preparano gli argomenti e chiamano new static(...). Rendere private il costruttore obbliga tutti a passare per le factory.

<?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) dall'esterno della classe ora lancia un Error ("Call to private Color::__construct() from global scope"). La pagina su static spiega perché qui si usa new static invece di new self.

Chiamare il costruttore padre con parent::__construct

Quando una classe figlia definisce il proprio costruttore, quello del padre non viene eseguito da solo. Chiamalo con parent::__construct(...), di solito per primo, così le proprietà del padre vengono impostate prima che la figlia aggiunga le sue:

<?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";

Se la figlia non ha alcun costruttore, PHP usa quello del padre, e new Truck('Volvo') passerebbe i suoi argomenti direttamente a Vehicle::__construct. Altro su questo in ereditarietà.

Dimenticare parent::__construct

Questo errore non produce alcun errore nella riga in cui avviene. Il costruttore figlio viene eseguito, le proprietà tipizzate del padre restano non inizializzate, e il programma fallisce più tardi, dove avviene la prima lettura:

<?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";
}

Aggiungi parent::__construct(); come prima riga di Post::__construct ed eseguilo di nuovo: stampa la data. Un metodo collegato, __destruct(), viene eseguito quando sparisce l'ultimo riferimento a un oggetto o quando lo script termina. Nel codice di tutti i giorni serve raramente, perché PHP chiude i file e libera la memoria da solo alla fine di ogni richiesta.