Was ist ein PHP-Namespace? Ausführliche Erläuterung der Beispiele für die Verwendung von Namespaces

PHP beginnt mit der Unterstützung von Namespace in Versionen nach 5.3.0. Was ist ein Namensraum? Im Großen und Ganzen ist ein Namespace eine Möglichkeit, Dinge zu kapseln. Dieses abstrakte Konzept findet sich vielerorts.

Namespace-Übersicht

In PHP werden Namespaces verwendet, um Probleme zu lösen, die beim Schreiben von Klassenbibliotheken oder Anwendungen zum Erstellen von wiederverwendbarem Code wie Klassen oder Funktionen auftreten :

Namenskonflikte zwischen vom Benutzer geschriebenem Code und PHP-internen Klassen/Funktionen/Konstanten oder Klassen/Funktionen/Konstanten von Drittanbietern.
Erstellen Sie einen Aliasnamen (oder Kurznamen) für einen sehr langen Bezeichnernamen (der normalerweise zur Linderung des ersten Problemtyps definiert wird), um die Lesbarkeit des Quellcodes zu verbessern.
PHP-Namespaces bieten eine Möglichkeit, verwandte Klassen, Funktionen und Konstanten zu gruppieren. Hier ist ein Beispiel, das die PHP-Namespace-Syntax veranschaulicht:

Definieren eines Namespace

Obwohl jeder legale PHP-Code in einem Namespace enthalten sein kann, aber nur Drei Arten von Code sind von Namespaces betroffen: Klassen, Funktionen und Konstanten. Namespaces werden mit dem Schlüsselwort namespace deklariert. Wenn eine Datei einen Namespace enthält, muss sie den Namespace vor dem gesamten anderen Code deklarieren. Darüber hinaus kann im Gegensatz zu anderen Sprachfunktionen von PHP derselbe Namespace in mehreren Dateien definiert werden, wodurch der Inhalt desselben Namespace aufgeteilt und in verschiedenen Dateien gespeichert werden kann. Natürlich können Sie auch mehrere Namensräume in derselben Datei definieren.

namespace MyProject;
class MyClass
{
    #code...
}

Sub-Namespaces definieren: Ähnlich wie die Beziehung zwischen Verzeichnissen und Dateien ermöglichen PHP-Namespaces auch die Angabe hierarchischer Namespace-Namen. Daher können Namespace-Namen hierarchisch definiert werden:

namespace MyProject\helper\http;
class MyClass
{
    #code...
}

Mehrere Namespaces in derselben Datei definieren: Es gibt zwei Möglichkeiten, mehrere Namespaces in derselben Datei zu deklarieren, aber in der tatsächlichen Programmierpraxis ist dies der Fall Es wird dringend davon abgeraten, den Dogo-Namespace in derselben Datei zu definieren. Diese Methode wird hauptsächlich verwendet, um mehrere PHP-Skripte in derselben Datei zu kombinieren. Die erste Methode ist unten aufgeführt.

namespace MyProject\helper\http;
class MyClass
{
    #code...
}
namespace MyProject\helper\request;
class MyClass
{
    #code...
}

Es wird jedoch dringend davon abgeraten, diese Methode zu verwenden. Sie können sich auf die folgende Klammerdefinitionsmethode beziehen:

namespace MyProject\helper\http;
{
    class MyClass
    {
        #code...
    }
}
namespace MyProject\helper\request;
{
    class MyClass
    {
        #code...
    }
}

Elemente im PHP-Namespace verwenden

Bevor Sie die Verwendung von Namespaces besprechen, müssen Sie verstehen, woher PHP weiß, welche Namespace-Elemente verwendet werden sollen. Auf Klassennamen kann auf drei Arten verwiesen werden:

als unqualifizierter Name oder als Klassenname ohne Präfix, z. B. $a=new foo(); oder foo::staticmethod();. Wenn der aktuelle Namespace aktuellerNamespace ist, wird foo in currentnamespacefoo aufgelöst. Wenn der Code, der foo verwendet, global ist und keinen Code in einem Namespace enthält, wird foo als foo aufgelöst. Warnung: Wenn eine Funktion oder Konstante im Namespace undefiniert ist, wird der unqualifizierte Funktions- oder Konstantenname in einen globalen Funktions-Namen oder Konstantennamen aufgelöst. Weitere Informationen finden Sie unter Verwenden von Namespaces: Globale Fallback-Funktionsnamen/Konstantennamen.

Qualifizierter Name oder Name mit Präfix, z. B. $a = new subnamespacefoo(); oder subnamespacefoo::staticmethod();. Wenn der aktuelle Namespace currentnamespace ist, wird foo in currentnamespacesubnamespacefoo aufgelöst. Wenn der Code, der foo verwendet, global ist und der Code in keinem Namespace enthalten ist, wird foo in den Subnamespacefoo aufgelöst.

vollständig qualifizierter Name oder ein Name, der den globalen Präfix -Operator enthält, zum Beispiel $a = new currentnamespacefoo(); oder currentnamespacefoo::staticmethod();. In diesem Fall wird foo im Code immer in den Literalnamen currentnamespacefoo aufgelöst.
Namespaces verwenden: Alias/Import

Das Ermöglichen der Referenzierung oder des Imports externer vollständig qualifizierter Namen über Aliase ist eine wichtige Funktion von Namespaces. PHP-Namespace-Unterstützung Es gibt zwei Möglichkeiten, Aliase oder Importe zu verwenden: Aliase für Klassennamen oder Aliase für Namespace-Namen. In PHP werden Aliase durch den Operator use implementiert.

Beachten Sie, dass PHP keine importierten Funktionen oder Konstanten unterstützt.

namespace foo;
use My\Full\Classname as Another;
// 下面的例子与 use My\Full\NSname as NSname 相同
use My\Full\NSname;
// 导入一个全局类
use \ArrayObject;

Namensauflösungsregeln

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

Unqualifizierter Name: Eine Kennung, die enthält kein Namespace-Trennzeichen in seinem Namen, wie zum Beispiel Foo
Qualifizierter Name Qualifizierter Name: Ein Bezeichner, der ein Namespace-Trennzeichen in seinem Namen enthält, wie zum Beispiel FooBar
Vollständig qualifizierter Name: Ein Name, der ein Namespace-Trennzeichen enthält und Bezeichner, die mit einem Namespace-Trennzeichen beginnen, wie z. B. FooBar. namespaceFoo ist ebenfalls ein vollständig qualifizierter Name.
Die Namensauflösung erfolgt nach folgenden Regeln:

对完全限定名称的函数，类和常量的调用在编译时解析。例如 new \A\B 解析为类 A\B。
所有的非限定名称和限定名称（非完全限定名称）根据当前的导入规则在编译时进行转换。例如，如果命名空间 A\B\C 被导入为 C，那么对 C\D\e() 的调用就会被转换为 A\B\C\D\e()。
在命名空间内部，所有的没有根据导入规则转换的限定名称均会在其前面加上当前的命名空间名称。例如，在命名空间 A\B 内部调用 C\D\e()，则 C\D\e() 会被转换为 A\B\C\D\e() 。
非限定类名根据当前的导入规则在编译时转换（用全名代替短的导入名称）。例如，如果命名空间 A\B\C 导入为C，则 new C() 被转换为 new A\B\C() 。
在命名空间内部（例如A\B），对非限定名称的函数调用是在运行时解析的。例如对函数 foo() 的调用是这样解析的：
1) 在当前命名空间中查找名为 A\B\foo() 的函数
2) 尝试查找并调用 全局(global) 空间中的函数 foo()。
在命名空间（例如A\B）内部对非限定名称或限定名称类（非完全限定名称）的调用是在运行时解析的。下面是调用 new C() 及 new D\E() 的解析过程： new C()的解析:
在当前命名空间中查找A\B\C类。
尝试自动装载类A\B\C。

new D\E()的解析:
在类名称前面加上当前命名空间名称变成：A\B\D\E，然后查找该类。
尝试自动装载类 A\B\D\E。

为了引用全局命名空间中的全局类，必须使用完全限定名称 new \C()。

Example 名称解析示例

<?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 detaillierte Inhalt vonWas ist ein PHP-Namespace? Ausführliche Erläuterung der Beispiele für die Verwendung von Namespaces. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!