Der Inhalt, der in diesem Artikel mit Ihnen geteilt wird, befasst sich mit den Unterschieden zwischen self, static und $this in PHP und der detaillierten Erklärung der späten statischen Bindung. Freunde in Not können sich darauf beziehen
Der Unterschied zwischen self, static und $this
Um den Unterschied zwischen self, static und $this besser zu verstehen Schauen wir uns zunächst ein Beispiel an.
<?phpclass A { protected $name = 'A'; static $alias = 'a'; const HASH = 'md5'; public function dd() { echo $this->name; echo '--'; echo static::$alias; echo '--'; // 后期静态绑定
echo static::HASH; echo '--'; // 后期静态绑定
echo self::$alias; echo '--'; echo self::HASH; echo '--';
var_dump(new self); echo '--';
var_dump($this); echo '--';
var_dump(new static); echo '<br>'; // 后期静态绑定
} public static function who() { echo __CLASS__; echo ' [ This is A ]'; echo '<br>';
} public static function test() { self::who();
} public static function test2() { static::who(); // 后期静态绑定
} public static function getInstance() {
var_dump(new self); echo '--';
var_dump(new static); echo '<br>'; // 后期静态绑定
}
}class B extends A { protected $name = 'B'; static $alias = 'b'; const HASH = 'sha1'; public static function who() { echo __CLASS__; echo ' [ This is B ]'; echo '<br>';
}
}class C extends B { public static function who() { echo __CLASS__; echo ' [ This is C]'; echo '<br>';
}
}
(new A)->dd(); // A--a--md5--a--md5--object(A)#2 (1) { ["name":protected]=> string(1) "A" } --object(A)#1 (1) { ["name":protected]=> string(1) "A" } --object(A)#2 (1) { ["name":protected]=> string(1) "A" }(new B)->dd(); // B--b--sha1--a--md5--object(A)#2 (1) { ["name":protected]=> string(1) "A" } --object(B)#1 (1) { ["name":protected]=> string(1) "B" } --object(B)#2 (1) { ["name":protected]=> string(1) "B" }A::who(); // A [ This is A ]B::who(); // B [ This is B ]A::test(); // A [ This is A ]B::test(); // A [ This is A ]A::test2(); // A [ This is A ]B::test2(); // B [ This is B ]C::test2(); // C [ This is C]A::getInstance(); // object(A)#1 (1) { ["name":protected]=> string(1) "A" } --object(A)#1 (1) { ["name":protected]=> string(1) "A" }B::getInstance(); // object(A)#1 (1) { ["name":protected]=> string(1) "A" } --object(B)#1 (1) { ["name":protected]=> string(1) "B" }Nach dem Login kopieren
Zusammenfassung:
- self und __CLASS__ sind statische Verweise auf die aktuelle Klasse, abhängig davon, wo die aktuelle Methode in der Klasse definiert ist. Mit anderen Worten: Die Klasse, in der das Selbst geschrieben ist, ist diejenige, auf die es sich bezieht.
- $this zeigt auf das Objekt, wenn es tatsächlich aufgerufen wird. Das heißt, wer auch immer die Eigenschaften oder Methoden der Klasse während des eigentlichen laufenden Prozesses aufruft, $this zeigt auf das Objekt . Aber $this kann nicht auf statische Eigenschaften und Konstanten der Klasse zugreifen und $this kann nicht in statischen Methoden existieren.
- Neben der Deklaration statischer Mitglieder (Eigenschaften und Methoden) einer Klasse spielt das Schlüsselwort static auch eine sehr wichtige Rolle bei der späten statischen Bindung.
- self kann verwendet werden, um auf statische Eigenschaften, statische Methoden und Konstanten einer Klasse zuzugreifen, self verweist jedoch auf die Klasse, in der es aktuell definiert ist, was eine Einschränkung von self darstellt.
- Das Objekt, auf das $this zeigt, gehört zur gleichen Klasse wie die Klasse, auf die static zeigt.
- static kann in statischen oder nicht statischen Methoden verwendet werden und kann auch auf statische Eigenschaften, statische Methoden, Konstanten und nicht statische Methoden der Klasse zugreifen, jedoch nicht auf nicht statische Eigenschaften.
- Beim statischen Aufruf zeigt statisch auf die Klasse, die tatsächlich aufgerufen wird; bei nichtstatischem Aufruf zeigt statisch auf die Klasse, zu der das Objekt tatsächlich aufgerufen wird.
Späte statische Bindung
Die späte statische Bindung (auch verzögerte statische Bindung genannt) kann verwendet werden, um statisch aufgerufene Klassen im Vererbungsbereich, also Code, zu referenzieren Die Klasse das zunächst zur Laufzeit aufgerufen wird.
Die spätere statische Bindung sollte ursprünglich durch die Einführung eines neuen Schlüsselworts ausgedrückt werden, aber am Ende wurde das statische Schlüsselwort verwendet.
工作原理
确切地说，static 后期静态绑定的工作原理是存储了上一个非转发调用（non-forwarding call）的类名。
当进行静态方法调用时，该类名（static指向的类名）为明确指定的那个（通常是 :: 运算符的左侧部分），即实际调用时的类。
如上述示例中的：
A::test2(); B::test2();
Nach dem Login kopieren
static 和 self 的区别：
当进行非静态方法调用时，该类名（static指向的类名）为该对象所属的类，即实际调用时的对象所属的类。
如上述示例中的：
(new A)->dd();
(new B)->dd();
Nach dem Login kopieren
static 和 $this 有点类似，但又有区别：
$this 指向的对象所属的类和 static 指向的类相同。
$this 不能用于静态方法中，也不能访问类的静态属性和常量。
$this 指向的是实际调用的对象。
static 可以用于静态或非静态方法中，也可以访问类的静态属性、静态方法、常量和非静态方法，但不能访问非静态属性。
static 指向的是实际调用时的对象所属的类。
Aufruf weiterleiten
Der sogenannte Weiterleitungsaufruf bezieht sich auf statische Aufrufe, die auf folgende Weise erfolgen: self::, parent::, static:: und forward_static_call().
Sie können die Funktion get_claimed_class() verwenden, um den Klassennamen der aufgerufenen Methode abzurufen.
Die folgenden vier Formen von Anrufen sind alle Weiterleitungsanrufe:
self::
-
parent::
static::
forward_static_call()
Andere Anrufe als dieser sind Anrufe ohne Weiterleitung.
Nicht weiterleitender Anruf (nicht weiterleitender Anruf)
Die späte statische Bindung funktioniert durch Speichern des vorherigen nicht weiterleitenden Anrufs (nicht weiterleiten). Anruf) Klassenname.
Aufrufe über bestimmte Klassennamen oder bestimmte Objekte sind nicht weitergeleitete Anrufe.
Zum Beispiel:
A::test2();
B::test2();
(new A)->dd();
(new B)->dd();
Nach dem Login kopieren
注意事项
非静态环境下的私有方法的查找顺序
在非静态环境下，在类的非静态方法中，使用 $this 和 static 调用类的私有方法时，执行方式有所不同。
具体来说，$this 会先到所在定义范围内寻找私有方法，再到它指向的对象所属的类中寻找私有方法，然后寻找公有方法，最后到所在定义范围内寻找公共方法。只要找到了匹配的方法，就调用，并停止查找。
而 static 则是先到它指向的类中寻找私有方法，再寻找共有方法；然后到所在定义范围内寻找私有方法，再寻找共有方法。只要找到了匹配的方法，就调用，并停止查找。
下面是一个例子：
<?php
class A { private function foo () {
var_dump($this); echo '--';
var_dump(new static); echo '--'; echo __CLASS__; echo '--'; echo get_called_class(); echo '<br>';
} public function test () { $this -> foo (); static:: foo (); echo '<br>';
}
}class B extends A { }class C extends A { private function foo () { echo 'this is C';
}
}
(new B())->test();
(new C())->test();Nach dem Login kopieren
输出结果为：
object(B)#1 (0) { } --object(B)#2 (0) { } --A--B
object(B)#1 (0) { } --object(B)#2 (0) { } --A--B
object(C)#1 (0) { } --object(C)#2 (0) { } --A--C
Fatal error: Uncaught Error: Call to private method C::foo() from context 'A'Nach dem Login kopieren
关于后期静态绑定的解析
后期静态绑定的解析会一直到取得一个完全解析了的静态调用为止。如果静态调用使用了 parent:: 或者 self:: 等转发调用的形式，将会转发调用信息。
<?phpclass A { public static function foo () { static:: who ();
} public static function who () { echo __CLASS__ . "\n" ;
}
}class B extends A { public static function test () {
A :: foo (); parent :: foo (); self :: foo (); static::foo();
forward_static_call(['A', 'foo']); echo '<br>';
} public static function who () { echo __CLASS__ . "\n" ;
}
}class C extends B { public static function who () { echo __CLASS__ . "\n" ;
} public static function test2() { self::test();
}
}class D extends C { public static function who () { echo __CLASS__ . "\n" ;
}
}
B::foo();
B::test();
C::foo();
C::test();
D::foo();
D::test2();Nach dem Login kopieren
以上的输出结果为：
B A B B B B
C A C C C C D A D D D D
Nach dem Login kopieren
static 后期静态绑定的工作原理是存储了上一个非转发调用（non-forwarding call）的类名。请记住这句话。
下面的例子是非转发调用。
A::foo(); // 输出 AB::foo(); // 输出 BC::foo(); // 输出 C
Nach dem Login kopieren
后期静态绑定 static ，是定义在了 foo() 方法中，哪个类通过非转发调用的形式调用 foo() 方法， foo() 方法中的 static 指向的就是哪个类。
但是，如果通过转发调用的形式，调用 foo() 方法，如：
parent :: foo ();self :: foo ();static::foo();forward_static_call(['A', 'foo']);
Nach dem Login kopieren
那么，就以转发调用代码所在的方法 test() 为准，哪个类通过非转发调用的形式调用 test() 方法， foo() 方法中的 static 指向的就是哪个类。
假如调用 test() 方法时，也采用了转发调用的形式，如：
public static function test2() { self::test();
}Nach dem Login kopieren
那么，就以 test2() 方法为准 ... 依次类推。
也就是说，在使用了后期静态绑定的基类中，后期静态绑定所在的方法如果被转发调用，则 static 的指向，会一直向上追溯，直到遇到非转发调用的形式。
相关推荐：
php中const与static的区别与使用
Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung der Unterschiede zwischen self, static, $this und später statischer Bindung in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
