Parsing PHP's self keyword

Someone in the PHP group asked about the usage of the self keyword. The answer is relatively obvious: this cannot be used in static member functions to call non- Member functions, 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 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

and parent, static and this

If you want to completely understand self, to be distinguished from parent, static and this. Comparisons are made below. The distinction between

parent

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

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 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, 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, dynamically pointing to the function of the calling class. The three keywords

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

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;
is used for static member functions /For variable access,
2. is recommended to use self instead of $this:: or $this->;
To access non-static member variables,
3. self cannot be used, only this;
4. this must be used when the object has already been Used when instantiating, self does not have this restriction;
is used within non-static member functions,
5. self suppresses polymorphic behavior and refers to functions 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 above three keywords, 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, 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. this needs 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 call self:: 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. self in static functions and non-static functions. Guess what the result is? They are all string(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 Tutorial column 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!