Từ khóa static trong PHP: phương thức tĩnh, self và static

Một phương thức hay thuộc tính static thuộc về chính lớp thay vì về bất kỳ đối tượng nào. Bạn gọi phương thức tĩnh bằng ClassName::method() và đọc thuộc tính tĩnh bằng ClassName::$property, không cần tạo đối tượng trước. Bên trong lớp, self:: trỏ đến chính các thành viên đó.

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

Không hề có new Temperature() ở đâu cả. Thành viên tĩnh hữu ích cho các hàm tiện ích không cần trạng thái của đối tượng (chuyển đổi, factory, kiểm tra dữ liệu) và cho dữ liệu thuộc về cả lớp, như một bộ đếm.

Thuộc tính tĩnh dùng chung cho mọi đối tượng

Một thuộc tính bình thường có một giá trị cho mỗi đối tượng. Thuộc tính tĩnh có một giá trị cho cả lớp, nên mọi đối tượng đều thấy cùng một giá trị. Ở đây mỗi User mới tăng một bộ đếm dùng chung và nhận ID tiếp theo:

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

Chú ý dấu $ trong self::$nextId: thuộc tính tĩnh giữ dấu này sau ::, còn hằng số (self::MAX) thì không. Một thuộc tính tĩnh chỉ tồn tại trong một request PHP. Trên một website điển hình (PHP-FPM hoặc Apache), nó bắt đầu lại sau mỗi lần tải trang, nên đây không phải chỗ để lưu dữ liệu giữa các người xem.

Phương thức tĩnh không có $this

Phương thức tĩnh chạy mà không có đối tượng, nên bên trong không tồn tại $this. Phương thức tĩnh có thể gọi các phương thức tĩnh khác bằng self::, nhưng không đọc được thuộc tính bình thường. Gọi một phương thức bình thường theo kiểu tĩnh cũng thất bại:

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

Chiều ngược lại thì không sao: một phương thức bình thường có thể gọi phương thức tĩnh, như withSeparator() làm với self::make().

self và static: late static binding

self:: trỏ đến lớp nơi đoạn code được viết. static:: trỏ đến lớp mà phương thức được gọi trên đó lúc chạy. Khác biệt chỉ lộ ra khi có kế thừa, và quan trọng nhất với các phương thức 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() trả về một Model, gần như không bao giờ là thứ người gọi mong muốn. static được hiểu là Post vì đó là lớp được nêu tên trong lời gọi; PHP gọi cơ chế này là late static binding. Hãy dùng static:: và new static() trong những phương thức sẽ được kế thừa, và self:: khi bạn thực sự muốn nói đúng lớp này. Quy tắc tương tự áp dụng cho hằng số: static::TABLE lấy TABLE riêng của lớp con, còn self::TABLE luôn đọc hằng số trong lớp nơi đoạn code được viết.

Thuộc tính tĩnh kế thừa được dùng chung

Lớp con dùng chung thuộc tính tĩnh của lớp cha, trừ khi nó tự khai báo thuộc tính của riêng mình. Đây là bất ngờ kinh điển với static: hai lớp con cùng đếm vào một con số.

<?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 không có $count riêng, nên Apples::$count chính là Counter::$count, và cả hai đều in ra 2. Pears khai báo lại thuộc tính và tự đếm riêng. Một thuộc tính tĩnh khai báo trong trait thì hoạt động khác: mỗi lớp dùng trait đó có một bản sao riêng.

Biến static bên trong hàm

static còn có nghĩa thứ hai bên trong thân hàm: một biến static giữ nguyên giá trị giữa các lần gọi. Giá trị khởi tạo chỉ được gán ở lần đầu tiên hàm chạy:

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

Lần gọi slowSquare(12) thứ hai bỏ qua bước tính toán. Giống như thuộc tính tĩnh, các giá trị này được đặt lại khi mỗi request kết thúc. Trang biến trình bày phạm vi biến nói chung.

Khi nào static là lựa chọn sai

Phương thức tĩnh rất tiện, và chính vì vậy mà dễ bị lạm dụng. Một lớp mà mọi phương thức đều đọc và ghi thuộc tính tĩnh thực chất là trạng thái toàn cục khoác thêm tên lớp: mọi nơi gọi đều dùng chung nó, test không lấy được một bản mới, và bạn không thể thay bằng một cách cài đặt khác.

<?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());

Những trường hợp nên dùng static: hàm tiện ích thuần không có trạng thái (Slug::make()), hàm khởi tạo có tên (Color::fromHex()), và hằng số dùng cho cả lớp. Nếu một phương thức cần dữ liệu có thể khác nhau giữa hai lần dùng, thứ nó cần là một đối tượng.