Learn about the self keyword in PHP

This article mainly introduces you to the relevant knowledge about the self keyword in PHP. The article introduces it in detail through sample code and has certain reference value. Friends in need can refer to it. I hope it will be helpful to everyone.

Preface

Someone asked about the usage of the self keyword, and the answer is relatively obvious: static members You cannot use this to call non-member functions within a function, but you can use self to call static member functions/variables/constants; other member functions can use self to call static member functions and non-static member functions. As the discussion deepens, it is discovered that self is not that simple. In view of this, this article first compares and differentiates several keywords, and then summarizes the usage of self.

The difference between parent, static and this

If you want to fully understand self, you must understand it with parent, static and this differentiate. Comparisons are made below.

parent

The distinction between self and parent is relatively easy: parent refers to the hidden method (or variable) of the parent class/base class, and self refers to Self 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

static is generally used to modify functions or variables to make them class functions and class variables. You can also modify variables within a function to extend their life cycle to the life cycle of the entire application. But its association with self is 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 self and static is: for static member functions, self points to the current class of the code, and static points to the calling class; for non-static member functions, self suppresses polymorphism , points to the member function of the current class, static is equivalent to this, and dynamic points to the function of the calling class.

The three keywords parent, self, and static are very interesting when combined together. They point to the parent class, current class, and subclass respectively, which has a bit of a "past, present, and future" flavor.

this

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

1. this cannot be used in static member functions, self can;
2. For accessing static member functions/variables, it is recommended to use self instead of $ this:: or $this-> form;
3. To access non-static member variables, self cannot be used, only this;
4. this must be instantiated when the object has been When used under, self does not have this restriction;
5. is used within a non-static member function, self suppresses polymorphic behavior and refers to the function of the current class; and this refers to the override function of the calling class (if any talk).

The purpose of self

After reading the differences from the above three keywords, is the purpose of self immediately obvious? To sum up in one sentence, that is: self always points to "the current class (and class instance)". In detail, it is:

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

slot

1. Among these keywords, only this needs to be added The $ symbol must be added, obsessive-compulsive disorder means it is very uncomfortable;
2. Static member functions cannot call non-static member functions through $this->, but they can be called through self:: and are not used in the calling function It can still run smoothly even if $this-> is used. This behavior seems to behave differently in different PHP versions. It is ok in the current 7.3;
3. Output self in static functions and non-static functions. Guess what the result is? They are all string(4) "self", the output of the mystery;
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? !

Recommended learning: PHP video tutorial

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