What is the usage of self in laravel

In laravel, the self keyword is used to replace the class name. It can refer to static member variables and static functions of the current class. It is also used to suppress polymorphic behavior. It can refer to functions of the current class instead of subclasses. Overridden implementation, self always points to the current class and class instance.

#The operating environment of this article: Windows 10 system, Laravel version 6, Dell G3 computer.

What is the usage of self in laravel

You cannot use this to call non-member functions within a static member function, but you can use self to call static members Function/variable/constant; 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 fully understand self , should 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 hidden method (or variable) of the base class, 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

static The 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 it is related to self It 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 difference between the two is as follows:

1. this cannot be used in static member functions, self can;
for static member functions /For variable access, it is recommended to use
2. self instead of $this:: or $this->;
is not To access static member variables,
3. self cannot be used, only this;
4. this must be used when the object has been instantiated. , self does not have this restriction;
is used within a non-static member function,
5. self suppresses polymorphic behavior and refers to the function of the current class; and this Reference the override 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)". The details are:

1. Replace the class name, refer to the static member variables and static functions of the current class;
2. Suppress polymorphic behavior, refer to the functions of the current class instead of the overridden implementation in the subclass;

groove point

1. Among these keywords, only this needs to be added with the $ symbol and must be added. Obsessive-compulsive disorder means it is very uncomfortable. ;
2. Non-static member functions cannot be called through $this-> in static member functions, but they can be called through self:: and are not included in the calling function. It can still run smoothly when using $this->. This behavior seems to behave differently in different PHP versions. It is ok in the current 7.3;
3. is output in static functions and non-static functions self. Guess what the result is? Both are string(4) "self", confusing output;
4. return $this instanceof static::class; There will be syntax errors, but the following two The normal way to write it is:
   $class = static::class;
   return $this instanceof $class;
   // Or like this:
   return $this instanceof static;

[Related recommendations: laravel video tutorial]

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