PHP-Namensauflösungsregeln

Bevor wir die Namensauflösungsregeln erklären, werfen wir einen Blick auf einige wichtige Definitionen:

Namespace-Namensdefinition

Unqualifizierter Name

Der Name enthält keine Namespace-Trennungsbezeichner mit Namespace Trennzeichen, wie zum Beispiel Foo

Qualifizierter Name

Bezeichner mit Namespace-Trennzeichen im Namen, wie zum Beispiel FooBar

Vollständig qualifizierter Name

Ein Bezeichner, dessen Name ein Namespace-Trennzeichen enthält und mit dem 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 wurde, würden 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 Namensraums 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:

Suchen Sie eine Funktion namens ABfoo() im aktuellen Namespace

Versuchen Sie, eine Funktion im globalen Bereich foo 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 des Aufrufs von new C() und new DE(): Parsing von new C():

Parsing von new DE():

Um auf das Globale zu verweisen Namespace-Klasse, muss den vollqualifizierten Namen new C() verwenden.

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.

Suchen Sie die Klasse ABC im aktuellen Namespace.

Versuchen Sie, die Klasse ABC automatisch zu laden.

Beispiel zur Namensauflösung

<?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 E(); // 使用导入规则，创建命名空间 "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"
?>