Sen statisk bindning styr vilken klass som refereras i statiska sammanhang inom arv. Nyckelskilnaden: self:: refererar till klassen där koden är skriven, medan static:: refererar till klassen som faktiskt anropades vid körning — vilket är viktigt när en barnklass ärver en förälderklasss statiska metod.
<?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 in vid definitionen (alltid den definerande klassen), så även när det anropas via ChildClass, skapar new self() en ParentClass. static:: löses in vid körning till den faktiskt anropade klassen — så new static() skapar 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 bindning är det som gör att ärvda fabriksmetoder, flytande builders och ORM-mönster returnerar rätt underklassinstans — väsentligt för de statiska metod-baserade API:er som ramverk förlitar sig på.
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 bindning (static:: vs `self::``) är ett viktigt och ofta missförstått PHP-koncept, särskilt relevant för att förstå hur ramverk implementerar arvsbaserade statiska API:er.
Den avgörande skillnaden — att self:: binder till klassen där koden är skriven medan static:: binder till klassen som faktiskt anropades vid körning — spelar roll när en barnklass ärver en förälderklasss statiska metod som skapar instanser eller refererar till klassen: med self:: skulle ärvda fabriksmetoder alltid returnera föräldertypen (ett fel), medan static:: korrekt returnerar den anropade underklassen.
Detta är exakt vad som möjliggör de ärvda fabriksmetoder, flytande builders och ORM-mönster som ramverk som Laravels Eloquent förlitar sig på (t.ex. User::make() returnerar en User, inte den grundläggande Model).
Att förstå sen statisk bindning är viktigt både för att använda dessa ramverksmönster korrekt och för att skriva dina egna arvsbetingade statiska metoder som beter sig riktigt med underklasser.
Även om det är ett mer avancerat ämne, är det en vanlig källa till subtila fel och förvirring ("varför returnerar detta förälderklassen?"), och att förstå skillnaden mellan self::/static::/parent:: återspeglar djupare kunskap om PHP:s objektmodell och arvsbeteende — värdefullt för att arbeta med och bygga de statiska metod-baserade, arvstunga API:er som är vanliga i moderna PHP-ramverk.