PHP-Namespace-Aufl?sungsregeln

Namespace-Namensdefinition

Unqualifizierter NameUnqualifizierter Name

<code>名稱中不包含命名空間分隔符的標(biāo)識符，例如Foo
</code>

Qualifizierter NameQualifizierter Name

<code>名稱中含有命名空間分隔符的標(biāo)識符，例如：Foo\Bar
</code>

Vollst?ndig Qualifizierter Name

<code>名稱中包含命名空間分隔符，并以命名空間分隔符開始的標(biāo)識符，例如：\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;

// 函數(shù)調(diào)用

foo();      // 首先嘗試調(diào)用定義在命名空間"A"中的函數(shù)foo()
            // 再嘗試調(diào)用全局函數(shù) "foo"

\foo();     // 調(diào)用全局空間函數(shù) "foo" 

my\foo();   // 調(diào)用定義在命名空間"A\my"中函數(shù) "foo" 

F();        // 首先嘗試調(diào)用定義在命名空間"A"中的函數(shù) "F" 
            // 再嘗試調(diào)用全局函數(shù) "F"

// 類引用

new B();    // 創(chuàng)建命名空間 "A" 中定義的類 "B" 的一個對象
            // 如果未找到，則嘗試自動裝載類 "A\B"

new D();    // 使用導(dǎo)入規(guī)則，創(chuàng)建命名空間 "B" 中定義的類 "D" 的一個對象
            // 如果未找到，則嘗試自動裝載類 "B\D"

new F();    // 使用導(dǎo)入規(guī)則，創(chuàng)建命名空間 "C" 中定義的類 "E" 的一個對象
            // 如果未找到，則嘗試自動裝載類 "C\E"

new \B();   // 創(chuàng)建定義在全局空間中的類 "B" 的一個對象
            // 如果未發(fā)現(xiàn)，則嘗試自動裝載類 "B"

new \D();   // 創(chuàng)建定義在全局空間中的類 "D" 的一個對象
            // 如果未發(fā)現(xiàn)，則嘗試自動裝載類 "D"

new \F();   // 創(chuàng)建定義在全局空間中的類 "F" 的一個對象
            // 如果未發(fā)現(xiàn)，則嘗試自動裝載類 "F"

// 調(diào)用另一個命名空間中的<strong>靜態(tài)方法</strong>或命名空間函數(shù)

B\foo();    // 調(diào)用命名空間 "A\B" 中函數(shù) "foo"

B::foo();   // 調(diào)用命名空間 "A" 中定義的類 "B" 的 "foo" 方法
            // 如果未找到類 "A\B" ，則嘗試自動裝載類 "A\B"

D::foo();   // 使用導(dǎo)入規(guī)則，調(diào)用命名空間 "B" 中定義的類 "D" 的 "foo" 方法
            // 如果類 "B\D" 未找到，則嘗試自動裝載類 "B\D"

\B\foo();   // 調(diào)用命名空間 "B" 中的函數(shù) "foo" 

\B::foo();  // 調(diào)用全局空間中的類 "B" 的 "foo" 方法
            // 如果類 "B" 未找到，則嘗試自動裝載類 "B"

// 當(dāng)前命名空間中的<strong>靜態(tài)方法</strong>或函數(shù)

A\B::foo();   // 調(diào)用命名空間 "A\A" 中定義的類 "B" 的 "foo" 方法
              // 如果類 "A\A\B" 未找到，則嘗試自動裝載類 "A\A\B"

\A\B::foo();  // 調(diào)用命名空間 "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.