Detaillierte Erläuterung der Analyse und Anwendung der späten statischen PHP-Bindung

Dieser Artikel fasst die relevanten Wissenspunkte der statischen Bindungsanalyse und -anwendung in der späten Phase von PHP zusammen. Freunde, die daran interessiert sind, können es lernen.

Grundkenntnisse

1. Bereichsanalyseoperator (::)

• kann für den Zugriff auf statische Mitglieder und Klassenkonstanten verwendet werden und kann auch zum Überschreiben von Eigenschaften und Methoden in einer Klasse verwendet werden.

• Die drei speziellen Schlüsselwörter self, parent und static werden verwendet, um auf ihre Eigenschaften oder Methoden innerhalb der Klassendefinition zuzugreifen.

• parent wird verwendet, um überschriebene Eigenschaften oder Methoden in der übergeordneten Klasse aufzurufen (wo es erscheint, wird es in die übergeordnete Klasse der entsprechenden Klasse aufgelöst).

• self wird verwendet, um Methoden oder Eigenschaften in dieser Klasse aufzurufen (wo immer es erscheint, wird es in die entsprechende Klasse geparst; beachten Sie den Unterschied zu $this, $this zeigt auf den aktuellen Wert instanziiertes Objekt).

• Wenn eine Unterklasse eine Methode in ihrer übergeordneten Klasse überschreibt, ruft PHP die überschriebene Methode in der übergeordneten Klasse nicht auf. Ob die Methode der übergeordneten Klasse aufgerufen wird, hängt von der untergeordneten Klasse ab.
  

2. Der PHP-Kernel versetzt die Vererbungsimplementierung von Klassen in die „Kompilierungsphase“

<?php
class A{
 const H = &#39;A&#39;;

 const J = &#39;A&#39;;

 static function testSelf(){
  echo self::H; //在编译阶段就确定了 self解析为 A
 }
}

class B extends A{
 const H = "B";

 const J = &#39;B&#39;;

 static function testParent(){
  echo parent::J; //在编译阶段就确定了 parent解析为A
 }

 /* 若重写testSelf则能输出“B”, 且C::testSelf()也是输出“B”
 static function testSelf(){
  echo self::H;
 }
 */

}

class C extends B{
 const H = "C";

 const J = &#39;C&#39;;
}

B::testParent();
B::testSelf();

echo "\n";

C::testParent();
C::testSelf();

Laufergebnis:

AA
AA

Fazit:

selbst:: und parent:: erscheint in der Definition einer bestimmten Klasse X und wird in die entsprechende Klasse X aufgelöst, es sei denn, die Methode der übergeordneten Klasse wird in der Unterklasse überschrieben.

3.Statisches (statisches) Schlüsselwort

Funktion:

- Das statische Schlüsselwort wird verwendet, um Variablen im Funktionskörper Definieren zu ändern statische lokale Variablen.
- Wird zum Deklarieren statischer Mitglieder beim Ändern von Klassenmitgliedsfunktionen und Mitgliedsvariablen verwendet.
- (nach PHP5.3) eine spezielle Klasse, die eine statische verzögerte Bindung vor dem Scope-Resolver darstellt (::).

Beispiel:

Statische lokale Variablen definieren (Vorkommen: in lokalen Funktionen)

Feature: Statische Variablen existieren nur im lokalen Funktionsbereich, aber wenn das Programm Sein Wert geht nicht verloren, wenn die Ausführung diesen Bereich verlässt.

<?php
function test()
{
 static $count = 0;

 $count++;
 echo $count;
 if ($count < 10) {
  test();
 }
 $count--;
}

Statische Methoden und statische Attribute definieren

a) Klassenattribute oder -methoden als statisch deklarieren, Sie müssen nicht instanziieren Die Klasse und der direkte Zugriff.

b) Auf statische Eigenschaften kann nicht über ein Objekt zugegriffen werden, dessen Klasse instanziiert wurde (statische Methoden jedoch schon)

c) Wenn keine Zugriffskontrolle angegeben ist, werden Eigenschaften und Methoden Der Standardwert ist öffentlich.

d) Da statische Methoden keinen Aufruf eines Objekts erfordern, ist die Pseudovariable $this in statischen Methoden nicht verfügbar.

e) Auf statische Eigenschaften kann von Objekten nicht über den ->-Operator zugegriffen werden.

f) Der statische Aufruf einer nicht statischen Methode führt zu einem Fehler auf E_STRICT-Ebene.

g) Wie alle anderen statischen PHP-Variablen können statische Eigenschaften nur als Literale oder Konstanten initialisiert werden, nicht als Ausdrücke. Eine statische Eigenschaft kann also mit einer Ganzzahl oder einem Array initialisiert werden, sie kann jedoch nicht mit einem anderen Variablen- oder Funktionsrückgabewert initialisiert werden und kann auch nicht auf ein Objekt verweisen.

a. Beispiel für eine statische Methode (Vorkommen: Klassenmethodendefinition)

<?php
class Foo {
 public static function aStaticMethod() {
  // ...
 }
}

Foo::aStaticMethod();
$classname = &#39;Foo&#39;;
$classname::aStaticMethod(); // 自PHP 5.3.0后，可以通过变量引用类
?>

b. Beispiel für ein statisches Attribut (Vorkommen: Klassenattributdefinition)

<?php
class Foo
{
 public static $my_static = &#39;foo&#39;;

 public function staticValue() {
  return self::$my_static; //self 即 FOO类
 }
}

class Bar extends Foo
{
 public function fooStatic() {
  return parent::$my_static; //parent 即 FOO类
 }
}

print Foo::$my_static . "\n";

$foo = new Foo();
print $foo->staticValue() . "\n";
print $foo->my_static . "\n";  // Undefined "Property" my_static 

print $foo::$my_static . "\n";
$classname = &#39;Foo&#39;;
print $classname::$my_static . "\n"; // As of PHP 5.3.0

print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() . "\n";
?>

c. Wird für die späte statische Bindung verwendet (Auftritt: in der Methode der Klasse, wird zum Ändern von Variablen oder Methoden verwendet)

Das Folgende ist eine detaillierte Analyse

Späte statische Bindung (späte statische Bindung)

Seit PHP 5.3.0 hat PHP eine Funktion namens Funktion hinzugefügt In letzter Zeit wird die statische Bindung verwendet, um statisch aufgerufene Klassen im Vererbungsbereich zu referenzieren.

1. Weitergeleitete Anrufe und nicht weitergeleitete Anrufe

Weitergeleitete Anrufe:

bezieht sich auf statische Anrufe, die auf folgende Weise getätigt werden: selbst ::, parent::, static:: und forward_static_call().

Nicht weitergeleitete Aufrufe:

Statische Aufrufe, die explizit den Klassennamen angeben (z. B. Foo::foo())

Nicht statische Aufrufe (z. B. $ foo->foo())

2. Arbeitsprinzip der späten statischen Bindung

Prinzip: Speichern Sie das vorherige „non -forwarded“ Klassenname im nicht weiterleitenden Anruf. Das heißt, wenn wir einen statischen Aufruf aufrufen, bei dem es sich um einen Weiterleitungsaufruf handelt, ist die tatsächlich aufgerufene Klasse die Klasse des vorherigen Nicht-Weiterleitungsaufrufs.

Beispielanalyse:

<?php
class A {
 public static function foo() {
  echo __CLASS__."\n";
  static::who();
 }

 public static function who() {
  echo __CLASS__."\n";
 }
}

class B extends A {
 public static function test() {
  echo "A::foo()\n";
  A::foo();
  echo "parent::foo()\n";
  parent::foo();
  echo "self::foo()\n";
  self::foo();
 }

 public static function who() {
  echo __CLASS__."\n";
 }
}

class C extends B {
 public static function who() {
  echo __CLASS__."\n";
 }
}

C::test();

/*
 * C::test(); //非转发调用 ，进入test()调用后，“上一次非转发调用”存储的类名为C
 *
 * //当前的“上一次非转发调用”存储的类名为C
 * public static function test() {
 *  A::foo(); //非转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为A，然后实际执行代码A::foo(), 转 0-0
 *  parent::foo(); //转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为C， 此处的parent解析为A ,转1-0
 *  self::foo(); //转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为C， 此处self解析为B, 转2-0
 * }
 *
 *
 * 0-0
 * //当前的“上一次非转发调用”存储的类名为A
 * public static function foo() {
 *  static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为A， 故实际执行代码A::who(),即static代表A，进入who()调用后，“上一次非转发调用”存储的类名依然为A，因此打印 “A”
 * }
 *
 * 1-0
 * //当前的“上一次非转发调用”存储的类名为C
 * public static function foo() {
 *  static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为C， 故实际执行代码C::who(),即static代表C，进入who()调用后，“上一次非转发调用”存储的类名依然为C，因此打印 “C”

 * }
 *
 * 2-0
 * //当前的“上一次非转发调用”存储的类名为C
 * public static function foo() {
 *  static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为C， 故实际执行代码C::who(),即static代表C，进入who()调用后，“上一次非转发调用”存储的类名依然为C，因此打印 “C”
 * }
 */


故最终结果为：
A::foo()
A
A
parent::foo()
A
C
self::foo()
A
C

3. Weitere Beispiele für statische späte statische Bindung

a) Vergleich von Self, Parent und Static

<?php
class Mango {
 function classname(){
  return __CLASS__;
 }

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

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

class Orange extends Mango {
 function parentname(){
  return parent::classname();
 }

 function classname(){
  return __CLASS__;
 }
}

class Apple extends Orange {
 function parentname(){
  return parent::classname();
 }

 function classname(){
  return __CLASS__;
 }
}

$apple = new Apple();
echo $apple->selfname() . "\n";
echo $apple->parentname() . "\n";
echo $apple->staticname();

?>

运行结果：
Mango
Orange
Apple

b) Verwendung von forward_static_call()

<?php
class Mango
{
 const NAME = &#39;Mango is&#39;;
 public static function fruit() {
  $args = func_get_args();
  echo static::NAME, " " . join(&#39; &#39;, $args) . "\n";
 }
}

class Orange extends Mango
{
 const NAME = &#39;Orange is&#39;;

 public static function fruit() {
  echo self::NAME, "\n";

  forward_static_call(array(&#39;Mango&#39;, &#39;fruit&#39;), &#39;my&#39;, &#39;favorite&#39;, &#39;fruit&#39;);
  forward_static_call(&#39;fruit&#39;, &#39;my&#39;, &#39;father\&#39;s&#39;, &#39;favorite&#39;, &#39;fruit&#39;);
 }
}

Orange::fruit(&#39;NO&#39;);

function fruit() {
 $args = func_get_args();
 echo "Apple is " . join(&#39; &#39;, $args). "\n";
}

?>


运行结果：
Orange is
Orange is my favorite fruit
Apple is my father&#39;s favorite fruit

c) Verwenden Sie get_claimed_class()

<?php


class Mango {
 static public function fruit() {
  echo get_called_class() . "\n";
 }
}

class Orange extends Mango {
 //
}

Mango::fruit();
Orange::fruit();

?>



运行结果：
Mango
Orange

Anwenden

Wie bereits durchgeführt Vorher Wie bereits erwähnt, besteht der Zweck der Einführung einer späten statischen Bindung darin, statisch aufgerufene Klassen im Vererbungsbereich zu referenzieren.
Sie können also die späte statische Bindung verwenden, um das Problem der Singleton-Vererbung zu lösen.

Schauen wir uns zunächst an, wie es ist, self zu verwenden:

<?php
// new self 得到的单例都为A。
class A
{
 protected static $_instance = null;

 protected function __construct()
 {
  //disallow new instance
 }

 protected function __clone(){
  //disallow clone
 }

 static public function getInstance()
 {
  if (self::$_instance === null) {
   self::$_instance = new self();
  }
  return self::$_instance;
 }
}

class B extends A
{
 protected static $_instance = null;
}

class C extends A{
 protected static $_instance = null;
}

$a = A::getInstance();
$b = B::getInstance();
$c = C::getInstance();

var_dump($a);
var_dump($b);
var_dump($c);




运行结果：
E:\code\php_test\apply\self.php:37:
class A#1 (0) {
}
E:\code\php_test\apply\self.php:38:
class A#1 (0) {
}
E:\code\php_test\apply\self.php:39:
class A#1 (0) {
}

Wie Sie im obigen Beispiel sehen können, ist die Verwendung von self eine Instanziierung Was wir erhalten, sind die gleichen Objekte der Klasse A.

Mal sehen, welche Ergebnisse wir mit statischen Methoden erhalten

<?php
// new static 得到的单例分别为D，E和F。
class D
{
 protected static $_instance = null;

 protected function __construct(){}
 protected function __clone()
 {
  //disallow clone
 }

 static public function getInstance()
 {
  if (static::$_instance === null) {
   static::$_instance = new static();
  }
  return static::$_instance;
 }
}

class E extends D
{
 protected static $_instance = null;
}

class F extends D{
 protected static $_instance = null;
}

$d = D::getInstance();
$e = E::getInstance();
$f = F::getInstance();

var_dump($d);
var_dump($e);
var_dump($f);




运行结果：
E:\code\php_test\apply\static.php:35:
class D#1 (0) {
}
E:\code\php_test\apply\static.php:36:
class E#2 (0) {
}
E:\code\php_test\apply\static.php:37:
class F#3 (0) {
}

Das Obige ist das, wofür ich kompiliert habe Ich hoffe, dass es in Zukunft für alle hilfreich sein wird.

Verwandte Artikel:

AjaxSubmit() sendet die Datei

Zwei Methoden für Ajax, um redundante Aktualisierungen zu lösen

Eine kurze Analyse und Lösungen für Ajax-Synchronisierung und asynchrone Probleme

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Analyse und Anwendung der späten statischen PHP-Bindung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!