Detailed explanation of PHP's self keyword

Someone in the PHP group asked about the usage of the self keyword. The answer is relatively obvious:

You cannot use this to call non-member functions in a static member function, but you can use self calls 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.

Differences from parent, static and this

If you want to fully 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 hidden method of the parent class/base class ( or variable), self refers to its own method (or variable).

For example, the parent class constructor is called 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. They can also be modified. Variables within a function 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. Recommended: "PHP Tutorial"

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 result is as follows:

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

In function references, self and static The difference 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 and 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 can;

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

For access to non-static member variables, self cannot be used, only this;

this should be used when the object has been instantiated, self does not have this restriction;

is used in non-static member functions, self suppresses polymorphic behavior and refers to the function of the current class; while this refers to the calling class's heavy function Override the function (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 refer to the static member variables and static functions of the current class;

Suppress polymorphic behavior and refer to the functions of the current class instead of Implementation covered in subclasses;

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 they 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;

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;

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 That is why ah? !

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

For more PHP related knowledge, please visit PHP Chinese website!

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