Sen statisk binding kontrollerer hvilken klasse som refereres i statiske kontekster innen arving. Hovedskillet: self:: refererer til klassen der koden er skrevet, mens static:: refererer til klassen som faktisk ble — noe som er viktig når en barneklasse arver en statisk metode fra foreldreklassen.
<?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:: løses på definisjonstidspunktet (alltid den definerende klassen), så selv når det kalles via ChildClass, lager new self() en ParentClass. static:: løses ved kjøretid til den faktisk kalte klassen — så new static() lager korrekt en 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
Sen statisk binding er det som gjør at arvede fabrikk-metoder, fluent builders og ORM-mønstre returnerer den korrekte underklasse-forekomsten — essensielt for de statisk-metode-baserte API-ene som rammeverk er avhengige av.
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)
Sen statisk binding (static:: vs self::) er et viktig og ofte misforstått PHP-konsept, særlig relevant for å forstå hvordan rammeverk implementerer arvings-baserte statiske API-er.
Hovedskillet — at self:: binder til klassen der koden er skrevet mens static:: binder til klassen som faktisk ble kalt ved kjøretid — er viktig når en barneklasse arver en foreldreklasses statiske metode som oppretter forekomster eller refererer til klassen: med self:: ville arvede fabrikk-metoder alltid returnere foreldreklasstypen (en bug), mens static:: korrekt returnerer den kalte underklassen.
Dette er nettopp det som gjør de arvede fabrikk-metodene, fluent builders og ORM-mønstre mulig som rammeverk som Laravel's Eloquent er avhengig av (f.eks. User::make() returnerer en User, ikke grunnklassen Model).
Å forstå sen statisk binding er viktig både for å bruke disse rammeverks-mønsterne korrekt og for å skrive dine egne arvings-bevisste statiske metoder som oppfører seg riktig med underklasser.
Hovedsakelig et mer avansert emne, er det en vanlig kilde til subtile bugs og forvirring ("hvorfor returnerer dette foreldreklassen?"), og forståelsen av self::/static::/parent::-skillet gjenspeiler dypere kunnskap om PHP's objektmodell og arvingsatferd — verdifullt for å arbeide med og bygge de statisk-metode-baserte, arvings-tunge API-ene som er vanlige i moderne PHP-rammeverk.