Parsing PHP’s self keyword

Someone in the PHP group asked about the usage of theselfkeyword. The answer is relatively obvious:thiscannot be used in static member functions to call non- Member functions, but you can useselfto call static member functions/variables/constants; other member functions can useselfto call static member functions and non-static member functions. As the discussion deepened, I discovered thatselfis not that simple. In view of this, this article first compares and differentiates several keywords, and then summarizes the usage ofself. The difference between

andparent,staticandthis

If you want to completely understandself, to be distinguished fromparent,staticandthis. Comparisons are made below. The distinction between

parent

##selfandparentis relatively easy:parentrefers to the parent class/ The method (or variable) of the base class is hidden, andselfrefers to its own method (or variable). For example, calling the parent class constructor in the constructor:

class Base { public function __construct() { echo "Base contructor!", PHP_EOL; } } class Child { public function __construct() { parent::__construct(); echo "Child contructor!", PHP_EOL; } } new Child; // 输出： // Base contructor! // Child contructor!

static

staticThe general purpose is to modify the function or variable to make it a class function and Class variables can also modify variables within functions to extend their life cycle to the life cycle of the entire application. But its association withselfis a new use introduced since PHP 5.3: static delayed binding.

With the static delayed binding function of

static, the belonging class can be dynamically determined at runtime. For example:

class Base { public function __construct() { echo "Base constructor!", PHP_EOL; } public static function getSelf() { return new self(); } public static function getInstance() { return new static(); } public function selfFoo() { return self::foo(); } public function staticFoo() { return static::foo(); } public function thisFoo() { return $this->foo(); } public function foo() { echo "Base Foo!", PHP_EOL; } } class Child extends Base { public function __construct() { echo "Child constructor!", PHP_EOL; } public function foo() { echo "Child Foo!", PHP_EOL; } } $base = Child::getSelf(); $child = Child::getInstance(); $child->selfFoo(); $child->staticFoo(); $child->thisFoo();

The program output is as follows:

Base constructor! Child constructor! Base Foo! Child Foo! Child Foo!

In terms of function references, the difference between

selfandstaticis: for static member functions,selfpoints to the current class of the code,staticpoints to the calling class; for non-static member functions,selfsuppresses polymorphism and points to the member function of the current class,staticis equivalent tothis, dynamically pointing to the function of the calling class. The three keywords

parent,self, andstaticare very interesting to look at together, pointing to the parent class, current class, and subclass respectively. , a bit like "past, present, future".

this

selfandthisare the most discussed combinations and are also the most likely to be misused. The main differences between the two are as follows:

1. thiscannot be used in static member functions,selfcan;
is used for static member functions /For variable access,
2. is recommendedto useselfinstead of$this::or$this->;
To access non-static member variables,
3. selfcannot be used, onlythis;
4. thismust be used when the object has already been Used when instantiating,selfdoes not have this restriction;
is used within non-static member functions,
5. selfsuppresses polymorphic behavior and refers to functions of the current class; Andthisrefers to the overriding function of the calling class (if any).

The purpose of self

After reading the differences between the above three keywords, is the purpose of

selfimmediately apparent? ? To sum up in one sentence, that is:selfalways points to "the current class (and class instance)". In detail, it is:

Replace the class name and refer to the static member variables and static functions of the current class;
1. Suppress polymorphic behavior and refer to the functions of the current class instead of subclasses Implementation of coverage;

slot

among these keywords, only
1. thisneeds to be added with the$symbol and Must be added, obsessive-compulsive disorder means it is very uncomfortable;
Static member functions cannot call non-static member functions through
2. $this->, but they can callself::Call, and it can still run smoothly without using$this->in the calling function. This behavior seems to behave differently in different PHP versions. It is ok in the current 7.3;
outputs
3. selfin static functions and non-static functions. Guess what the result is? They are allstring(4) "self", confusing output;

4. return $this instanceof static::class;There will be syntax errors, but The following two ways of writing are normal:

   $class = static::class; return $this instanceof $class; // 或者这样： return $this instanceof static;

   So why is this? !

For more PHP related technical articles, please visit the

PHP Tutorialcolumn to learn!

The above is the detailed content of Parsing PHP’s self keyword. For more information, please follow other related articles on the PHP Chinese website!