Late static binding คืออะไร (static:: เทียบกับ self::)?

Question

Accepted Answer

**Late static binding** ควบคุมว่าคลาสใดถูกอ้างอิงในบริบทแบบ static ภายในการสืบทอด (inheritance) ความแตกต่างสำคัญคือ **`self::`** อ้างถึงคลาสที่โค้ดถูก *เขียน* ไว้ ในขณะที่ **`static::`** อ้างถึงคลาสที่ถูก *เรียก* จริงตอนรันไทม์ ซึ่งสำคัญเมื่อ child class สืบทอด static method ของ parent

## ปัญหา: self:: เป็นแบบ "early bound"

```php
<?php
class ParentClass {
    public static function create(): self {
        return new self();      // self:: ALWAYS means ParentClass (where it's written)
    }
    public static function createStatic(): static {
        return new static();    // static:: means the CALLED class (runtime)
    }
}

class ChildClass extends ParentClass {}

get_class(ChildClass::create());        // "ParentClass" — self:: bound to where written ❌
get_class(ChildClass::createStatic());  // "ChildClass" — static:: bound to the call ✅
```

`self::` ถูกแก้ไข (resolve) ตอนนิยาม (definition time) เสมอ (เป็นคลาสที่นิยามมันเสมอ) ดังนั้นแม้เรียกผ่าน `ChildClass` ก็ตาม `new self()` ก็ยังสร้าง `ParentClass` ส่วน **`static::`** ถูกแก้ไขตอน *รันไทม์* เป็นคลาสที่ถูกเรียกจริง ดังนั้น `new static()` จึงสร้าง `ChildClass` ได้อย่างถูกต้อง

## ทำไมจึงสำคัญ: factory method และ fluent API

```php
class Model {
    public static function make(): static {     // static return type + new static()
        return new static();    // ✅ returns an instance of whatever subclass called it
    }
}
class User extends Model {}
class Post extends Model {}

User::make();   // returns a User (not a Model) — thanks to late static binding
Post::make();   // returns a Post
```

Late static binding คือสิ่งที่ทำให้ factory method ที่สืบทอดมา, fluent builder และแพตเทิร์น ORM คืน instance ของ *subclass ที่ถูกต้อง* ซึ่งจำเป็นต่อ API ที่อิงกับ static method ที่เฟรมเวิร์กพึ่งพา

## สามคีย์เวิร์ด

```text
self::    → the class where the code is WRITTEN (early/static binding)
static::  → the class CALLED at runtime (late static binding) — for subclass-aware code
parent::  → the parent class (for calling overridden parent methods)
```

## ทำไมจึงสำคัญ

Late static binding (`static::` เทียบกับ `self::`) เป็นแนวคิดสำคัญของ PHP ที่มักถูกเข้าใจผิด โดยเฉพาะอย่างยิ่งเกี่ยวข้องกับการเข้าใจว่าเฟรมเวิร์กสร้าง API แบบ static ที่อิงการสืบทอดอย่างไร

ความแตกต่างที่สำคัญยิ่ง คือ **`self::` ผูกกับคลาสที่โค้ดถูกเขียนไว้** ในขณะที่ **`static::` ผูกกับคลาสที่ถูกเรียกจริงตอนรันไทม์** มีความสำคัญทุกครั้งที่ child class สืบทอด static method ของ parent ที่สร้าง instance หรืออ้างถึงคลาส: ด้วย `self::` factory method ที่สืบทอดมาจะคืนชนิดของ parent เสมอ (เป็นบั๊ก) ในขณะที่ **`static::` คืน subclass ที่เรียกได้อย่างถูกต้อง**

นี่คือสิ่งที่เปิดทางให้ factory method ที่สืบทอดมา, fluent builder และแพตเทิร์น ORM ที่เฟรมเวิร์กอย่าง Eloquent ของ Laravel พึ่งพา (เช่น `User::make()` คืน `User` ไม่ใช่ `Model` ฐาน)

การเข้าใจ late static binding สำคัญทั้งต่อการใช้แพตเทิร์นของเฟรมเวิร์กเหล่านี้อย่างถูกต้อง และต่อการเขียน static method ที่รับรู้การสืบทอดของคุณเองให้ทำงานอย่างถูกต้องกับ subclass

แม้จะเป็นหัวข้อขั้นสูงกว่า แต่ก็เป็นต้นเหตุของบั๊กและความสับสนเล็ก ๆ น้อย ๆ ที่พบบ่อย ("ทำไมมันคืนคลาส parent?") และการเข้าใจความแตกต่างระหว่าง `self::`/`static::`/`parent::` สะท้อนถึงความรู้ที่ลึกซึ้งขึ้นเกี่ยวกับ object model และพฤติกรรมการสืบทอดของ PHP ซึ่งมีคุณค่าต่อการทำงานกับและสร้าง API แบบ static ที่เน้นการสืบทอดซึ่งพบบ่อยในเฟรมเวิร์ก PHP สมัยใหม่