Detailed explanation of the self keyword in PHP

Analysis of PHP’s self keyword

Someone in the PHP group asked about the usage of the self keyword, and the answer was comparison Obvious:

You cannot use this to call non-member functions in a static member 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 deepened, I found 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.

If you want to completely understand self, you must distinguish it from parent, static, and this.

The following are comparisons

parent

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

The general purpose of static is to modify functions or variables to make them class functions 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 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 members Function, 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:

this cannot be used in static member functions, self Yes;

For access to static member functions/variables, it is recommended to use self instead of $this:: or $this->;

For access to non-static member variables, You cannot use self, only this;

This must be used when the object has been instantiated, self has no such restriction;

When used within a non-static member function, self suppresses polymorphism Behavior refers to the function of the current class; and this refers to the overriding function of the calling class (if any).

The purpose of self

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

In detail:

Replace the class name and reference the static member variables and static functions of the current class;

Suppress polymorphic behavior and reference The function of the current class rather than the implementation covered in the subclass;

slot

Among these keywords, only This needs to be added with the $ sign and must be added. Obsessive-compulsive disorder means it is very uncomfortable;

Non-static member functions cannot be called through $this-> in static member functions, but they can be called through self::, and before calling the function It can still run smoothly without using $this->. This behavior seems to behave differently in different PHP versions, but it is ok in the current 7.3;

在静态函数和非静态函数中输出self，猜猜结果是什么？都是string(4) "self"，迷之输出；

return $this instanceof static::class;会有语法错误，但是以下两种写法就正常：
$class = static::class;
return $this instanceof $class;
// 或者这样：
return $this instanceof static;

所以这是为什么啊？！

$class = static::class;

return $this instanceof $class;

// 或者这样：

return $this instanceof static;

推荐教程：《PHP视频教程》

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