Late static binding என்றால் என்ன (static:: vs self::)?

Question

Accepted Answer

**Late static binding** என்பது inheritance-ல் static contexts-ல் எந்த class-ஐ reference செய்வதென்பதைக் கட்டுப்படுத்துகிறது. முக்கிய வேறுபாடு: **`self::`** code *எழுதப்பட்ட* class-ஐ குறிக்கிறது, அதேவேளை **`static::`** runtime-ல் *உண்மையாக call செய்யப்பட்ட* class-ஐ குறிக்கிறது — இது child class ஒரு parent-ன் static method-ஐ inherit செய்யும்போது முக்கியமாக இருக்கிறது.

## சிக்கல்: 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::` definition time-ல் resolve ஆகிறது (எப்போதுமே defining class), எனவே `ChildClass` மூலம் call செய்யப்பட்டாலும், `new self()` ஒரு `ParentClass`-ஐ உருவாக்குகிறது. **`static::`** என்பது *runtime* time-ல் உண்மையாக-call செய்யப்பட்ட class-க்கு resolve ஆகிறது — எனவே `new static()` சரியாக ஒரு `ChildClass`-ஐ உருவாக்குகிறது.

## ஏன் முக்கியமாக இருக்கிறது: factory methods மற்றும் fluent APIs

```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 என்பது inherited factory methods, fluent builders, மற்றும் ORM patterns-ஐ *சரியான subclass* instance-ஐ return செய்ய செய்யும் விஷயமாகும் — static-method-based APIs frameworks நம்பிக்கையுடன் இருக்கிறது.

## மூன்று keywords

```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::` vs `self::`), தமிழ்-speaking developers-க்கு ஒரு முக்கியமான மற்றும் அடிக்கடி தவறுபடுத்தப்படும் PHP concept-ஆகும், குறிப்பாக frameworks inheritance-based static APIs-ஐ எவ்வாறு implement செய்கிறது என்பதைப் புரிந்துகொள்வதற்குத் தொடர்புடையது.

अत्यावश्यक வேறுபாடு — **`self::` code எழுதப்பட்ட class-க்கு bind ஆகிறது** அதேவேளை **`static::` runtime-ல் உண்மையாக call செய்யப்பட்ட class-க்கு bind ஆகிறது** — இது ஒரு child class ஒரு parent-ன் static method-ஐ inherit செய்யும்போது முக்கியமாக இருக்கிறது அது instances உருவாக்குகிறதோ அல்லது class-ஐ reference செய்கிறதோ: `self::`-ல், inherited factory methods எப்போதுமே parent type-ஐ return செய்யும் (ஒரு bug), அதேவேளை **`static::` சரியாக calling subclass-ஐ return செய்கிறது**.

இது Laravel-ன் Eloquent போன்ற frameworks inherited factory methods, fluent builders, மற்றும் ORM patterns-ஐ சார்ந்திருக்கும் விஷயத்தை சரியாக செயல்படுத்துகிறது (உ.ம். `User::make()` `Model` அல்ல `User`-ஐ return செய்கிறது).

Late static binding-ஐ புரிந்துகொள்வது இந்த framework patterns-ஐ சரியாக பயன்படுத்துவதற்கும் உங்கள் சொந்த inheritance-aware static methods-ஐ எழுதுவதற்கும் முக்கியமாக இருக்கிறது subclasses-க்கு சரியாக செயல்பட:

ஒரு மேலும் advanced topic-ஆக இருந்தாலும், இது subtle bugs-ன் மற்றும் குழப்பத்திற்கான ஒரு common source (