Was genau sind späte statische Bindungen in PHP?

Question

Was genau sind späte statische Bindungen in PHP?

Answer 1

Ab PHP 5.3.0 implementiert PHP eine Funktion späten statische Bindung genannt, die verwendet werden können, die gerufene Klasse im Rahmen der statischen Erbe zu verweisen.

Die späte statische Bindung versucht, diese Einschränkung zu lösen, indem ein Schlüsselwort eingeführt wird, das auf die Klasse verweist, die ursprünglich zur Laufzeit aufgerufen wurde. Es wurde entschieden, kein neues Schlüsselwort einzuführen, sondern static zu verwenden, das bereits reserviert war.

Nehmen wir ein Beispiel sehen:

<?php 
    class Car 
    { 
     public static function run() 
     { 
      return static::getName(); 
     } 

     private static function getName() 
     { 
      return 'Car'; 
     } 
    } 

    class Toyota extends Car 
    { 
     public static function getName() 
     { 
      return 'Toyota'; 
     } 
    } 

    echo Car::run(); // Output: Car 
    echo Toyota::run(); // Output: Toyota 
?> 

late static bindings Arbeit durch die Klasse in der letzten „Nicht-Anrufweiterschaltung“ genannt zu speichern. Im Fall von statischen Methodenaufrufen ist dies die Klasse, die explizit benannt wird (normalerweise die links vom Operator ::); Bei nicht statischen Methodenaufrufen ist dies die Klasse des Objekts.

A "forwarding Call" ist eine statische eine, die von self:: eingeführt wird, parent::, static:: oder, wenn in der Klassenhierarchie steigen, forward_static_call().

Die Funktion get_called_class() kann verwendet werden, um eine Zeichenfolge mit dem Namen der aufgerufenen Klasse abzurufen, und static:: führt ihren Bereich ein.

Answer 2

Sie müssen unbedingt Late Static Bindings im PHP-Handbuch lesen. Ich werde jedoch versuchen, Ihnen eine kurze Zusammenfassung zu geben.

Grundsätzlich läuft es darauf hinaus, dass das Schlüsselwort self nicht den Regeln der Vererbung folgt. self wird immer in die Klasse aufgelöst, in der es verwendet wird. Dies bedeutet, dass self nicht wie erwartet auf das untergeordnete Element verweist, wenn Sie eine Methode in einer übergeordneten Klasse erstellen und von einer untergeordneten Klasse aufrufen.

Späte statische Bindung führt eine neue Verwendung für das Schlüsselwort static ein, das diesen besonderen Mangel behebt. Wenn Sie static verwenden, stellt es die Klasse dar, in der Sie es zuerst verwenden, dh. Es "bindet" an die Laufzeitklasse.

Das sind die zwei grundlegenden Konzepte dahinter. Die Art und Weise self, parent und static funktionieren, wenn static im Spiel ist, kann subtil sein, also lieber als ins Detail gehen, würde ich stark empfehlen, dass Sie die Beispiele der Handbuchseite studieren. Sobald Sie die Grundlagen jedes Keywords verstanden haben, sind die Beispiele sehr wichtig, um zu sehen, welche Art von Ergebnissen Sie erhalten werden.

Answer 3

Zum Beispiel:

abstract class Builder { 
    public static function build() { 
     return new static; 
    } 
} 

class Member extends Builder { 
    public function who_am_i() { 
     echo 'Member'; 
    } 
} 

Member::build()->who_am_i(); 

Answer 4

ist es nicht sehr offensichtlich Verhalten:

Der folgende Code erzeugt 'alpha'.

class alpha { 

    function classname(){ 
     return __CLASS__; 
    } 

    function selfname(){ 
     return self::classname(); 
    } 

    function staticname(){ 
     return static::classname(); 
    } 
} 

class beta extends alpha { 

    function classname(){ 
     return __CLASS__; 
    } 
} 

$beta = new beta(); 
echo $beta->selfname(); // Output: alpha 
echo $beta->staticname(); // Output: beta 

Wenn wir jedoch die Erklärung der Funktion Klassennamen aus der Beta-Klasse zu entfernen, erhalten wir ‚alphaalpha‘ als Ergebnis.

Answer 5

Ich zitiere aus dem Buch: "PHP Master schreiben topaktuellen Code".

Späte statische Bindung wurde mit php 5.3 eingeführt. Es ermöglicht uns, statische Methoden von einer übergeordneten Klasse zu erben und die untergeordnete Klasse zu referenzieren, die aufgerufen wird.

Dies bedeutet, dass Sie eine abstrakte Klasse mit statischen Methoden haben können, und Referenz der konkreten Implementierungen des Kindes Klasse mit der statischen :: Methode() Notation anstelle der Selbst :: Methode().

Fühlen Sie sich frei als auch einen Blick auf die offizielle PHP-Dokumentation zu nehmen: http://php.net/manual/en/language.oop5.late-static-bindings.php

Beispiel:

<?php 
class Animal { 
    public static function StaticCall() { 
     // Parent object invokes its own getAnimalName() 
     // Child object invokes its own getAnimalName() instead of parent's getAnimalName() 
     return static::getAnimalName(); 
    } 

    public static function SelfCall() { 
     return self::getWeight(); 
    } 

    private static function getAnimalName(){ 
     return 'Animal <br />'; 
    } 

    private static function getWeight(){ 
     return '10 kg <br />'; 
    } 
} 

class Bird extends Animal { 
    public static function getAnimalName(){ 
     return 'Bird <br />'; 
    } 

    private static function getWeight(){ 
     return '2 kg <br />'; 
    } 
} 

echo Animal::StaticCall(); // Animal  
echo Animal::SelfCall(); // 10 kg   
echo Bird::StaticCall(); // Bird invokes method from own object 
echo Bird::SelfCall();  // 10 kg invokes method from parent 

In dem obigen Code Sie zwei Klassen Animal sehen kann, die die Elternklasse ist und Bird welches die Kindklasse ist. Sowohl Animal als auch Bird haben eine getAnimalName() und getWeight() Methode. Die Oberklasse Animal hat zwei Methoden: StaticCall() und SelfCall().

Die Methode StaticCall() ruft getAnimalName() auf, indem das Schlüsselwort static verwendet wird.
Die Methode SelfCall() ruft getWeight() mit dem Schlüsselwort self auf.

Die Frage, die wir jetzt haben, ist: in welchem ​​Kontext ist getAnimalName() ausgeführt?

Die Antwort: static::getAnimalName() identifiziert den Kontext und ruft die Methode in diesem Kontext auf.

Wenn Sie Bird::StaticCall() aufrufen, wird der Code StaticCall() ausgeführt, der in Animal ist. Dann ruft static::getAnimalName() die Methode getAnimalName() von Bird auf und führt sie aus.

Dies unterscheidet sich von self::, weil self:: immer self die Methode in dem Objekt aufruft, ist definiert in. Also, wenn self::getWeight()SelfCall() in Objekt Animal in Methode definiert ist und Bird::SelfCall() dann getWeight()self::getWeight() ruft im Rahmen des Animal Objekt aufgerufen werden würde .

Answer 6

Betrachten Sie es von einem "warum sollte ich das verwenden?" Perspektive, es ist im Grunde eine Möglichkeit, den Kontext zu ändern, aus dem die statische Methode interpretiert/ausgeführt wird.

Mit self ist der Kontext derjenige, in dem Sie ursprünglich die Methode definiert haben. Mit static ist es derjenige, von dem Sie es anrufen.

Answer 7

Das einfachste Beispiel, um den Unterschied zu zeigen.
Hinweis, self :: $ c

class A 
{ 
    static $c = 7; 

    public static function getVal() 
    { 
     return self::$c; 
    } 
} 

class B extends A 
{ 
    static $c = 8; 
} 

B::getVal(); // 7 

Späte statische Bindung, beachten Sie statische :: $ c

class A 
{ 
    static $c = 7; 

    public static function getVal() 
    { 
     return static::$c; 
    } 
} 

class B extends A 
{ 
    static $c = 8; 
} 

B::getVal(); // 8