Pozdní statické vázání kontroluje, na kterou třídu se odkazuje v statických kontextech v rámci dědičnosti. Klíčový rozdíl: self:: se odkazuje na třídu, kde je kód napsán, zatímco static:: se odkazuje na třídu, která byla skutečně — což je důležité, když dceřiná třída dědí statickou metodu z rodičovské třídy.
<?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:: je rozlišeno v čase definice (vždy se jedná o definující třídu), takže i když je voláno přes ChildClass, new self() vytvoří instanci ParentClass. static:: je rozlišeno za běhu na skutečně volanou třídu — takže new static() správně vytvoří instanci 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
Pozdní statické vázání je to, co umožňuje děděným továrním metodám, fluent builderům a ORM vzorům vrátit instanci správné podtřídy — to je nezbytné pro statické API, na kterých jsou frameworky závislé.
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)
Pozdní statické vázání (static:: vs self::), je důležitý a často nepochopený koncept v PHP, obzvláště relevantní pro pochopení toho, jak frameworky implementují statické API na základě dědičnosti.
Klíčový rozdíl — že self:: vázane na třídu, kde je kód napsán, zatímco static:: vázane na třídu, která byla skutečně zavolána za běhu — je důležitý vždy, když dceřiná třída dědí statickou metodu z rodičovské třídy, která vytváří instance nebo se odkazuje na třídu: u self:: by děděné tovární metody vždy vrátily nadřazený typ (chyba), zatímco static:: správně vrátí volanou podtřídu.
To je přesně to, co umožňuje děděné tovární metody, fluent buildery a ORM vzory, na kterých závisí frameworky jako Laravel Eloquent (User::make() vrací User, ne základní Model).
Pochopení pozdního statického vázání je důležité jak pro správné používání těchto framework vzorů, tak pro psaní vlastních statických metod, které jsou si vědomy dědičnosti a které se správně chovají s podtřídami.
I když jde o pokročilejší téma, je to častý zdroj jemných chyb a nejasností ("proč to vrací nadřazenou třídu?"), a pochopení rozdílu self::/static::/parent:: odráží hlubší znalost objektového modelu PHP a chování dědičnosti — cenné pro práci s a tvorbu statických API na základě metod, která jsou těžko závislá na dědičnosti, kterou běžně vidíme v moderních PHP frameworcích.