Myöhäinen staattinen sitominen määrittää, mihin luokkaan viitataan staattisissa konteksteissa perinnässä. Keskeinen ero: self:: viittaa luokkaan, jossa koodi on kirjoitettu, kun taas static:: viittaa luokkaan, jota — mikä on tärkeää, kun lapsiluokka perii vanhemman staattisen metodin.
<?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:: ratkaistaan määritysajassa (aina määrittävä luokka), joten jopa kun sitä kutsutaan ChildClass-luokan kautta, new self() luo ParentClass-instanssin. static:: ratkaistaan ajon aikana todellisesti kutsuttuun luokkaan — joten new static() luo oikein ChildClass-instanssin.
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
Myöhäinen staattinen sitominen on se, joka tekee perityistä tehdasmetodeista, fluent rakentajista ja ORM-malleista oikean aliluokan instanssin palauttavia — olennaista staattisen metodin perustavissa API:issa, joita kehykset käyttävät.
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)
Myöhäinen staattinen sitominen (static:: vs `self::``) on tärkeä ja usein ymmärretty väärin PHP-käsite, erityisen relevantti ymmärrettäessä, kuinka kehykset toteuttavat perinnän pohjaiset staattiset API:t.
Ratkaiseva ero — että self:: sitoutuu luokkaan, jossa koodi on kirjoitettu, kun taas static:: sitoutuu ajon aikana todella kutsuttuun luokkaan — on merkityksellistä aina, kun lapsiluokka perii vanhemman staattisen metodin, joka luo instansseja tai viittaa luokkaan: self::-tapauksessa perityt tehdasmetodit palauttaisivat aina vanhemman tyypin (virhe), kun taas static:: oikein palauttaa kutsuvan aliluokan.
Juuri tämä mahdollistaa perityt tehdasmetodit, fluent rakentajat ja ORM-mallit, joista kehykset kuten Laravelin Eloquent riippuvat (esim. User::make() palauttaa User-instanssin, ei perusmallia).
Myöhäisen staattisen sitomisen ymmärtäminen on tärkeää sekä näiden kehysmallejen oikean käytön että omien perinnän tietoisten staattisten metodien kirjoittamisen kannalta, jotka toimivat oikein aliluokkien kanssa.
Vaikka se onkin edistyneempi aihe, se on yleinen lähde hienovaraisille virheille ja sekaannuksille ("miksi tämä palauttaa vanhemman luokan?"), ja self::/static::/parent::-eron ymmärtäminen heijastaa syvempää PHP:n oliomallista ja perinnön käyttäytymisestä — arvokas näkökulma työskenneltäessä staattisten metodien pohjaisista, perinnän raskaista API:ista, jotka ovat yleisiä nykyaikaisissa PHP-kehyksissä.