The difference in usage of this self static in PHP

This article mainly introduces the difference between this self static in PHP. The editor thinks it is quite good. Now I will share it with you and give it as a reference. Let’s follow the editor and take a look.

INTRODUCTION

I was doing software engineering course design recently, and I encountered a problem. I went to pick up the Laravel source code and searched again, and found that it was a self static Problems arise because of poor understanding, so record them to avoid making the same mistakes again.

Text

this

this is easier to understand. It points to the current object and is used to access the non-static variables and non-static methods of the current object. It is related to the object. ;

<?php
class Person {
    public $name;    
    
    public function getName() {
        echo $this->name;
    }
}

$p = new Person();
$p2 = new Person();
$p->name = "小红";
$p2->name = "小明";
$p->getName();  // 小红
$p2->getName();  // 小明

In the above example, two objects are new and the name attributes of the objects are set respectively. This is used in getName() to access the name attribute of the current object, so the name values ​​are output respectively. Therefore, this points to the current object and does not point to other objects or classes.

self

self is different from this. It points to the class itself and does not point to any instantiated object. It is generally used to access static variables and static methods in the class;

<?php
class Person {
    public static $name = "小红";    
    
    public static function getName() {
        echo self::$name;
    }
}

$p = new Person();
$p2 = new Person();
$p::getName();  // 小红
$p2::getName();  // 小红
$p::$name = "小明";
$p::getName();  // 小明
$p2::getName();  // 小明

In the above example, two objects are new, and the name attribute of one object is modified. The name attribute value of the other object is also changed. Therefore, self points to the current class and has nothing to do with the object. All objects share one value. .

static

static is the same as self, both point to the class, and are generally used to access static variables and static methods in the class, but there are some differences. Specifically: self writes In which class, this class is actually called; static is written in the parent class, and then this static is used through the subclass. This static points to this subclass, which is officially called Late static binding .

<?phpclass A {
    public function say() {
        echo "Hello";
    }    
    
    public function saySelf() {
        self::say();
    }    
    
    public function sayStatic() {
        static::say();
    }
}

class B extends A {
    public function say() {
        echo "World";
    }
}

$b = new B();
$b->say();  // World
$b->saySelf();  // Hello
$b->sayStatic();  // World

As you can see from the above example, self is written in class A, and it points to class A when called. static is also written in class A, but it is called with an object of class B, a subclass of class A. When it is used, it points to class B. When it is used, static determines which class it points to. This is late static binding.

Late static binding

Summary

this points to the current object, used to access the non-static variables and non-static methods of the current object;
self points to the class, generally Used to access static variables and static methods of the current class, which class it points to has been determined before running;
static points to the class, generally used to access static variables and static methods of the current class, but is not limited to A static call determines which class it points to at runtime.

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