php - बच्चों को गणित कैसे सिखाए




$ $ से अधिक का उपयोग कब करें? (14)

यहां $ $ के सही उपयोग और गैर स्थैतिक और स्थैतिक सदस्य चर के लिए स्वयं का एक उदाहरण दिया गया है:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo $this->non_static_member . ' '
           . self::$static_member;
    }
}

new X();
?> 

PHP 5 में, self और $this का उपयोग करने के बीच क्या अंतर है?

प्रत्येक उपयुक्त कब है?


संक्षिप्त जवाब

वर्तमान ऑब्जेक्ट को संदर्भित करने के लिए $this उपयोग करें। वर्तमान वर्ग को संदर्भित करने के लिए self का प्रयोग करें। दूसरे शब्दों में, गैर-स्थैतिक सदस्यों के लिए $this->member उपयोग करें, स्थिर सदस्यों के लिए self::$member उपयोग करें।

पूरा उत्तर

यहां $this के सही उपयोग और गैर स्थैतिक और स्थैतिक सदस्य चर के लिए self का एक उदाहरण दिया गया है:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo $this->non_static_member . ' '
           . self::$static_member;
    }
}

new X();
?>

यहां $this के गलत उपयोग और गैर स्थैतिक और स्थैतिक सदस्य चर के लिए self का एक उदाहरण दिया गया है:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo self::$non_static_member . ' '
           . $this->static_member;
    }
}

new X();
?>

यहां सदस्य कार्यों के लिए $this 1.2 के साथ बहुरूपता का एक उदाहरण दिया गया है:

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        $this->foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

सदस्य कार्यों के लिए self का उपयोग करके पॉलिमॉर्फिक व्यवहार को दबाने का एक उदाहरण यहां दिया गया है:

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        self::foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

विचार यह है कि $this->foo() जो भी> foo() सदस्य फ़ंक्शन को कॉल करता है> वर्तमान ऑब्जेक्ट का सटीक प्रकार है। यदि ऑब्जेक्ट type X , तो इस प्रकार> X::foo() कॉल करता है। यदि ऑब्जेक्ट type Y , तो यह Y::foo() कॉल करता है। लेकिन साथ> self :: foo (), X::foo() हमेशा कहा जाता है।

http://www.phpbuilder.com/board/showthread.php?t=10354489 :

http://board.phpbuilder.com/member.php?145249-laserlight द्वारा


कक्षा परिभाषा के अंदर, $ यह वर्तमान वस्तु को संदर्भित करता है, जबकि स्वयं वर्तमान वर्ग को संदर्भित करता है।

स्वयं का उपयोग करके कक्षा तत्व को संदर्भित करना आवश्यक है, और इसका उपयोग करके ऑब्जेक्ट तत्व का संदर्भ लें।

self::STAT // refer to a constant value
self::$stat // static variable
$this->stat // refer to an object variable  

कीवर्ड स्वयं केवल 'वर्तमान वर्ग' को संदर्भित नहीं करता है, कम से कम इस तरह से नहीं है जो आपको स्थिर सदस्यों को प्रतिबंधित करता है। एक गैर स्थैतिक सदस्य के संदर्भ में, self वर्तमान वस्तु के लिए vtable ( vtable पर विकी देखें ) को छोड़ने का एक तरीका भी प्रदान करता है। जैसे ही आप किसी फ़ंक्शन के माता-पिता संस्करण को कॉल करने के लिए parent::methodName() का उपयोग कर सकते हैं, ताकि आप एक विधि के वर्तमान वर्ग कार्यान्वयन को कॉल करने के लिए self::methodName() को कॉल कर सकें।

class Person {
    private $name;

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

    public function getName() {
        return $this->name;
    }

    public function getTitle() {
        return $this->getName()." the person";
    }

    public function sayHello() {
        echo "Hello, I'm ".$this->getTitle()."<br/>";
    }

    public function sayGoodbye() {
        echo "Goodbye from ".self::getTitle()."<br/>";
    }
}

class Geek extends Person {
    public function __construct($name) {
        parent::__construct($name);
    }

    public function getTitle() {
        return $this->getName()." the geek";
    }
}

$geekObj = new Geek("Ludwig");
$geekObj->sayHello();
$geekObj->sayGoodbye();

यह आउटपुट होगा:

हैलो, मैं geek लुडविग हूँ
व्यक्ति लुडविग से अलविदा

sayHello() $this पॉइंटर का उपयोग करता है, इसलिए Geek::getTitle() को कॉल करने के लिए बुलाया जाता है। sayGoodbye() self::getTitle() sayGoodbye() का उपयोग करता है, इसलिए vtable का उपयोग नहीं किया जाता है, और Person::getTitle() को कॉल किया जाता है। दोनों मामलों में, हम एक तत्काल वस्तु की विधि से निपट रहे हैं, और $this सूचक को कॉल किए गए कार्यों के भीतर $this पॉइंट तक पहुंच है।


जैसा कि यहां कोई भी प्रदर्शन के बारे में बात नहीं करता है, यहां मैंने एक छोटा बेंचमार्क किया है (5.6):

 Name     | Time    | Percent  
----------|---------|---------  
 $this->  | 0.99163 | 106.23%  
 self::   | 0.96912 | 103.82%  
 static:: | 0.93348 | 100%

वे 2 000 000 रन के परिणाम हैं, और यहां कोड का उपयोग किया गया है:

<?php

require '../vendor/autoload.php';

// My small class to do benchmarks
// All it does is looping over every test x times and record the
//   time it takes using `microtime(true)`
// Then, the percentage is calculated, with 100% being the quickest
// Times are being rouned for outputting only, not to calculate the percentages
$b = new Tleb\Benchmark\Benchmark(2000000);

class Foo
{
    public function calling_this()
    {
        $this->called();
    }

    public function calling_self()
    {
        self::called();
    }

    public function calling_static()
    {
        static::called();
    }

    public static function called()
    {
    }
}

$b->add('$this->',  function () { $foo = new Foo; $foo->calling_this(); });
$b->add('self::',   function () { $foo = new Foo; $foo->calling_self(); });
$b->add('static::', function () { $foo = new Foo; $foo->calling_static(); });

$b->run();

मेरा मानना ​​है कि प्रश्न यह नहीं था कि क्या आप कक्षा ClassName::staticMember को कॉल करके कक्षा के स्थिर सदस्य को कॉल कर सकते हैं। सवाल यह था कि self::classmember और $this->classmember self::classmember का उपयोग करने के बीच क्या अंतर है।

उदाहरण के लिए, निम्न दोनों उदाहरण बिना किसी त्रुटि के काम करते हैं, भले ही आप self:: या $this->

class Person{
    private $name;
    private $address;

    public function __construct($new_name,$new_address){
        $this->name = $new_name;
        $this->address = $new_address;
    }
}

class Person{
    private $name;
    private $address;
    public function __construct($new_name,$new_address){
        self::$name = $new_name;
        self::$address = $new_address;
    }
}

http://www.php.net/manual/en/language.oop5.static.php अनुसार कोई $self । कक्षा (वस्तु), और स्वयं के वर्तमान उदाहरण का जिक्र करने के लिए केवल $this , जिसका उपयोग कक्षा के स्थिर सदस्यों को संदर्भित करने के लिए किया जा सकता है। ऑब्जेक्ट इंस्टेंस और क्लास के बीच का अंतर यहां खेलता है।


इस ब्लॉग पोस्ट से :

  • self वर्तमान वर्ग को संदर्भित करता है
  • self स्थिर कार्यों और संदर्भ स्थिर सदस्य चर को संदर्भित करने के लिए self का उपयोग किया जा सकता है
  • self स्थिर कार्यों के अंदर इस्तेमाल किया जा सकता है
  • self vtable को छोड़कर polymorphic व्यवहार भी बंद कर सकते हैं
  • $this वर्तमान वस्तु को संदर्भित करता है
  • $this स्थिर कार्यों को कॉल करने के लिए इस्तेमाल किया जा सकता है
  • $this स्थिर सदस्य चर कॉल करने के लिए इस्तेमाल नहीं किया जाना चाहिए। इसके बजाए self प्रयोग करें।
  • $this स्थिर कार्यों के अंदर इस्तेमाल नहीं किया जा सकता है

$this refers to the current class object, self refers to the current class (Not object). The class is the blueprint of the object. So you define a class, but you construct objects.

So in other words, use self for static and this for none-static members or methods .

also in child/parent scenario self / parent is mostly used to identified child and parent class members and methods.


self ($ स्वयं नहीं) वर्ग के प्रकार को संदर्भित करता है, जहां $this वर्ग के वर्तमान उदाहरण को संदर्भित करता है। self स्थिर सदस्य चरों में उपयोग के लिए self को स्थिर सदस्य चरों तक पहुंचने की अनुमति देता है। $this गैर स्थैतिक सदस्य कार्यों में उपयोग किया जाता है, और उस वर्ग के उदाहरण का संदर्भ है जिस पर सदस्य कार्य कहा जाता था।

क्योंकि this एक वस्तु है, आप इसे इस तरह उपयोग करते हैं: $this->member

क्योंकि self एक वस्तु नहीं है, यह मूल रूप से एक प्रकार है जो स्वचालित रूप से वर्तमान वर्ग को संदर्भित करता है, आप इसका उपयोग करते हैं: self::member


self:: उपयोग न करें self:: static::

आत्म :: का एक और पहलू है जो उल्लेखनीय है। कष्टप्रद self:: निष्पादन के बिंदु पर परिभाषा के बिंदु पर दायरे को संदर्भित करता है । दो सरल तरीकों से इस सरल वर्ग पर विचार करें:

class Person
{

    public static function status()
    {
        self::getStatus();
    }

    protected static function getStatus()
    {
        echo "Person is alive";
    }

}

अगर हम Person::status() कॉल करते हैं तो हम देखेंगे "व्यक्ति जीवित है"। अब विचार करें कि क्या होता है जब हम उस वर्ग को प्राप्त करते हैं जो इस से प्राप्त होता है:

class Deceased extends Person
{

    protected static function getStatus()
    {
        echo "Person is deceased";
    }

}

कॉलिंग Deceased::status() हम "व्यक्ति मर चुके हैं" को देखने की उम्मीद करेंगे, हालांकि हम जो देखते हैं वह "व्यक्ति जीवित है" क्योंकि स्कोप में मूल विधि परिभाषा होती है जब self::getStatus() को परिभाषित किया गया था।

PHP 5.3 में एक समाधान है। static:: रिज़ॉल्यूशन ऑपरेटर "देर से स्थिर बाध्यकारी" लागू करता है जो कहने का एक शानदार तरीका है कि इसे कक्षा के दायरे से बंधे हुए हैं। status() में status() को static::getStatus() में बदलें और परिणाम आप अपेक्षा करेंगे। PHP के पुराने संस्करणों में आपको ऐसा करने के लिए एक क्लज खोजना होगा।

PHP दस्तावेज़ीकरण देखें

इसलिए सवाल का जवाब देने के लिए नहीं ...

$this-> वर्तमान वस्तु (कक्षा का एक उदाहरण) को संदर्भित करता है, जबकि static:: एक वर्ग को संदर्भित करता है


Additionally since $this:: has not been discussed yet.

For informational purposes only, as of PHP 5.3 when dealing with instantiated objects to get the current scope value, as opposed to using static:: , one can alternatively use $this:: like so.

http://ideone.com/7etRHy

class Foo
{
    const NAME = 'Foo';

    //Always Foo::NAME (Foo) due to self
    protected static $staticName = self::NAME;

    public function __construct()
    {
        echo $this::NAME;
    }

    public function getStaticName()
    {
       echo $this::$staticName;
    }
}

class Bar extends Foo
{
    const NAME = 'FooBar';

    /**
     * override getStaticName to output Bar::NAME
     */
    public function getStaticName()
    {
        $this::$staticName = $this::NAME;
        parent::getStaticName();
    }
}

$foo = new Foo; //outputs Foo
$bar = new Bar; //outputs FooBar
$foo->getStaticName(); //outputs Foo
$bar->getStaticName(); //outputs FooBar
$foo->getStaticName(); //outputs FooBar

Using the code above is not common or recommended practice, but is simply to illustrate its usage, and is to act as more of a "Did you know?" in reference to the original poster's question.

It also represents the usage of $object::CONSTANT for example echo $foo::NAME; as opposed to $this::NAME;


Use self if you want to call a method of a class without creating an object/instance of that class, thus saving RAM (sometimes use self for that purpose). In other words, it is actually calling a method statically. Use this for object perspective.


Php.net के अनुसार इस संदर्भ में तीन विशेष कीवर्ड होते हैं: self, parentऔर static। वे कक्षा परिभाषा के अंदर से गुणों या विधियों तक पहुंचने के लिए उपयोग किया जाता है।

$this दूसरी ओर, किसी भी वर्ग के उदाहरण और विधियों को कॉल करने के लिए उपयोग किया जाता है जब तक वह कक्षा सुलभ हो।





scope