Sen statisk binding styrer, hvilken klasse der refereres til i statiske kontekster inden for arv. Hovedforskellen: self:: henviser til den klasse, hvor koden er skrevet, mens static:: henviser til den klasse, der faktisk blev — hvilket betyder noget, når en underklasse arver en forældreklasses statiske metode.
<?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å definitionstidspunktet (altid den definerende klasse), så selv når den kaldes via ChildClass, opretter new self() en ParentClass. static:: løses ved kørseltidspunktet til den faktisk kaldte klasse — så new static() opretter 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, der gør arvet factory-metoder, fluent builders og ORM-mønstre returnerer den korrekte underklasse-instans — væsentlig for de statiske-metode-baserede APIs, som frameworks afhænger af.
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 vigtigt og ofte misforstået PHP-koncept, særligt relevant for at forstå, hvordan frameworks implementerer arvingsbaserede statiske APIs.
Hovedforskellen — at self:: bindes til den klasse, hvor koden er skrevet mens static:: bindes til den klasse, der faktisk blev kaldt ved kørseltidspunktet — betyder noget, hver gang en underklasse arver en forældreklasses statiske metode, der opretter instanser eller refererer til klassen: med self:: ville arvet factory-metoder altid returnere forældreklassen (en bug), mens static:: korrekt returnerer den kaldende underklasse.
Dette er netop det, der muliggør de arvet factory-metoder, fluent builders og ORM-mønstre, som frameworks som Laravel's Eloquent afhænger af (f.eks. User::make() returnerer en User, ikke basen Model).
At forstå sen statisk binding er vigtig både for at bruge disse framework-mønstre korrekt og for at skrive dine egne arvingsbevidste statiske metoder, der opfører sig korrekt med underklasser.
Skønt et mere avanceret emne, er det en hyppig kilde til subtile bugs og forvirring ("hvorfor returnerer dette forældreklassen?"), og at forstå self::/static::/parent::-forskellen afspejler dybere viden om PHPs objektmodel og arvingsadfærd — værdifuldt for at arbejde med og bygge de statiske-metode-baserede, arvingshyppige APIs, der er almindelige i moderne PHP-frameworks.