Späte PHP-Bindung

Der Inhalt dieses Artikels ist PHP-Post-Bindung. Jetzt teile ich ihn mit allen. Freunde in Not können sich auch auf diesen Artikel beziehen.

PHP-Post-Bindung

Seit PHP 5.3.0 hat PHP eine Funktion namens „späte statische Bindung“ hinzugefügt, die verwendet wird, um

statisch aufgerufene Klassen im Vererbungsbereich zu referenzieren.

Um genau zu sein, besteht das Arbeitsprinzip der späten statischen Bindung darin, die Daten im vorherigen „nicht weiterleitenden Aufruf“ (nicht weiterleitend
) zu speichern Anruf) Klassenname. Bei einem statischen Methodenaufruf ist der Klassenname der explizit angegebene (normalerweise in ::
). Operator); bei einem nicht statischen Methodenaufruf ist es die Klasse, zu der das Objekt gehört. Der sogenannte „Weiterleitungsanruf“ (Weiterleitung
call) bezieht sich auf statische Aufrufe über die folgenden Methoden: self::, parent::, static:: und
forward_static_call(). Sie können die Funktion get_claimed_class() verwenden, um den Klassennamen der aufgerufenen Methode, static::
, abzurufen weist auf seinen Umfang hin.

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

self

Verwenden Sie self:: oder CLASS einen statischen Verweis auf die aktuelle Klasse, je nachdem, wo sich die aktuelle befindet Methode ist Klasse definiert:

Beispiel #1 self:: Verwendung

<?phpclass 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(); //输出A?>

statische Verwendung der späten statischen Bindung

Die späte statische Bindung sollte durch die Einführung von a erfolgen Das neue Schlüsselwort stellt die Klasse dar, die die Laufzeit zunächst aufruft, um die Einschränkung zu umgehen. 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.

<?phpclass 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();  //输出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 gleichen Bereich aufzurufen, während static::
kann zu unterschiedlichen Ergebnissen führen. Ein weiterer Unterschied besteht darin, dass static:: nur mit statischen Eigenschaften verwendet werden kann.

Verwenden Sie static::

<?phpclass 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:

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

Die Auflösung der späten statischen Bindung 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.

Anrufe weiterleiten und nicht weiterleiten

<?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();
    }    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

Verwandte Empfehlungen:

Spätes Binden in PHP

Denken Sie über das Problem des späten Bindens von PHP nach

Das obige ist der detaillierte Inhalt vonSpäte PHP-Bindung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!