Detaillierte Erläuterung der Definition und Anwendungsbeispiele der poststatischen PHP-Bindung

Originaltext des Handbuchs: Seit PHP 5.3.0 hat PHP eine Funktion namens „späte statische Bindung“ hinzugefügt, als Referenz innerhalb der Vererbungsbereichsklassen die statisch aufgerufen werden.

Das Arbeitsprinzip der späten statischen Bindung besteht darin, den Klassennamen des vorherigen „Nicht-Weiterleitungsaufrufs“ zu speichern. Bei einem statischen Methodenaufruf ist der Klassenname der explizit angegebene (normalerweise auf der linken Seite des ::-Operators); bei einem nicht statischen Methodenaufruf ist es die Klasse, zu der das Objekt gehört. 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, und static:: weist auf deren Gültigkeitsbereich hin.

Diese Funktion wird aus sprachinterner Sicht als „späte statische Bindung“ bezeichnet. „Späte Bindung“ bedeutet, dass static:: nicht mehr in die Klasse aufgelöst wird, in der die aktuelle Methode definiert ist, sondern zur tatsächlichen Laufzeit berechnet wird. Es kann auch als „statische Bindung“ bezeichnet werden, da es für Aufrufe statischer Methoden verwendet werden kann (aber nicht darauf beschränkt ist).

Einschränkungen von self::

Verwenden Sie self:: oder __CLASS__ für einen statischen Verweis auf die aktuelle Klasse, abhängig von der Klasse, in der die aktuelle Methode definiert ist:

Beispiel #1 selbst:: Verwendung

<?php
class A {
public static function who() {
echo __CLASS__;
}
public static function test() {
self::who();
}
}
class B extends A {
public static function who() {
echo __CLASS__;
}
}
B::test();
?>

Die obige Routine gibt Folgendes aus:

A

Späte statische Bindung Die Verwendung der späten statischen Bindung sollte die Einschränkung umgehen, indem ein neues Schlüsselwort eingeführt wurde, das die Klasse darstellt, die ursprünglich von der Laufzeit aufgerufen wurde. Einfach ausgedrückt ermöglicht Ihnen dieses Schlüsselwort, beim Aufruf von test() im obigen Beispiel auf Klasse B statt auf Klasse A zu verweisen. Es wurde schließlich beschlossen, keine neuen Schlüsselwörter einzuführen, sondern das bereits reservierte statische Schlüsselwort zu verwenden.

Beispiel #2 statisch:: Einfache Verwendung

<?php
class A {
public static function who() {
echo __CLASS__;
}
public static function test() {
static::who(); // 后期静态绑定从这里开始
}
}
class B extends A {
public static function who() {
echo __CLASS__;
}
}
B::test();
?>

Die obige Routine gibt Folgendes aus:

B

Hinweis: In einer nicht statischen Umgebung ist die aufgerufene Klasse die Klasse, zu der die Objektinstanz gehört. Da $this-> versucht, die private Methode im selben Bereich aufzurufen, kann static:: zu unterschiedlichen Ergebnissen führen. Ein weiterer Unterschied besteht darin, dass static:: nur mit statischen Eigenschaften verwendet werden kann.

Beispiel #3 Verwendung von static::

<?php
class A {
private function foo() {
echo "success!\n";
}
public function test() {
$this->foo();
static::foo();
}
}
class B extends A {
/* foo() will be copied to B, hence its scope will still be A and
* the call be successful */
}
class C extends A {
private function foo() {
/* original method is replaced; the scope of the new one is C */
}
}
$b = new B();
$b->test();
$c = new C();
$c->test(); //fails
?>

in einer nicht statischen Umgebung Die obige Routine gibt Folgendes aus:

success !
Erfolg!
Erfolg!
Schwerwiegender Fehler: Aufruf der privaten Methode C::foo() aus Kontext „A“ in /tmp/test.php in Zeile 9

Hinweis: Die späte statische Bindungsauflösung wird fortgesetzt, bis ein vollständig aufgelöster statischer Aufruf erhalten wird. Bei einem statischen Aufruf mit parent:: oder self:: werden die Aufrufinformationen hingegen weitergeleitet.

Beispiel #4 Anrufe weiterleiten und nicht weiterleiten

<?php
class 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();
}
public static function who() {
echo __CLASS__."\n";
}
}
class C extends B {
public static function who() {
echo __CLASS__."\n";
}
}
C::test();
?>

Die obige Routine gibt Folgendes aus:

A
C
C

Das folgende Beispiel analysiert eine Klasse, die auf statische Aufrufe im Vererbungsbereich verweist, basierend auf der späten statischen Bindungsfunktion von PHP.

Schauen Sie sich zunächst den folgenden Code an:

class Person
{
public static function status()
{
self::getStatus();
}
protected static function getStatus()
{
echo "Person is alive";
}
}
class Deceased extends Person
{
protected static function getStatus()
{
echo "Person is deceased";
}
}
Deceased::status(); //Person is alive

Offensichtlich ist das Ergebnis nicht das, was wir erwartet haben. Dies liegt daran, dass self:: davon abhängt, wo Es ist eine Klasse, nicht die laufende Klasse. Um dieses Problem zu lösen, können Sie die Methode status() in der geerbten Klasse überschreiben. Eine bessere Lösung besteht darin, dass PHP 5.3 die Funktion der späten statischen Bindung hinzugefügt hat.

Der Code lautet wie folgt:

class Person
{
public static function status()
{
static::getStatus();
}
protected static function getStatus()
{
echo "Person is alive";
}
}
class Deceased extends Person
{
protected static function getStatus()
{
echo "Person is deceased";
}
}
Deceased::status(); //Person is deceased

Es ist ersichtlich, dass static:: nicht mehr auf die aktuelle Klasse verweist wird während des Betriebs berechnet. Erzwingt den Erhalt aller Eigenschaften der endgültigen Klasse.

Daher wird empfohlen, self:: in Zukunft nicht mehr zu verwenden und static:: zu verwenden.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Definition und Anwendungsbeispiele der poststatischen PHP-Bindung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!