Was ist der Unterschied zwischen self :: $ bar und static :: $ bar in PHP?

Was ist der Unterschied zwischen selfund staticim folgenden Beispiel?

class Foo
{
    protected static $bar = 1234;

    public static function instance()
    {
        echo self::$bar;
        echo "\n";
        echo static::$bar;
    }

}

Foo::instance();

produziert

1234
1234

Wenn Sie selfauf ein Klassenmitglied verweisen, beziehen Sie sich auf die Klasse, in der Sie das Schlüsselwort verwenden. In diesem Fall Foodefiniert Ihre Klasse eine geschützte statische Eigenschaft namens $bar. Wenn Sie selfin der FooKlasse auf die Eigenschaft verweisen, verweisen Sie auf dieselbe Klasse.

Wenn Sie also versuchen, eine andere Klasse self::$barin Ihrer FooKlasse zu verwenden, aber eine BarKlasse mit einem anderen Wert für die Eigenschaft haben, wird diese Foo::$baranstelle von verwendet Bar::$bar, was möglicherweise nicht das ist, was Sie beabsichtigen:

class Foo
{
    protected static $bar = 1234;
}

class Bar extends Foo
{
    protected static $bar = 4321;
}

Wenn Sie eine Methode über aufrufen , rufenstatic Sie eine Funktion auf, die als späte statische Bindungen bezeichnet wird (eingeführt in PHP 5.3).

Im obigen Szenario führt die Verwendung selfzu Foo::$bar(1234). Und using staticführt zu Bar::$bar(4321), da mit staticmit der Interpreter die Neudeklaration innerhalb der BarKlasse zur Laufzeit berücksichtigt wird .

Normalerweise verwenden Sie späte statische Bindungen für Methoden oder sogar die Klasse selbst anstelle von Eigenschaften, da Sie Eigenschaften in Unterklassen nicht häufig neu deklarieren. Ein Beispiel für die Verwendung des staticSchlüsselworts zum Aufrufen eines spät gebundenen Konstruktors finden Sie in dieser verwandten Frage: New self vs. new static

Dies schließt jedoch auch die Verwendung staticmit Eigenschaften nicht aus .

Wie bereits erwähnt, besteht einer der Hauptunterschiede darin, staticdass späte statische Bindungen möglich sind. Eines der nützlichsten Szenarien, das ich gefunden habe, war das Erstellen von Basisklassen für Singleton-Klassen:

class A { // Base Class
    protected static $name = '';
    protected static function getName() {
        return static::$name;
    }
}
class B extends A {
    protected static $name = 'MyCustomNameB';
}
class C extends A {
    protected static $name = 'MyCustomNameC';
}

echo B::getName(); // MyCustomNameB
echo C::getName(); // MyCustomNameC

Bei Verwendung return static::$namein der Basisklasse wird zurückgegeben, was statisch angehängt war, als es erweitert wurde. Wenn Sie sind verwenden , return self::$namedann B::getName()würde eine leere Zeichenfolge zurück , wie das ist , was in der Basisklasse deklariert wird.

Mit selfAnruf:

class Foo
{
    protected static $var = 123;
    
    public function getVar()
    {
        return self::$var;
    }
}

class Bar extends Foo
{
    protected static $var = 234;
}

// Displays: "123"
echo (new Bar)->getVar();

Sie können oben sehen, obwohl wir das $varmit unserer BarKlasse überschrieben haben , wird es dennoch zurückgegeben 123, da wir PHP explizit nach der selfVariablen gefragt haben , die wiederum nach der Variablen Foos fragt .

Wenn wir nun den Anruf mit tauschen static, erhalten wir stattdessen den Barüberschriebenen Wert:

Mit staticAnruf:

class Foo
{
    protected static $var = 123;
    
    public function getVar()
    {
        return static::$var;
    }
}

class Bar extends Foo
{
    protected static $var = 234;
}

// Displays: "234"
echo (new Bar)->getVar();