PHP में देर से स्थिर बाइंडिंग क्या हैं?




late-binding late-static-binding (6)

इसे देखकर "मैं इसका उपयोग क्यों करूं?" परिप्रेक्ष्य, यह मूल रूप से उस संदर्भ को बदलने का एक तरीका है जिससे स्थैतिक विधि का अर्थ / चलाया जा रहा है।

self साथ, संदर्भ वह है जहां आपने मूल रूप से विधि को परिभाषित किया था। static साथ, यह वह है जिसे आप इसे बुला रहे हैं।

PHP में देर से स्थिर बाइंडिंग क्या हैं?


आपको निश्चित रूप से PHP मैनुअल में लेट स्टेटिक बाइंडिंग पढ़ने की जरूरत है। हालांकि, मैं आपको एक त्वरित सारांश देने की कोशिश करूंगा।

असल में, यह इस तथ्य को उबालता है कि self कीवर्ड विरासत के समान नियमों का पालन नहीं करता है। self हमेशा उस वर्ग को हल करता है जिसमें इसका उपयोग किया जाता है। इसका मतलब यह है कि यदि आप अभिभावक वर्ग में कोई विधि बनाते हैं और उसे बाल वर्ग से कॉल करते हैं, तो self बच्चे को संदर्भित नहीं करेगा जैसा आप उम्मीद कर सकते हैं।

देर स्थिर बाध्यकारी static कीवर्ड के लिए एक नया उपयोग प्रस्तुत करता है, जो इस विशेष कमी को संबोधित करता है। जब आप static उपयोग करते हैं, तो यह उस वर्ग का प्रतिनिधित्व करता है जहां आप इसे पहले इस्तेमाल करते हैं, यानी। यह रनटाइम कक्षा में 'बांधता है'।

वे इसके पीछे दो बुनियादी अवधारणाएं हैं। जिस तरह से static खेल में है, self , parent - parent और static तरीके से सूक्ष्म हो सकता है, इसलिए अधिक विस्तार से जाने के बजाय, मैं दृढ़ता से अनुशंसा करता हूं कि आप मैन्युअल पृष्ठ उदाहरणों का अध्ययन करें। एक बार जब आप प्रत्येक कीवर्ड की मूल बातें समझ लेते हैं, तो उदाहरण यह देखने के लिए आवश्यक हैं कि आप किस प्रकार के परिणाम प्राप्त करने जा रहे हैं।


उदाहरण के लिए:

abstract class Builder {
    public static function build() {
        return new static;
    }
}

class Member extends Builder {
    public function who_am_i() {
         echo 'Member';
    }
}

Member::build()->who_am_i();

बहुत स्पष्ट व्यवहार नहीं है:

निम्नलिखित कोड 'अल्फाबेटा' उत्पन्न करता है।

class alpha {

    function classname(){
        return __CLASS__;
    }

    function selfname(){
        return self::classname();
    }

    function staticname(){
        return static::classname();
    }
}

class beta extends alpha {

    function classname(){
        return __CLASS__;
    }
}

$beta = new beta();
echo $beta->selfname(); // Output: alpha
echo $beta->staticname(); // Output: beta

हालांकि, अगर हम बीटा कक्षा से क्लासनाम फ़ंक्शन की घोषणा को हटा देते हैं, तो हमें परिणाम के रूप में 'अल्फालाफा' मिलता है।


अंतर दिखाने के लिए सबसे सरल उदाहरण।
नोट, स्वयं :: $ सी

class A
{
    static $c = 7;

    public static function getVal()
    {
        return self::$c;
    }
}

class B extends A
{
    static $c = 8;
}

B::getVal(); // 7

देर स्थिर बाध्यकारी, नोट स्थिर :: $ सी

class A
{
    static $c = 7;

    public static function getVal()
    {
        return static::$c;
    }
}

class B extends A
{
    static $c = 8;
}

B::getVal(); // 8

मैं पुस्तक से उद्धृत कर रहा हूं: "PHP मास्टर अत्याधुनिक कोड लिखते हैं"।

देर स्थिर बाध्यकारी php 5.3 के साथ पेश की गई एक विशेषता थी। यह हमें अभिभावक वर्ग से स्थैतिक तरीकों का वारिस करने और बाल वर्ग के संदर्भ में संदर्भित करने की अनुमति देता है।

इसका मतलब है कि आप स्थैतिक तरीकों के साथ एक अमूर्त वर्ग प्राप्त कर सकते हैं, और स्वयं :: विधि () के बजाय स्थिर :: विधि () नोटेशन का उपयोग करके बाल वर्ग के ठोस कार्यान्वयन का संदर्भ ले सकते हैं।

आधिकारिक PHP दस्तावेज़ों को भी देखने के लिए स्वतंत्र महसूस करें: http://php.net/manual/en/language.oop5.late-static-bindings.php

उदाहरण:

<?php
class Animal {
    public static function StaticCall() {
        // Parent object invokes its own getAnimalName()
        // Child object invokes its own getAnimalName() instead of parent's getAnimalName()
        return static::getAnimalName(); 
    }

    public static function SelfCall() {
        return self::getWeight();
    }

    private static function getAnimalName(){
        return 'Animal <br />';
    }

    private static function getWeight(){
        return '10 kg <br />';
    }
}

class Bird extends Animal  {
    public static function getAnimalName(){
        return 'Bird <br />';
    }

    private static function getWeight(){
        return '2 kg <br />';
    }
}

echo Animal::StaticCall(); // Animal       
echo Animal::SelfCall();   // 10 kg        
echo Bird::StaticCall();   // Bird    invokes method from own object
echo Bird::SelfCall();     // 10 kg   invokes method from parent

उपर्युक्त कोड में आप दो कक्षाएं देख सकते हैं Animal जो मूल वर्ग और Bird जो बाल वर्ग है। Animal और Bird दोनों को getWeight() और getWeight() विधि getWeight()StaticCall() Animal में दो विधियां हैं: StaticCall() और SelfCall()

विधि StaticCall() static कीवर्ड का उपयोग कर getAnimalName() को आमंत्रित करता है।
विधि SelfCall() self कीवर्ड का उपयोग कर SelfCall() आमंत्रित करती है।

अब हमारे पास सवाल यह है: किस संदर्भ में getAnimalName() निष्पादित किया गया है?

उत्तर: static::getAnimalName() संदर्भ की पहचान करता है और उस संदर्भ के भीतर विधि को आमंत्रित करता है।

यदि आप Bird::StaticCall() का आह्वान करते हैं तो कोड StaticCall() को निष्पादित करेगा जो कि Animal । फिर static::getAnimalName() विधि को प्राप्त करने के लिए विधि से निष्पादित और निष्पादित getAnimalName()

यह self:: से भिन्न होता है, क्योंकि self:: ऑब्जेक्ट self भीतर विधि को हमेशा आमंत्रित करता है। इसलिए यदि self::getWeight() को ऑब्जेक्ट में परिभाषित किया गया है तो विधि में Animal SelfCall() और Bird::SelfCall() होगा जिसे तब self::getWeight() कहा जाता है self::getWeight() getWeight() ऑब्जेक्ट के संदर्भ में self::getWeight() आमंत्रित करता है।





late-static-binding