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() في أي مكان. والأعضاء الساكنة مفيدة للدوال المساعدة التي لا تحتاج إلى حالة كائن (التحويلات، والمصانع، والتحقق) وللبيانات التي تخص الصنف كله، مثل عداد.

الخصائص الساكنة يتشاركها كل الكائنات

للخاصية العادية قيمة لكل كائن. وللخاصية الساكنة قيمة واحدة للصنف كله، فيرى كل كائن القيمة نفسها. هنا يزيد كل 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: الربط الساكن المتأخر

تشير self:: إلى الصنف الذي كُتبت فيه الشيفرة. وتشير static:: إلى الصنف الذي استُدعي عليه التابع وقت التشغيل. ولا يظهر الفرق إلا مع الوراثة، وأهم ما يكون مع توابع المصنع:

<?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 هذا الربط الساكن المتأخر. استخدم 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 فتعيد التصريح بالخاصية وتعدّ وحدها. والخاصية الساكنة المصرّح بها في سمة تتصرف بشكل مختلف: كل صنف يستخدم السمة يحصل على نسخة منفصلة.

المتغيرات الساكنة داخل الدوال

لـ 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())، والثوابت على مستوى الصنف. وإذا احتاج تابع إلى بيانات قد تختلف بين استخدامين، فهو يريد كائنًا.