בנאי ב-PHP: __construct וקידום מאפיינים

בנאי ב-PHP הוא מתודה בשם __construct(). PHP קוראת לה אוטומטית כשכותבים new ClassName(...), והארגומנטים שבסוגריים הופכים לפרמטרים שלה, כך שהאובייקט מתחיל את חייו כשהערכים שלו כבר מוגדרים.

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

בלי בנאי הייתם יוצרים אובייקט ריק ומגדירים כל מאפיין אחר כך, ושום דבר לא היה מונע מכם לשכוח אחד. עם בנאי, new User() בלי ארגומנטים הוא ArgumentCountError.

קידום מאפיינים בבנאי

הצהרה על מאפיין, רישום שלו כפרמטר והצבה של $this->name = $name חוזרות על כל שם שלוש פעמים. מאז PHP 8.0, מילת מפתח של רמת גישה לפני פרמטר בבנאי עושה את שלושתן בבת אחת:

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

פרמטר מקודם יכול להיות גם readonly (public readonly string $id), וזו הדרך הקצרה ביותר לכתוב אובייקט ערך שאינו ניתן לשינוי. אפשר לערבב פרמטרים מקודמים ורגילים, וגוף הבנאי עדיין יכול להכיל קוד שרץ אחרי שהמאפיינים המקודמים הוצבו.

ערכי ברירת מחדל וארגומנטים בשם

פרמטרים של בנאי מקבלים ברירות מחדל כמו כל פונקציה. פרמטרים עם ברירות מחדל באים אחרי פרמטרי החובה. עם ארגומנטים בשם (PHP 8.0) הקורא יכול לדלג ישר לאפשרות שהוא רוצה במקום לחזור על כל ברירת מחדל שלפניה:

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

הריצו את זה: הפלט מכיל HTML, ולכן הלשונית Page מציגה את שלושת הכפתורים, והלשונית Output מציגה את התגיות ש-PHP הדפיסה. שימו לב לסוגריים ב-(new Button('Save'))->render(): מאז PHP 8.4 הם אופציונליים, אבל PHP 8.3 צריכה אותם.

אימות ארגומנטים בבנאי

בנאי לא יכול להחזיר false או קוד שגיאה: מה שהוא מחזיר נזרק. כדי לסרב לקלט לא תקין, זרקו חריגה. האובייקט אז לא נוצר לעולם, ולכן שאר התוכנית יכולה לסמוך על כל 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";
}

העמוד try catch מסביר בפירוט רב יותר איך תופסים את החריגות האלה.

כמה בנאים עם מתודות factory סטטיות

אין ב-PHP העמסת בנאים: מחלקה אחת, __construct אחד. כשאפשר לבנות אובייקט מקלטים שונים (מחרוזת תאריך, מערך, חותמת זמן), הוסיפו מתודות סטטיות עם שם שמכינות את הארגומנטים וקוראות ל-new static(...). הפיכת הבנאי ל-private מכריחה את כולם לעבור דרך ה-factories.

<?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) מחוץ למחלקה זורק עכשיו Error ("Call to private Color::__construct() from global scope"). העמוד static מסביר למה משתמשים כאן ב-new static ולא ב-new self.

קריאה לבנאי של האב עם parent::__construct

כשמחלקת בת מגדירה בנאי משלה, הבנאי של האב לא רץ מעצמו. קראו לו עם parent::__construct(...), בדרך כלל ראשון, כדי שהמאפיינים של האב יוגדרו לפני שהבת מוסיפה את שלה:

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

אם לבת אין בנאי בכלל, PHP משתמשת בזה של האב, ו-new Truck('Volvo') הייתה מעבירה את הארגומנטים שלה ישירות ל-Vehicle::__construct. עוד על כך בירושה.

שכחת parent::__construct

הטעות הזו לא מפיקה שגיאה בשורה שבה היא קורית. בנאי הבת רץ, המאפיינים עם הטיפוס של האב נשארים לא מאותחלים, והתוכנית נכשלת מאוחר יותר, בכל מקום שבו קורית הקריאה הראשונה:

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

הוסיפו parent::__construct(); כשורה הראשונה של Post::__construct והריצו שוב: זה מדפיס את התאריך. מתודה קשורה, __destruct(), רצה כשההפניה האחרונה לאובייקט נעלמת או כשהסקריפט מסתיים. בקוד יומיומי צריך אותה לעיתים רחוקות, כי PHP סוגרת קבצים ומשחררת זיכרון בעצמה בסוף כל בקשה.