Der Editor bringt Ihnen die Aufrufreihenfolge von Namespaces bei

Im vorherigen Artikel haben wir erfahren, wie man auf die internen Elemente des Namespace zugreift. Wenn Sie es benötigen, lesen Sie bitte „Der Editor zeigt Ihnen, wie Sie auf die internen Elemente des Namespace zugreifen (PHP-Version)“. Dieses Mal stellen wir Ihnen die Reihenfolge der Namespaces vor, Sie können bei Bedarf darauf zurückgreifen.

Schauen wir uns zunächst ein kleines Beispiel an.

<?php
namespace A;
use B\D, C\E as F;

// 函数调用

foo();      // 首先尝试调用定义在命名空间"A"中的函数foo()
            // 再尝试调用全局函数 "foo"

\foo();     // 调用全局空间函数 "foo" 

my\foo();   // 调用定义在命名空间"A\my"中函数 "foo" 

F();        // 首先尝试调用定义在命名空间"A"中的函数 "F" 
            // 再尝试调用全局函数 "F"

// 类引用

new B();    // 创建命名空间 "A" 中定义的类 "B" 的一个对象
            // 如果未找到，则尝试自动装载类 "A\B"

new D();    // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象
            // 如果未找到，则尝试自动装载类 "B\D"

new F();    // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象
            // 如果未找到，则尝试自动装载类 "C\E"

new \B();   // 创建定义在全局空间中的类 "B" 的一个对象
            // 如果未发现，则尝试自动装载类 "B"

new \D();   // 创建定义在全局空间中的类 "D" 的一个对象
            // 如果未发现，则尝试自动装载类 "D"

new \F();   // 创建定义在全局空间中的类 "F" 的一个对象
            // 如果未发现，则尝试自动装载类 "F"

// 调用另一个命名空间中的静态方法或命名空间函数

B\foo();    // 调用命名空间 "A\B" 中函数 "foo"

B::foo();   // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法
            // 如果未找到类 "A\B" ，则尝试自动装载类 "A\B"

D::foo();   // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法
            // 如果类 "B\D" 未找到，则尝试自动装载类 "B\D"

\B\foo();   // 调用命名空间 "B" 中的函数 "foo" 

\B::foo();  // 调用全局空间中的类 "B" 的 "foo" 方法
            // 如果类 "B" 未找到，则尝试自动装载类 "B"

// 当前命名空间中的静态方法或函数

A\B::foo();   // 调用命名空间 "A\A" 中定义的类 "B" 的 "foo" 方法
              // 如果类 "A\A\B" 未找到，则尝试自动装载类 "A\A\B"

\A\B::foo();  // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法
              // 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"
?>

Wenn wir uns das kleine Beispiel oben genau ansehen, was können wir beobachten? Verdammt, wir geben jetzt die Antwort.

Wenn wir beim Aufrufen einer Funktion nur „foo()“ schreiben, wird zuerst die Funktion im Namespace aufgerufen, und dann wird die globale Funktion aufgerufen () )“, dadurch wird nur die globale Funktion aufgerufen.

foo()”，先调用的命名空间中的函数，然后在调用全局函数；但如果是“foo()”，这就只调用全局函数了。

在类应用的时候，如果我们写了“new B();”，将会创建命名空间中定义的类"B"的一个对象，但如果未找到，则尝试自动装载类"AB"。

在调用另一个命名空间中的静态方法或命名空间函数的时候，如何我们写了“Bfoo()”，这表明我们将调用命名空间中的函数“foo()”；但如果写的是“B::foo();”就不一样了，他先调用命名空间中的函数“foo()”，但如果未找到，则尝试自动装载类"AB"。

在当前命名空间中的静态方法或函数的时候，如何我们写了“AB::foo();Wenn wir während der Klassenanwendung „new B();“ schreiben, wird ein im Namespace definiertes Objekt der Klasse „B“ erstellt. Wenn es jedoch nicht gefunden wird, versuchen Sie es mit „Klasse automatisch laden“. „AB“.

Wenn wir eine statische Methode oder Namespace-Funktion in einem anderen Namespace aufrufen, schreiben wir „Bfoo()“, was angibt, dass wir die Funktion im Namespace „foo()“ aufrufen >“; aber wenn Sie „B::foo();“ schreiben, ist es anders. Er ruft zuerst die Funktion „foo()“ im Namespace auf, aber wenn sie nicht gefunden wird, wird ein Versuch unternommen um die Klasse „AB“ automatisch zu laden.

Wenn wir eine statische Methode oder Funktion im aktuellen Namespace schreiben, schreiben wir „AB::foo();“, was angibt, dass wir die im Namespace definierte Klasse „AA“ nennen Die Methode „foo“ von „B“ lädt automatisch die Klasse „AAB“, wenn sie nicht gefunden wird.

• Jetzt fassen wir zusammen.

• Aufrufe an vollständig qualifizierte Funktionen, Klassen und Konstanten werden zur Kompilierungszeit aufgelöst. Beispielsweise wird newaB in die Klasse aB aufgelöst.

• Alle unqualifizierten Namen und qualifizierten Namen (nicht vollständig qualifizierte Namen) werden zur Kompilierzeit gemäß den aktuellen Importregeln konvertiert. Wenn beispielsweise der Namespace ABC als C importiert wird, werden Aufrufe von CDe() in ABCDe() konvertiert.

• Alle unqualifizierten und qualifizierten Namen (nicht vollständig qualifizierte Namen) werden zur Kompilierzeit gemäß den aktuellen Importregeln konvertiert. Wenn beispielsweise der Namespace aBC als C importiert wird, werden Aufrufe von CDe() in aBCDe() konvertiert.

• Unqualifizierte Klassennamen werden zur Kompilierzeit gemäß den aktuellen Importregeln konvertiert (kurze Importnamen werden durch vollständige Namen ersetzt). Wenn beispielsweise der Namespace aBC als C importiert wird, wird das neue C() in das neue aBC() konvertiert.

• In einem Namespace (z. B. ab) werden Funktionsaufrufe an unqualifizierte Namen zur Laufzeit aufgelöst. Beispielsweise wird ein Aufruf der Funktion foo() wie folgt analysiert:

• Suchen Sie eine Funktion namens ABfoo() im aktuellen Namespace.

• Versuchen Sie, die Funktion foo() im globalen Bereich zu finden und aufzurufen.

• Aufrufe an unqualifizierte Namen oder qualifizierte Namensklassen (nicht vollständig qualifizierte Namen) innerhalb eines Namespace (z. B. ab) werden zur Laufzeit aufgelöst. Das Folgende ist der Parsing-Prozess zum Aufrufen von new c() und new de(): Parsen von new c():

• Suchen Sie die ABC-Klasse im aktuellen Namespace.

• Versuchen Sie es mit der Autoload-Klasse ABC.

• neue DE()-Analyse:

• Fügen Sie den aktuellen Namespace-Namen vor dem Klassennamen hinzu, um ABDE zu erhalten, und suchen Sie dann nach der Klasse.

• Versuchen Sie es mit der automatischen Ladeklasse ABDE.

Um auf eine globale Klasse im globalen Namensraum zu verweisen, muss der vollqualifizierte Name new C() verwendet werden.

🎜Das ist alles. Wenn Sie noch etwas wissen möchten, können Sie hier klicken. → →🎜php-Video-Tutorial🎜🎜

Das obige ist der detaillierte Inhalt vonDer Editor bringt Ihnen die Aufrufreihenfolge von Namespaces bei. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!