Constructor PHP: __construct dan Property Promotion

Constructor PHP adalah method bernama __construct(). PHP memanggilnya secara otomatis saat kamu menulis new ClassName(...), dan argumen di dalam tanda kurung menjadi parameternya, jadi objek itu langsung lahir dengan nilai yang sudah terisi.

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

Tanpa constructor, kamu akan membuat objek kosong lalu mengisi setiap property sesudahnya, dan tidak ada yang mencegahmu lupa mengisi salah satunya. Dengan constructor, new User() tanpa argumen menghasilkan ArgumentCountError.

Constructor property promotion

Mendeklarasikan property, menuliskannya sebagai parameter, lalu mengisi $this->name = $name berarti mengulang setiap nama tiga kali. Sejak PHP 8.0, kata kunci visibilitas di depan parameter constructor melakukan ketiganya sekaligus:

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

Parameter yang di-promote juga bisa readonly (public readonly string $id), yang merupakan cara terpendek untuk menulis value object yang tidak bisa diubah. Kamu boleh mencampur parameter yang di-promote dengan parameter biasa, dan body constructor tetap bisa berisi kode yang berjalan setelah property hasil promotion terisi.

Nilai bawaan dan named argument

Parameter constructor bisa punya nilai bawaan seperti fungsi lainnya. Parameter dengan nilai bawaan ditulis setelah parameter yang wajib. Dengan named argument (PHP 8.0), pemanggil bisa langsung menuju opsi yang diinginkannya tanpa mengulang setiap nilai bawaan sebelumnya:

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

Jalankan: output-nya berisi HTML, jadi tab Halaman menampilkan ketiga tombol itu, dan tab Output menampilkan tag yang dicetak PHP. Perhatikan tanda kurung di (new Button('Save'))->render(): sejak PHP 8.4 tanda kurung itu opsional, tetapi PHP 8.3 membutuhkannya.

Memvalidasi argumen di constructor

Constructor tidak bisa mengembalikan false atau kode error: apa pun yang dikembalikannya diabaikan. Untuk menolak input yang salah, lempar exception. Objeknya lalu tidak pernah dibuat, sehingga bagian program lainnya bisa memercayai setiap Temperature yang diterimanya.

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

Halaman try catch membahas cara menangkap exception seperti ini secara lebih rinci.

Beberapa constructor dengan static factory method

PHP tidak punya constructor overloading: satu class, satu __construct. Saat sebuah objek bisa dibuat dari input yang berbeda-beda (string tanggal, array, timestamp), tambahkan static method bernama yang menyiapkan argumennya lalu memanggil new static(...). Menjadikan constructor private memaksa semua orang lewat factory tersebut.

<?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) dari luar class sekarang melempar Error ("Call to private Color::__construct() from global scope"). Halaman static menjelaskan kenapa di sini dipakai new static, bukan new self.

Memanggil constructor parent dengan parent::__construct

Saat class turunan mendefinisikan constructor sendiri, constructor milik parent tidak berjalan dengan sendirinya. Panggil dengan parent::__construct(...), biasanya di awal, supaya property milik parent sudah terisi sebelum class turunan menambahkan miliknya sendiri:

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

Kalau class turunan sama sekali tidak punya constructor, PHP memakai milik parent, dan new Truck('Volvo') akan meneruskan argumennya langsung ke Vehicle::__construct. Selengkapnya ada di inheritance.

Lupa memanggil parent::__construct

Kesalahan ini tidak menghasilkan error di baris tempat kesalahannya terjadi. Constructor class turunan berjalan, property bertipe milik parent tetap belum diinisialisasi, dan program gagal belakangan, di mana pun property itu pertama kali dibaca:

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

Tambahkan parent::__construct(); sebagai baris pertama Post::__construct, lalu jalankan lagi: tanggalnya tercetak. Method yang berkaitan, __destruct(), berjalan saat referensi terakhir ke sebuah objek hilang atau saat script selesai. Method ini jarang dibutuhkan di kode sehari-hari, karena PHP menutup file dan membebaskan memori sendiri di akhir setiap request.