Konstruktor w PHP: __construct i promocja właściwości

Konstruktor w PHP to metoda o nazwie __construct(). PHP wywołuje ją automatycznie, gdy piszesz new ClassName(...), a argumenty w nawiasach stają się jej parametrami, więc obiekt od początku ma ustawione wartości.

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

Bez konstruktora tworzyłbyś pusty obiekt i ustawiał każdą właściwość później, a nic nie powstrzymałoby cię przed zapomnieniem którejś. Z konstruktorem new User() bez argumentów kończy się ArgumentCountError.

Promocja właściwości w konstruktorze

Zadeklarowanie właściwości, wymienienie jej jako parametru i przypisanie $this->name = $name powtarza każdą nazwę trzy razy. Od PHP 8.0 słowo kluczowe widoczności przed parametrem konstruktora robi wszystkie trzy rzeczy naraz:

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

Promowany parametr może być też readonly (public readonly string $id), co jest najkrótszym sposobem zapisania niezmiennego obiektu wartości. Możesz mieszać parametry promowane ze zwykłymi, a treść konstruktora nadal może zawierać kod, który wykona się po przypisaniu promowanych właściwości.

Wartości domyślne i argumenty nazwane

Parametry konstruktora przyjmują wartości domyślne jak w każdej funkcji. Parametry z wartościami domyślnymi idą po wymaganych. Z argumentami nazwanymi (PHP 8.0) wywołujący może przejść od razu do potrzebnej opcji, zamiast powtarzać każdą wcześniejszą wartość domyślną:

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

Uruchom: wynik zawiera HTML, więc zakładka Page pokazuje trzy wyrenderowane przyciski, a zakładka Output znaczniki wypisane przez PHP. Zwróć uwagę na nawiasy w (new Button('Save'))->render(): od PHP 8.4 są opcjonalne, ale PHP 8.3 ich wymaga.

Walidacja argumentów w konstruktorze

Konstruktor nie może zwrócić false ani kodu błędu: to, co zwraca, jest ignorowane. Aby odrzucić złe dane, rzuć wyjątek. Obiekt wtedy w ogóle nie powstaje, więc reszta programu może ufać każdemu otrzymanemu obiektowi Temperature.

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

Przechwytywanie takich wyjątków dokładniej opisuje strona try catch.

Kilka konstruktorów przez statyczne metody fabryczne

PHP nie ma przeciążania konstruktorów: jedna klasa, jeden __construct. Gdy obiekt można zbudować z różnych danych (stringa z datą, tablicy, znacznika czasu), dodaj nazwane metody statyczne, które przygotowują argumenty i wywołują new static(...). Prywatny konstruktor zmusza wszystkich do korzystania z fabryk.

<?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) spoza klasy rzuca teraz Error („Call to private Color::__construct() from global scope”). Strona o static wyjaśnia, dlaczego użyto tu new static, a nie new self.

Wywołanie konstruktora rodzica przez parent::__construct

Gdy klasa potomna definiuje własny konstruktor, konstruktor rodzica sam się nie wykona. Wywołaj go przez parent::__construct(...), zwykle na początku, żeby właściwości rodzica były ustawione, zanim potomek doda własne:

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

Jeśli potomek w ogóle nie ma konstruktora, PHP używa konstruktora rodzica, a new Truck('Volvo') przekazałoby argumenty prosto do Vehicle::__construct. Więcej na ten temat w dziedziczeniu.

Zapomniane parent::__construct

Ten błąd nie daje komunikatu w linii, w której powstaje. Konstruktor potomka się wykonuje, typowane właściwości rodzica pozostają niezainicjowane, a program pada później, tam, gdzie nastąpi pierwszy odczyt:

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

Dodaj parent::__construct(); jako pierwszą linię Post::__construct i uruchom ponownie: wypisze datę. Pokrewna metoda, __destruct(), wykonuje się, gdy znika ostatnie odwołanie do obiektu albo kończy się skrypt. W codziennym kodzie rzadko jest potrzebna, bo PHP samo zamyka pliki i zwalnia pamięć na koniec każdego żądania.