Late static binding controlla quale classe viene referenziata nei contesti statici all'interno dell'ereditarietà. La distinzione chiave: self:: si riferisce alla classe dove il codice è scritto, mentre static:: si riferisce alla classe che è stata effettivamente — cosa che importa quando una classe figlia eredita il metodo statico di una classe genitore.
<?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:: viene risolto al momento della definizione (sempre della classe che la definisce), quindi anche se chiamato via ChildClass, new self() crea una ParentClass. static:: viene risolto a runtime alla classe effettivamente chiamata — quindi new static() crea correttamente una 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 è ciò che permette ai factory methods ereditati, ai fluent builders e ai pattern ORM di restituire l'istanza della sottoclasse corretta — essenziale per le API basate su metodi statici su cui i framework si affidano.
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::), è un concetto PHP importante e frequentemente frainteso, particolarmente rilevante per comprendere come i framework implementano API statiche basate sull'ereditarietà.
La distinzione cruciale — che self:: si lega alla classe dove il codice è scritto mentre static:: si lega alla classe effettivamente chiamata a runtime — importa ogni volta che una classe figlia eredita il metodo statico di una classe genitore che crea istanze o referenzia la classe: con self::, i factory methods ereditati restituirebbero sempre il tipo genitore (un bug), mentre static:: correttamente restituisce la sottoclasse chiamante.
Questo è esattamente ciò che abilita i factory methods ereditati, i fluent builders e i pattern ORM su cui framework come Laravel's Eloquent si affidano (per es. User::make() che restituisce un User, non il base Model).
Comprendere late static binding è importante sia per usare correttamente questi pattern framework che per scrivere i propri metodi statici consapevoli dell'ereditarietà che si comportano propriamente con le sottoclassi.
Seppure un argomento più avanzato, è una fonte comune di bug sottili e confusione ("perché sta restituendo la classe genitore?"), e comprendere la distinzione self::/static::/parent:: riflette una conoscenza più profonda del modello di oggetti di PHP e del comportamento dell'ereditarietà — prezioso per lavorare con e costruire le API basate su metodi statici, pesantemente ereditarie, comuni nei moderni framework PHP.