Regeln für die Auflösung von PHP-Namespaces

PHP-Namespace-Auflösungsregeln

Namespace-Namensdefinition

Unqualifizierter NameUnqualifizierter Name

<code>名称中不包含命名空间分隔符的标识符，例如Foo
</code>

Qualifizierter NameQualifizierter Name

<code>名称中含有命名空间分隔符的标识符，例如：Foo\Bar
</code>

Vollständig Qualifizierter Name

<code>名称中包含命名空间分隔符，并以命名空间分隔符开始的标识符，例如：\Foo\Bar.
namespace\Foo 也是一个完全限定名称。
</code>

Die Namensauflösung folgt den folgenden Regeln

1. 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.
2. 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.
3. 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.
4. 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 das neue C() in das neue ABC() konvertiert.
5. 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 globale Space-Funktion zu finden und aufzurufen foo() in .

6. 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():

   1. Suchen Sie die ABC-Klasse in der aktuellen namespace;

   2. Versuchen Sie, die Klasse ABC automatisch zu laden.

   Parsing von neuem DE():

   1. Fügen Sie den aktuellen Namespace-Namen vor dem Klassennamen hinzu, um ABDE zu erhalten, und suchen Sie dann für die Klasse

   2. 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.

Beispiel zur Namensauflösung

<code><?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"

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

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"

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

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

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

').addClass('pre-numbering').hide(); $(this).addClass('has-numbering').parent().append($numbering); for (i = 1; i ').text(i)); }; $numbering.fadeIn(1700); }); });

Das Obige stellt die Parsing-Regeln für PHP-Namespaces vor, einschließlich statischer Methoden. Ich hoffe, dass es für Freunde hilfreich ist, die sich für PHP-Tutorials interessieren.