Hinweis 009 PHP-Namespace – Teil 2

Namensauflösungsregeln

Bevor wir die Namensauflösungsregeln erklären, schauen wir uns einige wichtige Definitionen an:

Namespace-Namensdefinition

Unqualifizierter Name

An Bezeichner, dessen Name kein Namespace-Trennzeichen enthält, z. B. Foo

Qualifizierter Name Qualifizierter Name

Ein Bezeichner, dessen Name ein Namespace-Trennzeichen enthält, z. B. FooBar

Vollständig qualifizierter Name

Ein Bezeichner, dessen Name ein Namespace-Trennzeichen enthält und mit einem Namespace-Trennzeichen beginnt, z. B. FooBar. namespaceFoo ist ebenfalls ein vollständig qualifizierter Name.

Die Namensauflösung folgt den folgenden Regeln:

Aufrufe von Funktionen, Klassen und Konstanten mit vollständig qualifizierten Namen werden zur Kompilierungszeit aufgelöst. Beispielsweise wird „Neu AB“ 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.

Innerhalb eines Namespace wird allen qualifizierten Namen, die nicht gemäß Importregeln konvertiert werden, der aktuelle Namespace-Name vorangestellt. Wenn beispielsweise CDe() innerhalb des Namespace AB aufgerufen wird, wird CDe() in ABCDe() konvertiert.

Unqualifizierte Klassennamen werden zur Kompilierzeit gemäß den aktuellen Importregeln konvertiert (vollständige Namen werden anstelle von kurzen Importnamen verwendet). Wenn beispielsweise der Namespace ABC als C importiert wird, wird new C() in new ABC() konvertiert.

Innerhalb eines Namensraums (z. B. AB) werden Funktionsaufrufe an unqualifizierte Namen zur Laufzeit aufgelöst. Ein Aufruf der Funktion foo() wird beispielsweise wie folgt analysiert: 1. Suchen Sie eine Funktion namens ABfoo() im aktuellen Namespace. 2. 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():

Parsing von new C():

Suchen Sie die ABC-Klasse im aktuellen Namespace.

Versuchen Sie, die Klasse ABC automatisch zu laden.

Parsing von neuem DE():

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

Versuchen Sie, die Klasse ABDE automatisch zu laden.

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

<?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" 中定义的类 "B" 的 "foo" 方法
// 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"
?>

Das Obige ist der Inhalt von Hinweis 009 PHP-Namespace – Teil Zwei. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).