Late static binding inheritance મા static contexts માં કયો class reference થાય છે તે નિયંત્રિત કરે છે। મુખ્ય તફાવત: self:: તે class ને refer કરે છે જ્યાં code લખવામાં આવ્યો છે, જ્યારે static:: તે class ને refer કરે છે જે runtime પર વાસ્તવમાં — જે બાબત child class જ્યારે parent ના static method ને inherit કરે તો મહત્વપૂર્ણ છે।
<?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:: definition time પર resolve થાય છે (હંમેશા defining class), તેથી જ્યારે ChildClass મારફતે call થાય ત્યારે પણ, new self() એક ParentClass બનાવે છે। static:: runtime પર resolve થાય છે actually-called class સુધી — તેથી new static() સાચી રીતે 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
Late static binding જે વસ્તુ બનાવે છે તે inherited factory methods, fluent builders, અને ORM patterns સાચો subclass instance return કરે છે — જે framework ના static-method-based APIs માટે આવશ્યક છે।
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)
Late static binding (static:: વિ self::):એ એક મહત્વપૂર્ણ અને વારંવાર ગેરસમજાય તેવો PHP concept છે, ખાસ કરીને inheritance-based static APIs કેવી રીતે frameworks implement કરે છે તે સમજવા માટે સંબંધિત છે।
મહત્વપૂર્ણ તફાવત — કે self:: તે class માં bind થાય છે જ્યાં code લખવામાં આવ્યો છે જ્યારે static:: તે class માં bind થાય છે જે runtime પર વાસ્તવમાં call કરવામાં આવ્યો હતો — જ્યારે પણ important છે જ્યારે child class એક parent ના static method ને inherit કરે છે જે instances બનાવે છે અથવા class ને reference કરે છે: self:: સાથે, inherited factory methods હંમેશા parent type return કરશે (a bug), જ્યારે static:: સાચી રીતે calling subclass return કરે છે।
યह બરાબર તે છે જે inherited factory methods, fluent builders, અને ORM patterns ને enable કરે છે જે frameworks જેમ કે Laravel ના Eloquent પર depend કરે છે (દા.ત. User::make() એક User return કરે છે, base Model નહીં)।
Late static binding સમજવું બંને માટે મહત્વપૂર્ણ છે આ framework patterns ને સાચી રીતે ઉપયોગ કરવા માટે અને તમારા પોતાના inheritance-aware static methods લખવા માટે જે subclasses સાથે યોગ્ય રીતે કાર્ય કરે।
જો કે અધ્ययનનું વધુ advance topic છે, તે subtle bugs અને confusion નો સામાન્ય સ્ત્રોત છે ("આ શા માટે parent class return કરી રહ્યો છે?"), અને self::/static::/parent:: તફાવત સમજવું PHP ના object model અને inheritance behavior ના ગહન જ્ઞાન દર્શાવે છે — જે static-method-based, inheritance-heavy APIs સાથે કાર્ય કરવા અને બનાવવા માટે મૂલ્યવાન જે modern PHP frameworks માં સામાન્ય છે।
વિગતવાર જવાબો સાથે IT ઇન્ટરવ્યૂ પ્રશ્નોની લાઇબ્રેરી — જુનિયરથી સિનિયર સુધી.
દાન કરો