Pozno statično vezanje nadzira, na kateri razred se sklicujemo v statičnih kontekstih znotraj dedovanja. Ključna razlika: self:: se nanaša na razred, kjer je kod napisan, medtem ko se static:: nanaša na razred, ki je bil dejansko — kar je pomembno, ko dedovani razred deduje statično metodo roditeljskega razreda.
<?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 razrešen ob času definicije (vedno definirajući razred), zato tudi ko je pozvan prek ChildClass, new self() ustvari ParentClass. static:: je razrešen ob izvajanju na dejansko pozvan razred — zato new static() pravilno ustvari 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
Pozno statično vezanje je tisto, kar omogoča dedovanim tovarniškim metodam, fluent graditeljem in ORM vzorcem, da vrnejo pravilno instanco podrazreda — bistveno za statične API-je, na katere se zanašajo ogrodja.
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)
Pozno statično vezanje (static:: proti `self::``) je pomemben in pogosto napačno razumljen koncept PHP-ja, posebej relevant za razumevanje, kako ogrodja implementirajo dedovane statične API-je.
Odločilna razlika — da se self:: veže na razred, kjer je kod napisan, medtem ko se static:: veže na razred, ki je dejansko pozvan ob izvajanju — je pomembna kadarkoli dedovani razred deduje statično metodo roditeljskega razreda, ki ustvarja instance ali se sklicuje na razred: z self:: bi dedovane tovarniške metode vedno vrnile tip starša (napaka), medtem ko static:: pravilno vrne klicanega podrazreda.
To je natanko tisto, kar omogoča dedovane tovarniške metode, fluent graditelje in ORM vzorce, na katere se zanašajo ogrodja kot Laravel's Eloquent (npr. User::make() vrne User, ne osnovnega Model).
Razumevanje poznega statičnega vezanja je pomembno tako za pravilno uporabo teh vzorcev ogrodij kot za pisanje lastnih dedovanju-zavednih statičnih metod, ki se pravilno obnašajo s podrazredi.
Čeprav je naprednejša tema, je pogost vir subtilnih napak in zmede (»zakaj to vrača roditeljski razred?«), in razumevanje razlike med self::, static:: in parent:: kaže globlji pogled na PHP-jev objektni model in vedenje dedovanja — dragoceno pri delu s statičnimi API-ji, ki temeljijo na dedikovanju in so pogosti v sodobnih PHP ogrodjih.