Late static binding là gì (static:: vs self::)?

Question

Accepted Answer

**Late static binding** kiểm soát class nào được tham chiếu trong các ngữ cảnh static bên trong kế thừa. Sự phân biệt then chốt: **`self::`** tham chiếu tới class nơi code được *viết*, còn **`static::`** tham chiếu tới class thực sự được *gọi lúc chạy* — điều này quan trọng khi một lớp con kế thừa một method static của lớp cha.

## Vấn đề: self:: là "early bound"

```php
<?php
class ParentClass {
    public static function create(): self {
        return new self();      // self:: LUÔN nghĩa là ParentClass (nơi nó được viết)
    }
    public static function createStatic(): static {
        return new static();    // static:: nghĩa là class được GỌI (lúc chạy)
    }
}

class ChildClass extends ParentClass {}

get_class(ChildClass::create());        // "ParentClass" — self:: gắn với nơi được viết ❌
get_class(ChildClass::createStatic());  // "ChildClass" — static:: gắn với lời gọi ✅
```

`self::` được phân giải lúc định nghĩa (luôn là class định nghĩa nó), nên ngay cả khi gọi qua `ChildClass`, `new self()` tạo một `ParentClass`. **`static::`** được phân giải lúc *chạy* tới class thực sự được gọi — nên `new static()` đúng đắn tạo một `ChildClass`.

## Tại sao quan trọng: factory method và fluent API

```php
class Model {
    public static function make(): static {     // kiểu trả về static + new static()
        return new static();    // ✅ trả về instance của bất kỳ lớp con nào đã gọi nó
    }
}
class User extends Model {}
class Post extends Model {}

User::make();   // trả về một User (không phải Model) — nhờ late static binding
Post::make();   // trả về một Post
```

Late static binding là điều khiến các factory method được kế thừa, các builder fluent, và các mẫu ORM trả về đúng instance *lớp con* — thiết yếu cho các API dựa trên method static mà framework dựa vào.

## Ba từ khóa

```text
self::    → class nơi code được VIẾT (binding sớm/static)
static::  → class được GỌI lúc chạy (late static binding) — cho code nhận biết lớp con
parent::  → lớp cha (để gọi method cha đã bị ghi đè)
```

## Tại sao điều này quan trọng

Late static binding (`static::` vs `self::`) là một khái niệm PHP quan trọng và thường bị hiểu sai, đặc biệt liên quan để hiểu cách các framework triển khai các API static dựa trên kế thừa.

Sự phân biệt then chốt — rằng **`self::` gắn với class nơi code được viết** còn **`static::` gắn với class thực sự được gọi lúc chạy** — quan trọng bất cứ khi nào một lớp con kế thừa một method static của lớp cha vốn tạo instance hoặc tham chiếu class: với `self::`, các factory method được kế thừa sẽ luôn trả về kiểu cha (một lỗi), còn **`static::` đúng đắn trả về lớp con đang gọi**.

Đây chính xác là điều cho phép các factory method được kế thừa, các builder fluent, và các mẫu ORM mà các framework như Eloquent của Laravel dựa vào (ví dụ `User::make()` trả về một `User`, không phải `Model` gốc).

Hiểu late static binding quan trọng cả để dùng các mẫu framework này đúng và để viết các method static nhận biết kế thừa của riêng bạn hoạt động đúng với lớp con.

Dù là một chủ đề nâng cao hơn, đây là nguồn lỗi và nhầm lẫn tinh vi thường gặp ("tại sao cái này trả về lớp cha?"), và hiểu sự phân biệt `self::`/`static::`/`parent::` phản ánh kiến thức sâu hơn về mô hình object và hành vi kế thừa của PHP — giá trị để làm việc với và xây các API dựa trên method static, nặng về kế thừa phổ biến trong các framework PHP hiện đại.