Late static binding controlează ce clasă este referențiată în contexte statice în cadrul moștenirii. Distinția cheie: self:: se referă la clasa în care codul este scris, în timp ce static:: se referă la clasa care a fost efectiv — ceea ce conteaza atunci când o clasă copil moștenește o metodă statică a clasei părinte.
<?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:: este rezolvată la momentul definirii (întotdeauna clasa care definește), deci chiar și atunci când este apelată prin ChildClass, new self() creează o ParentClass. static:: este rezolvată la runtime la clasa efectiv apelată — deci new static() creează corect o ChildClass.
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 este ceea ce face ca metodele factory moștenite, fluent builders și modelele ORM să returneze instanța corectă de subclasă — esențial pentru API-urile bazate pe metode statice pe care se bazează framework-urile.
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::) este un concept PHP important și adesea greșit înțeles, cu relevanță particulară pentru a înțelege cum framework-urile implementează API-uri statice bazate pe moștenire.
Distincția crucială — că self:: se leagă la clasa în care codul este scris în timp ce static:: se leagă la clasa care a fost efectiv apelată la runtime — conteaza ori de câte ori o clasă copil moștenește o metodă statică a clasei părinte care creează instanțe sau face referință la clasă: cu self::, metodele factory moștenite ar returna întotdeauna tipul clasei părinte (o greșeală), în timp ce static:: returnează corect subclasa apelată.
Acesta este exact ceea ce permite metodele factory moștenite, fluent builders și modelele ORM pe care framework-uri precum Laravel's Eloquent se bazează (de exemplu, User::make() returnează un User, nu baza Model).
Înțelegerea late static binding este importantă atât pentru utilizarea corectă a acestor modele de framework cât și pentru scrierea propriilor metode statice conștiente de moștenire care se comportă corespunzător cu subclasele.
Deși este un subiect mai avansat, este o sursă frecventă de greșeli subtile și confuzie ("de ce returnează aceasta clasa părinte?"), și înțelegerea distincției self::/static::/parent:: reflectă cunoștințe mai profunde despre modelul de obiecte al PHP și comportamentul moștenirii — valoros pentru lucrul și construirea API-urilor bazate pe metode statice, grele în moștenire, comune în framework-urile PHP moderne.