static ב-PHP: מתודות ומאפיינים סטטיים, self מול static

מתודה או מאפיין static שייכים למחלקה עצמה ולא לאובייקט כלשהו. קוראים למתודה סטטית עם ClassName::method() וקוראים מאפיין סטטי עם ClassName::$property, בלי ליצור קודם אובייקט. בתוך המחלקה, self:: מתייחס לאותם חברים.

<?php
class Temperature
{
    public static int $conversions = 0;

    public static function toFahrenheit(float $c): float
    {
        self::$conversions++;
        return $c * 9 / 5 + 32;
    }
}

echo Temperature::toFahrenheit(20), "\n";
echo Temperature::toFahrenheit(37.5), "\n";
echo 'Conversions so far: ', Temperature::$conversions, "\n";

אין new Temperature() בשום מקום. חברים סטטיים שימושיים לפונקציות עזר שלא צריכות מצב של אובייקט (המרות, factories, אימות) ולנתונים ששייכים למחלקה כולה, כמו מונה.

מאפיינים סטטיים משותפים לכל האובייקטים

למאפיין רגיל יש ערך אחד לכל אובייקט. למאפיין סטטי יש ערך אחד לכל המחלקה, ולכן כל אובייקט רואה את אותו ערך. כאן כל User חדש מגדיל מונה משותף ומקבל את המזהה הבא:

<?php
class User
{
    private static int $nextId = 1;
    public readonly int $id;

    public function __construct(public string $name)
    {
        $this->id = self::$nextId++;
    }

    public static function created(): int
    {
        return self::$nextId - 1;
    }
}

$a = new User('Ada');
$b = new User('Grace');
$c = new User('Linus');

echo "{$a->name} #{$a->id}, {$b->name} #{$b->id}, {$c->name} #{$c->id}\n";
echo User::created(), " users created\n";

שימו לב ל-$ ב-self::$nextId: מאפיינים סטטיים שומרים עליו אחרי ::, בעוד קבועים (self::MAX) לא. מאפיין סטטי חי לבקשת PHP אחת בלבד. באתר טיפוסי (PHP-FPM או Apache) הוא מתחיל מחדש בכל טעינת דף, ולכן הוא לא מקום לשמור נתונים בין מבקרים.

למתודות סטטיות אין $this

מתודה סטטית רצה בלי אובייקט, ולכן $this לא קיים בתוכה. מתודה סטטית יכולה לקרוא למתודות סטטיות אחרות עם self::, אבל היא לא יכולה לקרוא מאפיינים רגילים. גם קריאה סטטית למתודה רגילה נכשלת:

<?php
class Slug
{
    private string $separator = '-';

    public static function make(string $text): string
    {
        $text = strtolower(trim($text));
        return trim(preg_replace('/[^a-z0-9]+/', '-', $text), '-');
    }

    public function withSeparator(string $text): string
    {
        return str_replace('-', $this->separator, self::make($text));
    }
}

echo Slug::make('  Hello, Static World! '), "\n";
echo (new Slug())->withSeparator('Objects can call static methods'), "\n";

try {
    echo Slug::withSeparator('no object here');
} catch (Error $e) {
    echo get_class($e), ': ', $e->getMessage(), "\n";
}

הכיוון ההפוך בסדר: מתודה רגילה יכולה לקרוא למתודות סטטיות, כמו ש-withSeparator() עושה עם self::make().

self מול static: late static binding

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

<?php
class Model
{
    public static function createWithSelf(): Model
    {
        return new self();
    }

    public static function createWithStatic(): static
    {
        return new static();
    }

    public static function table(): string
    {
        return strtolower(static::class) . 's';
    }

    public static function tableWithSelf(): string
    {
        return strtolower(self::class) . 's';
    }
}

class Post extends Model {}
class Comment extends Model {}

echo get_class(Post::createWithSelf()), "\n";    // Model
echo get_class(Post::createWithStatic()), "\n";  // Post
echo Post::table(), ', ', Comment::table(), "\n";
echo Post::tableWithSelf(), "\n";

Post::createWithSelf() מחזירה Model, וזה כמעט אף פעם לא מה שהקורא רצה. static מתפרש כ-Post כי זו המחלקה שנכתבה בקריאה; PHP קוראת לזה late static binding. השתמשו ב-static:: וב-new static() במתודות שנועדו לעבור בירושה, וב-self:: כשאתם באמת מתכוונים למחלקה המדויקת הזו. אותו כלל חל על קבועים: static::TABLE לוקח את ה-TABLE של הבת, בעוד self::TABLE תמיד קורא את זה שבמחלקה שבה הקוד כתוב.

מאפיינים סטטיים שעוברים בירושה משותפים

מחלקת בת חולקת את המאפיין הסטטי של האב שלה אלא אם היא מצהירה על משלה. זו ההפתעה הקלאסית של static: שתי מחלקות בת שסופרות לתוך מספר אחד.

<?php
class Counter
{
    public static int $count = 0;

    public static function increment(): void
    {
        static::$count++;
    }
}

class Apples extends Counter {}

class Pears extends Counter
{
    public static int $count = 0;   // its own copy
}

Apples::increment();
Apples::increment();
Pears::increment();

echo 'Counter: ', Counter::$count, "\n";
echo 'Apples: ', Apples::$count, "\n";
echo 'Pears: ', Pears::$count, "\n";

ל-Apples אין $count משלה, ולכן Apples::$count הוא Counter::$count, ושניהם מדפיסים 2. Pears מצהירה מחדש על המאפיין וסופרת בעצמה. מאפיין סטטי שמוצהר ב-trait מתנהג אחרת: כל מחלקה שמשתמשת ב-trait מקבלת עותק נפרד.

משתנים סטטיים בתוך פונקציות

ל-static יש משמעות שנייה בתוך גוף של פונקציה: משתנה סטטי שומר על הערך שלו בין קריאות. הערך ההתחלתי מוצב רק בפעם הראשונה שהפונקציה רצה:

<?php
function nextTicket(): string
{
    static $number = 0;
    $number++;
    return sprintf('T-%04d', $number);
}

echo nextTicket(), "\n";
echo nextTicket(), "\n";
echo nextTicket(), "\n";

// A simple cache: computed once, reused afterwards
function slowSquare(int $n): int
{
    static $cache = [];
    if (!isset($cache[$n])) {
        echo "(computing $n) ";
        $cache[$n] = $n * $n;
    }
    return $cache[$n];
}

echo slowSquare(12), "\n";
echo slowSquare(12), "\n";

ה-slowSquare(12) השני מדלג על החישוב. כמו מאפיינים סטטיים, הערכים האלה מתאפסים בסוף כל בקשה. העמוד משתנים מכסה טווח משתנים באופן כללי.

מתי static הוא הבחירה הלא נכונה

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

<?php
// Static: one shared cart for the whole program
class StaticCart
{
    private static array $items = [];

    public static function add(string $item): void { self::$items[] = $item; }
    public static function items(): array { return self::$items; }
}

// Object: each cart is separate
class Cart
{
    private array $items = [];

    public function add(string $item): void { $this->items[] = $item; }
    public function items(): array { return $this->items; }
}

StaticCart::add('book');
StaticCart::add('pen');     // a "second customer" adds to the same cart
print_r(StaticCart::items());

$ada = new Cart();
$linus = new Cart();
$ada->add('book');
$linus->add('pen');
print_r($ada->items());
print_r($linus->items());

שימושים טובים ב-static: פונקציות עזר טהורות בלי מצב (Slug::make()), בנאים עם שם (Color::fromHex()) וקבועים של המחלקה כולה. אם מתודה צריכה נתונים שיכולים להשתנות בין שני שימושים, היא רוצה אובייקט.