מחלקות ואובייקטים ב-PHP: מאפיינים, מתודות ו-$this

מחלקה ב-PHP מוצהרת עם class Name { ... } ומחזיקה מאפיינים (משתנים) ומתודות (פונקציות). new Name() יוצר ממנה אובייקט, ו--> קורא מאפיין או קורא למתודה: $user->name, $user->greet().

<?php
class User
{
    public string $name = 'Guest';

    public function greet(): string
    {
        return "Hello, {$this->name}";
    }
}

$user = new User();
echo $user->greet(), "\n";

$user->name = 'Ada';
echo $user->greet(), "\n";

המחלקה היא התבנית, האובייקט הוא דבר אחד שנבנה ממנה. אפשר ליצור ממחלקה אחת כמה אובייקטים שצריך, ולכל אחד יש ערכי מאפיינים משלו.

מאפיינים ומתודות

מאפיין מוצהר עם מילת מפתח של רמת גישה, טיפוס אופציונלי וערך ברירת מחדל אופציונלי. מתודה היא פונקציה בתוך המחלקה. בתוך מתודה, $this הוא האובייקט שעליו נקראה המתודה, ולכן $this->balance קורא את היתרה של האובייקט הזה.

<?php
class Account
{
    public string $owner = '';
    public float $balance = 0;

    public function deposit(float $amount): void
    {
        $this->balance += $amount;
    }

    public function summary(): string
    {
        return sprintf('%s has %.2f', $this->owner, $this->balance);
    }
}

$a = new Account();
$a->owner = 'Ada';
$a->deposit(50);
$a->deposit(25.5);

$b = new Account();
$b->owner = 'Linus';
$b->deposit(10);

echo $a->summary(), "\n";
echo $b->summary(), "\n";

כל אובייקט שומר $balance משלו: הפקדה ל-$a לא נוגעת ב-$b. הגדרה של מאפיינים אחד אחד אחרי new נעשית מייגעת; בנאי מקבל במקום זאת את ערכי ההתחלה כארגומנטים.

public, private ו-protected

רמת הגישה קובעת מי יכול לגעת במאפיין או לקרוא למתודה:

הפיכת מאפיין ל-private וחשיפת מתודות היא הדרך שבה מחלקה מגינה על הכללים שלה. כאן היתרה יכולה להשתנות רק דרך deposit() ו-withdraw(), שמסרבות לסכומים לא תקינים:

<?php
class Wallet
{
    private int $cents = 0;

    public function deposit(int $cents): void
    {
        if ($cents <= 0) {
            throw new InvalidArgumentException('Deposit must be positive');
        }
        $this->cents += $cents;
    }

    public function withdraw(int $cents): bool
    {
        if ($cents > $this->cents) {
            return false;
        }
        $this->cents -= $cents;
        return true;
    }

    public function balance(): int
    {
        return $this->cents;
    }
}

$w = new Wallet();
$w->deposit(500);
var_dump($w->withdraw(800));
var_dump($w->withdraw(200));
echo $w->balance(), "\n";

קריאה של המאפיין הפרטי מחוץ למחלקה היא לא אזהרה, היא Error:

<?php
// This throws an Error on purpose: $cents is private
class Wallet
{
    private int $cents = 500;
}

$w = new Wallet();
echo $w->cents;

מאפיינים עם טיפוס וערכים לא מאותחלים

מאפיין עם טיפוס בלי ערך ברירת מחדל מתחיל לא מאותחל, וזה שונה מ-null. קריאה שלו לפני שמשהו הוצב בו זורקת Error. או שתתנו לו ברירת מחדל, או שתציבו אותו בבנאי, או שתהפכו אותו ל-nullable עם ?Type ו-= null.

<?php
class Product
{
    public string $name;           // no default: uninitialized
    public ?string $sku = null;    // nullable with a default
    public int $stock = 0;
}

$p = new Product();
var_dump($p->sku, $p->stock);

try {
    echo $p->name;
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

$p->name = 'Keyboard';
echo $p->name, "\n";

הטיפוסים נאכפים בהצבה. במצב ברירת המחדל (לא מחמיר), $p->stock = '7' ממיר את המחרוזת המספרית ל-7, בעוד $p->stock = 'many' זורק TypeError.

מאפייני readonly

מאפיין readonly (PHP 8.1) אפשר לכתוב פעם אחת, מתוך המחלקה, ואז אף פעם לא שוב. זו הדרך הרגילה לבנות אובייקטי ערך כמו סכומי כסף או מזהים. PHP 8.2 הוסיפה את readonly class, שהופכת כל מאפיין ל-readonly.

<?php
class Order
{
    public readonly string $id;

    public function __construct(string $id)
    {
        $this->id = $id;
    }
}

$order = new Order('A-1001');
echo $order->id, "\n";

try {
    $order->id = 'B-2002';
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

למאפיין readonly חייב להיות טיפוס, ואין לו ערך ברירת מחדל. אם אתם צריכים עותק משונה, צרו אובייקט חדש (new Order('B-2002')) במקום לערוך את הישן.

הדפסת אובייקט עם __toString

echo $object עובד רק כשהמחלקה מגדירה __toString(). המתודה מחזירה את המחרוזת ש-PHP צריכה להשתמש בה בכל פעם שהאובייקט מטופל כטקסט: ב-echo, בשרשור מחרוזות, ב-"{$object}".

<?php
class Money
{
    public function __construct(
        private int $cents,
        private string $currency = 'EUR',
    ) {}

    public function __toString(): string
    {
        return number_format($this->cents / 100, 2) . ' ' . $this->currency;
    }
}

$price = new Money(129900);
echo $price, "\n";
echo 'Total: ' . $price . "\n";
echo "Shipping: " . new Money(450, 'USD') . "\n";

// For debugging, print_r and var_dump show the properties
print_r(new Money(5));

בלי __toString, echo $object זורק Error ("Object of class Money could not be converted to string"). לדיבאג, print_r() ו-var_dump() עובדות על כל אובייקט ומציגות גם מאפיינים פרטיים; ראו var_dump ו-print_r.

הצבה של אובייקט לא מעתיקה אותו

זו הטעות שעוקצת את רוב מי שמגיעים ממערכים. הצבה של מערך מעתיקה אותו. הצבה של אובייקט מעתיקה רק את הידית: שני המשתנים מצביעים אז על אותו אובייקט.

<?php
class Point
{
    public int $x = 0;
    public int $y = 0;
}

$a = new Point();
$b = $a;          // same object
$b->x = 10;
echo "a->x = {$a->x}\n";

$c = clone $a;    // independent copy
$c->x = 99;
echo "a->x = {$a->x}, c->x = {$c->x}\n";

var_dump($a === $b, $a === $c, $a == $c);
var_dump($a instanceof Point);
echo get_class($c), "\n";

clone יוצר עותק רדוד: אם מאפיין מחזיק אובייקט אחר, שני העותקים עדיין חולקים את האובייקט הפנימי הזה. === מתקיים רק לאותו אובייקט, בעוד == משווה את ערכי המאפיינים של שני אובייקטים מאותה מחלקה. העברה של אובייקט לפונקציה עובדת כמו הצבה, ולכן פונקציה יכולה לשנות את האובייקט שהיא מקבלת.