PHP में :: (डबल कॉलन) और -> (तीर) के बीच क्या अंतर है?

Question

PHP में विधियों तक पहुंचने के दो अलग-अलग तरीके हैं, लेकिन क्या अंतर है?

$response->setParameter('foo', 'bar'); 

और

sfConfig::set('foo', 'bar'); 

मैं यह सोचते हैं रहा हूँ -> (साइन इन करें या शेवरॉन से अधिक के साथ पानी का छींटा) चर के लिए कार्यों के लिए प्रयोग किया जाता है, और :: (डबल कोलन) कक्षाओं के लिए कार्यों के लिए प्रयोग किया जाता है। सही बात?

=> असाइनमेंट ऑपरेटर केवल एक सरणी के भीतर डेटा असाइन करने के लिए उपयोग किया जाता है? क्या यह = असाइनमेंट ऑपरेटर के विपरीत है जिसका प्रयोग चर को त्वरित या संशोधित करने के लिए किया जाता है?

Answer 1

जब बायां हिस्सा एक ऑब्जेक्ट उदाहरण है, तो आप -> का उपयोग करते हैं। अन्यथा, आप :: का उपयोग करें।

इसका मतलब है कि -> ज्यादातर, उदाहरण के सदस्यों तक पहुँचने के लिए प्रयोग किया जाता है, जबकि :: आमतौर पर स्थिर सदस्यों तक पहुँचने के लिए (प्रयोग किया जाता है (हालांकि यह भी स्थिर सदस्यों, इस तरह के उपयोग को हतोत्साहित किया जाता का उपयोग करने के लिए इस्तेमाल किया जा सकता है), हालांकि कुछ विशेष मामलों में, इसका उपयोग उदाहरण सदस्यों तक पहुंचने के लिए किया जाता है)।

सामान्य तौर पर, ::scope resolution के लिए प्रयोग किया जाता है, और यह या तो एक वर्ग के नाम, parent, self, या (पीएचपी 5.3 में), उसके बाईं ओर static हो सकता है। parent उस वर्ग के सुपरक्लास के दायरे को संदर्भित करता है जहां इसका उपयोग किया जाता है; self उस वर्ग के दायरे को संदर्भित करता है जहां इसका उपयोग किया जाता है; static "कॉल स्कोप" को संदर्भित करता है (late static bindings देखें)।

नियम है कि :: के साथ एक कॉल एक उदाहरण कॉल है यदि और केवल यदि:

• लक्ष्य विधि स्थिर और
• वहाँ समय में एक संगत वस्तु संदर्भ है के रूप में घोषित नहीं किया गया है कॉल की, इन अर्थ सच होना चाहिए:
  1. कॉल एक संदर्भ में, जहां $this मौजूद है से बनाया गया है और
  2. $this की कक्षा या तो उस विधि का वर्ग है जिसे इसके नाम या उप-वर्ग कहा जाता है।

उदाहरण:

class A { 
    public function func_instance() { 
     echo "in ", __METHOD__, "\n"; 
    } 
    public function callDynamic() { 
     echo "in ", __METHOD__, "\n"; 
     B::dyn(); 
    } 

} 

class B extends A { 
    public static $prop_static = 'B::$prop_static value'; 
    public $prop_instance = 'B::$prop_instance value'; 

    public function func_instance() { 
     echo "in ", __METHOD__, "\n"; 
     /* this is one exception where :: is required to access an 
     * instance member. 
     * The super implementation of func_instance is being 
     * accessed here */ 
     parent::func_instance(); 
     A::func_instance(); //same as the statement above 
    } 

    public static function func_static() { 
     echo "in ", __METHOD__, "\n"; 
    } 

    public function __call($name, $arguments) { 
     echo "in dynamic $name (__call)", "\n"; 
    } 

    public static function __callStatic($name, $arguments) { 
     echo "in dynamic $name (__callStatic)", "\n"; 
    } 

} 

echo 'B::$prop_static: ', B::$prop_static, "\n"; 
echo 'B::func_static(): ', B::func_static(), "\n"; 
$a = new A; 
$b = new B; 
echo '$b->prop_instance: ', $b->prop_instance, "\n"; 
//not recommended (static method called as instance method): 
echo '$b->func_static(): ', $b->func_static(), "\n"; 

echo '$b->func_instance():', "\n", $b->func_instance(), "\n"; 

/* This is more tricky 
* in the first case, a static call is made because $this is an 
* instance of A, so B::dyn() is a method of an incompatible class 
*/ 
echo '$a->dyn():', "\n", $a->callDynamic(), "\n"; 
/* in this case, an instance call is made because $this is an 
* instance of B (despite the fact we are in a method of A), so 
* B::dyn() is a method of a compatible class (namely, it's the 
* same class as the object's) 
*/ 
echo '$b->dyn():', "\n", $b->callDynamic(), "\n"; 

आउटपुट:

 
B::$prop_static: B::$prop_static value 
B::func_static(): in B::func_static 

$b->prop_instance: B::$prop_instance value 
$b->func_static(): in B::func_static 

$b->func_instance(): 
in B::func_instance 
in A::func_instance 
in A::func_instance 

$a->dyn(): 
in A::callDynamic 
in dynamic dyn (__callStatic) 

$b->dyn(): 
in A::callDynamic 
in dynamic dyn (__call) 

Answer 2

=> ऑपरेटर एक साहचर्य सरणी में कुंजी-मान जोड़ों आवंटित करने के लिए प्रयोग किया जाता है।उदाहरण के लिए:

$fruits = array(
    'Apple' => 'Red', 
    'Banana' => 'Yellow' 
); 

यह अर्थ foreach बयान में समान है:

foreach ($fruits as $fruit => $color) 
    echo "$fruit is $color in color."; 

Answer 3

::, स्थिर संदर्भ में प्रयोग किया जाता है अर्थात्। जब कुछ विधि या संपत्ति स्थिर के रूप में घोषित किया जाता है:

class Math { 
    public static function sin($angle) { 
     return ...; 
    } 
} 

$result = Math::sin(123); 

इसके अलावा, :: ऑपरेटर (स्कोप संकल्प ऑपरेटर, उर्फ ​​Paamayim Nekudotayim) गतिशील संदर्भ में प्रयोग किया जाता है जब आप एक माता पिता के वर्ग की एक विधि/संपत्ति आह्वान:

class Rectangle { 
    protected $x, $y; 

    public function __construct($x, $y) { 
     $this->x = $x; 
     $this->y = $y; 
    } 
} 

class Square extends Rectangle { 
    public function __construct($x) { 
     parent::__construct($x, $x); 
    } 
} 

->गतिशील संदर्भ में उपयोग किया जाता है, यानी। जब आप कुछ वर्ग के कुछ उदाहरण के साथ सौदा:

class Hello { 
    public function say() { 
     echo 'hello!'; 
    } 
} 

$h = new Hello(); 
$h->say(); 

वैसे: मुझे नहीं लगता कि Symfony का उपयोग कर एक अच्छा विचार है कि आप किसी भी OOP अनुभव की जरूरत नहीं है जब है।

Answer 4

स्थिर और instantiated तरीकों और गुण के बीच का अंतर है जो हिब्रू से Paamayim Nekudotayim कहा जाता है बस पीएचपी 5.

डबल पेट के ऑपरेटर (में OOP PHP के साथ शुरू कर उन लोगों के लिए सबसे बड़ी बाधाओं में से एक होने लगते हैं - ट्रिविया) का उपयोग किसी ऑब्जेक्ट या प्रॉपर्टी को स्थिर संदर्भ से कॉल करते समय किया जाता है। इसका मतलब है कि ऑब्जेक्ट का एक उदाहरण अभी तक नहीं बनाया गया है।

तीर ऑपरेटर, इसके विपरीत, ऑब्जेक्ट के उदाहरण के संदर्भ से विधियों या गुणों को कॉल करता है।

स्थिर तरीके विशेष रूप से ऑब्जेक्ट मॉडल में उपयोगी हो सकते हैं जो डेटाबेस बनाने और विधियों को हटाने के लिए डेटाबेस से जुड़े होते हैं, क्योंकि आप वापसी मूल्य आईडी पर वापसी मान सेट कर सकते हैं और फिर पंक्ति आईडी द्वारा ऑब्जेक्ट को तुरंत चालू करने के लिए कन्स्ट्रक्टर का उपयोग कर सकते हैं ।

Answer 5

हां, मैंने बस अपना पहला 'PHP Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM' मारा। मेरा बुरा, मेरे पास $instance::method() था जो $instance->method() होना चाहिए था। मुझे मूर्ख।

अजीब बात यह है कि यह अभी भी मेरी स्थानीय मशीन (PHP 5.3.8 चल रहा है) पर ठीक काम करता है - कुछ भी नहीं, error_reporting = E_ALL के साथ चेतावनी भी नहीं - लेकिन परीक्षण सर्वर पर बिल्कुल नहीं, वहां बस विस्फोट एक वाक्यविन्यास त्रुटि और ब्राउज़र में एक सफेद स्क्रीन के साथ। चूंकि परीक्षण मशीन पर PHP लॉगिंग बंद कर दी गई थी, और होस्टिंग कंपनी इसे चालू करने में बहुत व्यस्त थी, यह बहुत स्पष्ट नहीं थी।

तो, चेतावनी का शब्द: जाहिर है, कुछ PHP इंस्टॉलेशन आपको $ example :: method() का उपयोग करने देगा, जबकि अन्य नहीं।

यदि कोई भी विस्तार कर सकता है, तो कृपया ऐसा करें।

Answer 6

असल में इस संकेत से हम एक वर्ग विधि है कि स्थिर और नहीं अन्य आरंभीकरण पर निर्भर होना कॉल कर सकते हैं ...

class Test { 

    public $name; 

    public function __construct() { 
     $this->name = 'Mrinmoy Ghoshal'; 
    } 

    public static function doWrite($name) { 
     print 'Hello '.$name; 
    } 

    public function write() { 
     print $this->name; 
    } 
} 

यहाँ doWrite() फ़ंक्शन किसी भी अन्य विधि या चर पर निर्भर नहीं है, और यह एक स्थिर विधि है।यही कारण है कि हम इस वर्ग के ऑब्जेक्ट को शुरू किए बिना इस विधि को इस ऑपरेटर द्वारा क्यों कॉल कर सकते हैं।

Test::doWrite('Mrinmoy'); // Output: Hello Mrinmoy.

लेकिन अगर आप इस तरह से write विधि कॉल करना चाहते हैं, यह एक त्रुटि उत्पन्न होगा, क्योंकि यह आरंभीकरण पर निर्भर है।