Das beste PHP Namespace (Namensraum)-Tutorial im Jahr 2024. In diesem Tutorial können Sie definieren von Namespaces,Subnamespaces,Namespaces,Namespaces und dynamische Sprachfeatures,Namespace-Schlüsselwort und Konstanten __NAMESPACE__,Namespaces verwenden: Importieren / Aliase,Namespaces verwenden: Rückgriff auf globale Funktion / Konstante,globale Raum,Bestellen Sie Namespace, lernen
PHP Namespace (Namensraum) in PHP 5.3, hinzugefügt, wenn Sie C # und Java gelernt, Namensraum, der nichts Neues ist. Aber in PHP, die hat immer noch eine sehr wichtige Bedeutung.
PHP Namespaces können die folgenden zwei Probleme zu lösen:
Standardmäßig werden alle Konstanten, Klassen und Funktionsnamen werden im globalen Raum platziert, genau das gleiche wie vor dem Namespace-Unterstützung PHP.
Namespace-Deklaration nach Stichwort Namespace. Wenn ein Dateiname Leerzeichen enthält, muss es den Namespace vor jedem anderen Code deklarieren. Die Syntax ist wie folgt;
< ?php // 定义代码在 'MyProject' 命名空间中 namespace MyProject; // de. 代码 de.
Sie können auch verschiedene Namensräume in der gleichen Datei im Code, wie definieren:
< ?php namespace MyProject1; // MyProject1 命名空间中的PHP代码 namespace MyProject2; // MyProject2 命名空间中的PHP代码 // 另一种语法 namespace MyProject3 { // MyProject3 命名空间中的PHP代码 } ?>
Bevor Sie einen Namensraum einzigartigen Rechts Code erklärt wird verwendet, um die Quelldatei Codierverfahren Anweisung deklarieren zu definieren. Alle Nicht-PHP-Code enthält Leerzeichen nicht vor der Namespace-Deklaration erscheinen kann.
<?php declare(encoding='UTF-8'); //定义多个命名空间和不包含在命名空间中的代码 namespace MyProject { const CONNECT_OK = 1; class Connection { /* de. */ } function connect() { /* de. */ } } namespace { // 全局代码 session_start(); $a = MyProject\connect(); echo MyProject\Connection::start(); } ?>
Der folgende Code Syntaxfehler auftreten:
<html> <?php namespace MyProject; // 命名空间前出现了“<html>” 会致命错误 - 命名空间必须是程序脚本的第一条语句 ?>
Beziehung mit Verzeichnissen und Dateien viel wie, PHP Namespaces ermöglicht auch den Namen des hierarchischen Namensraum angeben. Somit kann der Name des Namespace definiert werden, um eine hierarchische Weise unter Verwendung von:
<?php namespace MyProject\Sub\Level; //声明分层次的单个命名空间 const CONNECT_OK = 1; class Connection { /* de. */ } function Connect() { /* de. */ } ?>
Das obige Beispiel erzeugt Konstante MyProject \ Sub \ Ebene \ CONNECT_OK, Typ MyProject \ Sub \ Ebene \ Connection und Funktion MyProject \ Sub \ Ebene \ Connect.
PHP Namespace Klassenname kann auf drei Arten verwiesen werden:
Unqualifizierte Namen oder den Namen der Klasse enthält kein Präfix, wie $ a = new foo (); oder foo :: static ();. Wenn der aktuelle Namespace aktuellerNamespace, wird foo als aktuellerNamespace \ foo interpretiert werden. Wenn foo globale Code ist, wird der Code keinen Namensraum enthalten, wird es als foo foo analysiert werden. Achtung: Wenn der Namespace-Funktion oder Konstante nicht definiert ist, dann der Name der Funktion oder unqualifizierte konstant Name wird auf die globale Funktionsnamen oder konstante Name aufgelöst werden.
Qualifizierter Name, oder enthält der Name mit dem Präfix, wie $ a = new subnamespace \ foo ( ); oder subnamespace \ foo :: static ();. Wenn der aktuelle Namespace aktuellerNamespace ist, dann wird foo als aktuellerNamespace \ subnamespace \ foo analysiert. Wenn foo globale Code ist, wird der Code keinen Namensraum enthalten, wird foo aufgelöst werden \ foo subnamespace.
Der vollständig qualifizierte Name oder ein globales Präfix Name des Bedieners umfassen zum Beispiel $ a = new \ aktuellerNamespace \ foo (); oder \ aktuellerNamespace \ foo :: static () ;. In diesem Fall wird, foo immer auf den Namen der Codewörter aufgelöst werden (wörtliche Name) aktuellerNamespace \ foo.
Hier ist ein Beispiel dieser drei Möglichkeiten:
file1.php Datei Code
<?php namespace Foo\Bar\subnamespace; const FOO = 1; function foo() {} class foo { static function staticmethod() {} } ?>
file2.php Datei Code
<?php namespace Foo\Bar; include 'file1.php'; const FOO = 2; function foo() {} class foo { static function staticmethod() {} } /* 非限定名称 */ foo(); // 解析为 Foo\Bar\foo resolves to function Foo\Bar\foo foo::staticmethod(); // 解析为类 Foo\Bar\foo的静态方法staticmethod。resolves to class Foo\Bar\foo, method staticmethod echo FOO; // resolves to constant Foo\Bar\FOO /* 限定名称 */ subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo, // 以及类的方法 staticmethod echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO /* 完全限定名称 */ \Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo \Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO ?>
Beachten Sie, dass für den Zugriff auf jede globale Klasse, Funktion oder Konstante, können Sie den vollständig qualifizierten Namen, wie zum Beispiel \ strlen () oder \ Exception oder \ INI_ALL verwenden.
Namespace-Zugriff auf globale Klassen, Funktionen und Konstanten:
<?php namespace Foo; function strlen() {} const INI_ALL = 3; class Exception {} $a = \strlen('hi'); // 调用全局函数strlen $b = \INI_ALL; // 访问全局常量 INI_ALL $c = new \Exception('error'); // 实例化全局类 Exception ?>
Implementieren Sie PHP Namespace durch seine eigene dynamische Sprachfunktionen betroffen. Also, wenn Sie wollen den folgenden Code in Namespaces, dynamische Zugriffselemente.
example1.php Datei Code:
<?php class classname { function __construct() { echo __METHOD__,"\n"; } } function funcname() { echo __FUNCTION__,"\n"; } const constname = "global"; $a = 'classname'; $obj = new $a; // prints classname::__construct $b = 'funcname'; $b(); // prints funcname echo constant('constname'), "\n"; // prints global ?>
Sie müssen einen vollqualifizierten Namen (einschließlich der Klassenname des Namespacepräfix) verwenden. Beachten Sie, dass, weil in einer dynamischen Klasse Name, Funktion Name, oder konstanten Namen, qualifizierten Namen und den voll qualifizierten Namen keinen Unterschied, so der führende Backslash unnötig ist.
Dynamic Access-Namespace-Element
<?php namespace namespacename; class classname { function __construct() { echo __METHOD__,"\n"; } } function funcname() { echo __FUNCTION__,"\n"; } const constname = "namespaced"; include 'example1.php'; $a = 'classname'; $obj = new $a; // prints classname::__construct $b = 'funcname'; $b(); // prints funcname echo constant('constname'), "\n"; // prints global /* note that if using double quotes, "\\namespacename\\classname" must be used */ $a = '\namespacename\classname'; $obj = new $a; // prints namespacename\classname::__construct $a = 'namespacename\classname'; $obj = new $a; // also prints namespacename\classname::__construct $b = 'namespacename\funcname'; $b(); // prints namespacename\funcname $b = '\namespacename\funcname'; $b(); // also prints namespacename\funcname echo constant('\namespacename\constname'), "\n"; // prints namespaced echo constant('namespacename\constname'), "\n"; // also prints namespaced ?>
PHP unterstützt zwei Möglichkeiten, um die aktuellen Namensraum abstrakten Interieur-Elemente zuzugreifen, __ NAMESPACE__ magische Konstanten und Namespace-Schlüsselwort.
__NAMESPACE__ Konstanter Wert ist eine Zeichenfolge, die den Namen des aktuellen Namensraum enthält. Im globalen, wird der Code keinen Namensraum enthalten, die eine leere Zeichenfolge enthält.
__NAMESPACE__ Beispiel, in einem Namespace Code
<?php namespace MyProject; echo '"', __NAMESPACE__, '"'; // 输出 "MyProject" ?>
__NAMESPACE__ Beispiel, globale Code
<?php echo '"', __NAMESPACE__, '"'; // 输出 "" ?>
Constant __NAMESPACE__ dynamisch erstellt, wenn der Name nützlich ist, zum Beispiel:
Verwenden Sie __NAMESPACE__ dynamisch erstellten Namen
<?php namespace MyProject; function get($classname) { $a = __NAMESPACE__ . '\\' . $classname; return new $a; } ?>
Namespace-Schlüsselwort kann explizit verwendet werden, um den aktuellen Namespace zugreifen oder ein Unternamensraum-Elemente. Sie ist äquivalent zu der Klasse der Selbstbedienungsperson.
Namespace-Operator-Namespace Code
<?php namespace MyProject; use blah\blah as mine; // see "Using namespaces: importing/aliasing" blah\mine(); // calls function blah\blah\mine() namespace\blah\mine(); // calls function MyProject\blah\mine() namespace\func(); // calls function MyProject\func() namespace\sub\func(); // calls function MyProject\sub\func() namespace\cname::method(); // calls static method "method" of class MyProject\cname $a = new namespace\sub\cname(); // instantiates object of class MyProject\sub\cname $b = namespace\CONSTANT; // assigns value of constant MyProject\CONSTANT to $b ?>
Namespace-Betreiber, die globale Code
<?php namespace\func(); // calls function func() namespace\sub\func(); // calls function sub\func() namespace\cname::method(); // calls static method "method" of class cname $a = new namespace\sub\cname(); // instantiates object of class sub\cname $b = namespace\CONSTANT; // assigns value of constant CONSTANT to $b ?>
PHP Namespaces unterstützen zwei Aliasnamen oder den Import verwendet: ein Alias für den Klassennamen verwenden oder einen Alias für einen Namespace-Namen. Beachten Sie, dass PHP unterstützt keine Funktion oder Konstante importieren.
In PHP, alias für Operator verwenden Sie die folgende zu erreichen, ist eine Nutzung aller Möglichkeiten, drei Beispiele zu importieren:
1, mit der Verwendung Operator Import / alias
<?php namespace foo; use My\Full\Classname as Another; // 下面的例子与 use My\Full\NSname as NSname 相同 use My\Full\NSname; // 导入一个全局类 use \ArrayObject; $obj = new namespace\Another; // 实例化 foo\Another 对象 $obj = new Another; // 实例化 My\Full\Classname 对象 NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func $a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象 // 如果不使用 "use \ArrayObject" ,则实例化一个 foo\ArrayObject 对象 ?>
2, die Linie, die mehrfache Verwendung Aussagen enthält
<?php use My\Full\Classname as Another, My\Full\NSname; $obj = new Another; // 实例化 My\Full\Classname 对象 NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func ?>
Importoperation wird bei der Kompilierung durchgeführt, sondern eine dynamische Klasse Name, Funktion Name, oder konstant Name nicht.
3, Import und dynamischen Namens
<?php use My\Full\Classname as Another, My\Full\NSname; $obj = new Another; // 实例化一个 My\Full\Classname 对象 $a = 'Another'; $obj = new $a; // 实际化一个 Another 对象 ?>
Darüber hinaus wirkt sich der Importvorgang nur unqualifizierte und qualifizierte Namen. Vollständig qualifizierte Namen, weil er identifiziert wird, wird es nicht durch den Import betroffen.
4, Importieren und voll qualifizierten Namen
<?php use My\Full\Classname as Another, My\Full\NSname; $obj = new Another; // instantiates object of class My\Full\Classname $obj = new \Another; // instantiates object of class Another $obj = new Another\thing; // instantiates object of class My\Full\Classname\thing $obj = new \Another\thing; // instantiates object of class Another\thing ?>
In einem Namespace, wenn PHP eine unqualifizierte Klasse trifft, Funktion oder konstanten Namen, verwendet es eine andere Priorität Strategien, um den Namen aufzulösen. Der Klassenname des aktuellen Namespace-Namen aufgelöst immer. Daher wird in einem internen Zugriff auf das System oder nicht im Namensraum des Klassennamens enthalten ist, müssen Sie den vollständig qualifizierten Namen verwenden, zum Beispiel:
1, Zugriff auf globale Klassen in einem Namespace
<?php namespace A\B\C; class Exception extends \Exception {} $a = new Exception('hi'); // $a 是类 A\B\C\Exception 的一个对象 $b = new \Exception('hi'); // $b 是类 Exception 的一个对象 $c = new ArrayObject; // 致命错误, 找不到 A\B\C\ArrayObject 类 ?>
Für Funktionen und Konstanten, wird die Funktion nicht vorhanden ist oder wenn die aktuellen Namespace Konstanten, wird PHP zu globalen Funktionen oder Konstanten im Raum zurückgreifen.
2, globale Funktion Namensraum reserviert / Konstanten
<?php namespace A\B\C; const E_ERROR = 45; function strlen($str) { return \strlen($str) - 1; } echo E_ERROR, "\n"; // 输出 "45" echo INI_ALL, "\n"; // 输出 "7" - 使用全局常量 INI_ALL echo strlen('hi'), "\n"; // 输出 "1" if (is_array('hi')) { // 输出 "is not array" echo "is array\n"; } else { echo "is not array\n"; } ?>
Wenn Sie keinen Namensraum definieren, werden alle Klassendefinitionen und Funktionen sind in einem globalen Raum und PHP als vor der Einführung des Konzepts der Namensräume. Bevor der Name Präfix \ zeigt an, dass der Name einer globalen Namensraum ist, ist es auch wahr, andere Namespace auch wenn der Name befindet.
Beschreibung Verwendung globaler Raum
<?php namespace A\B\C; /* 这个函数是 A\B\C\fopen */ function fopen() { /* de. */ $f = \fopen(de.); // 调用全局的fopen函数 return $f; } ?>
Da mit dem Namespace, die die meisten fehleranfällige Nutzung der Unterrichtszeit ist, zu finden, der Weg dieser Klasse ist das, was die.
<?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" ?>
Namensauflösung Führen Sie die folgenden Regeln: