Il miglior tutorial PHP namespace (spazio dei nomi) Nel 2024, in questo tutorial puoi imparare Definire gli spazi dei nomi,sottospazi dei nomi,Namespace,Namespace e caratteristiche del linguaggio dinamico,namespace parola chiave e costanti __NAMESPACE__,Utilizzando spazi dei nomi: Aliasing / importazione,Utilizzando spazi dei nomi: fallback di funzione globale / costante,spazio globale,namespace ordine,
PHP namespace (spazio dei nomi) viene aggiunto in PHP 5.3, se hai imparato C # e Java, dello spazio dei nomi che non è niente di cose nuove. Ma in PHP che ha ancora un significato molto importante.
namespace PHP possono risolvere i seguenti due problemi:
Per impostazione predefinita, tutte le costanti, le classi, e nomi delle funzioni sono collocati nello spazio globale, proprio come prima del PHP supporto dello spazio dei nomi.
dichiarazione dello spazio dei nomi da namespace parola chiave. Se il nome del file contiene spazi, deve dichiarare il namespace prima di qualsiasi altro codice. La sintassi è la seguente;
< ?php // 定义代码在 'MyProject' 命名空间中 namespace MyProject; // it. 代码 it.
È inoltre possibile definire diversi spazi dei nomi nello stesso file nel codice, come ad esempio:
< ?php namespace MyProject1; // MyProject1 命名空间中的PHP代码 namespace MyProject2; // MyProject2 命名空间中的PHP代码 // 另一种语法 namespace MyProject3 { // MyProject3 命名空间中的PHP代码 } ?>
Prima di dichiarare un codice giuridico unico spazio dei nomi viene utilizzato per definire il file di origine metodi di codifica dichiarano dichiarazione. Tutto il codice non PHP include la spaziatura non può apparire prima della dichiarazione dello spazio dei nomi.
<?php declare(encoding='UTF-8'); //定义多个命名空间和不包含在命名空间中的代码 namespace MyProject { const CONNECT_OK = 1; class Connection { /* it. */ } function connect() { /* it. */ } } namespace { // 全局代码 session_start(); $a = MyProject\connect(); echo MyProject\Connection::start(); } ?>
si verificherà il seguente errore di sintassi di codice:
<html> <?php namespace MyProject; // 命名空间前出现了“<html>” 会致命错误 - 命名空间必须是程序脚本的第一条语句 ?>
Rapporti con le directory ei file molto simile, namespace PHP permette anche di specificare il nome dello spazio dei nomi gerarchico. Così, il nome del namespace può essere definita utilizzando maniera gerarchica:
<?php namespace MyProject\Sub\Level; //声明分层次的单个命名空间 const CONNECT_OK = 1; class Connection { /* it. */ } function Connect() { /* it. */ } ?>
L'esempio sopra crea costante MyProject \ sub \ Livello \ CONNECT_OK, digitare il progetto \ sub \ Livello \ collegamento e la funzione MyProject \ sub \ Livello \ Connect.
PHP nome della classe spazio dei nomi è possibile fare riferimento in tre modi:
nome non qualificato o il nome della classe non contiene un prefisso, come ad esempio $ a = new foo (); o foo :: staticmethod ();. Se lo spazio dei nomi corrente è currentnamespace, foo sarà interpretato come currentnamespace \ foo. Se foo è il codice globale, il codice non contiene alcun namespace, verrà analizzato come pippo pippo. Avvertenza: Se la funzione di spazio dei nomi o la costante non è definita, quindi il nome della funzione o non qualificato nome della costante saranno risolti al nome della funzione globale, o il nome della costante.
nome completo, oppure il nome contiene il prefisso, come ad esempio $ a = new subnamespace \ foo ( ); o subnamespace \ foo :: staticmethod ();. Se lo spazio dei nomi corrente è currentnamespace, allora foo verrà analizzato come currentnamespace \ subnamespace \ foo. Se foo è il codice globale, il codice non contiene alcun namespace, foo sarà risolto a subnamespace \ foo.
Completamente nome completo, o includere un nome dell'operatore prefisso globale, per esempio, $ a = new \ currentnamespace \ foo (); o \ currentnamespace \ foo :: staticmethod () ;. In questo caso, foo sarà sempre risolto al nome delle parole in codice (letterale nome) currentnamespace \ foo.
Ecco un esempio di questi tre modi:
codice del file file1.php
<?php namespace Foo\Bar\subnamespace; const FOO = 1; function foo() {} class foo { static function staticmethod() {} } ?>
codice del file file2.php
<?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 ?>
Si noti che per accedere a qualsiasi classe, funzione globale o costante, è possibile utilizzare il nome completo, come ad esempio \ strlen () o \ Exception o \ INI_ALL.
Namespace Accesso classi, funzioni e costanti globali:
<?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 ?>
Implementare PHP spazio dei nomi colpiti dalle sue stesse caratteristiche del linguaggio dinamico. Quindi, se si desidera che il seguente codice in spazi dei nomi, elementi di accesso dinamico.
codice del file example1.php:
<?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 ?>
È necessario utilizzare un nome completo (compreso il nome della classe del prefisso namespace). Si noti che, poiché in un nome dinamico di classe, il nome della funzione, o il nome della costante, nome completo e il nome completo è alcuna differenza, in modo che il backslash non è necessaria.
elemento dello spazio dei nomi di accesso dinamico
<?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 supporta due modi per accedere agli elementi dello spazio dei nomi corrente Estratto interno, __ costanti NAMESPACE__ magici e namespace parola chiave.
__NAMESPACE__ Valore costante è una stringa contenente il nome dello spazio dei nomi corrente. Nel globale, il codice non include alcun namespace che contiene una stringa vuota.
__NAMESPACE__ Esempio, in un codice namespace
<?php namespace MyProject; echo '"', __NAMESPACE__, '"'; // 输出 "MyProject" ?>
__NAMESPACE__ Esempio, il codice globale
<?php echo '"', __NAMESPACE__, '"'; // 输出 "" ?>
__NAMESPACE__ Costante crea dinamicamente quando il nome è utile, ad esempio:
Utilizzare __NAMESPACE__ nome creato in modo dinamico
<?php namespace MyProject; function get($classname) { $a = __NAMESPACE__ . '\\' . $classname; return new $a; } ?>
Namespace parola chiave può essere utilizzato per accedere in modo esplicito lo spazio dei nomi corrente o un elementi sub-namespace. È equivalente alla classe dell'operatore sé.
namespace codice operatore namespace
<?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 ?>
operatore namespace, il codice globale
<?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 ?>
namespace PHP supportano due utilizzando pseudonimi o importazione: utilizzare un alias per il nome della classe, o un alias per un nome di namespace. Si noti che PHP non supporta l'importazione di una funzione o costante.
In PHP, alias per l'uso dell'operatore di raggiungere i seguenti è un uso di tutti i possibili modi per importare i tre esempi:
1, utilizzando le uso dell'operatore di importazione / 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, la riga che contiene più istruzioni d'uso
<?php use My\Full\Classname as Another, My\Full\NSname; $obj = new Another; // 实例化 My\Full\Classname 对象 NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func ?>
L'operazione di importazione viene eseguita in fase di compilazione, ma un nome di classe dinamica, il nome della funzione, o il nome della costante non è.
3, l'importazione e il nome dinamico
<?php use My\Full\Classname as Another, My\Full\NSname; $obj = new Another; // 实例化一个 My\Full\Classname 对象 $a = 'Another'; $obj = new $a; // 实际化一个 Another 对象 ?>
Inoltre, l'operazione di importazione riguarda solo nomi non qualificati e qualificati. Completamente nome qualificato perché è identificato, non è influenzato dalla importazione.
4, l'importazione e pienamente qualificati nomi
<?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 uno spazio dei nomi, quando il PHP incontra una classe non qualificata, la funzione o il nome costante, utilizza una diversa strategie prioritarie per risolvere il nome. Il nome della classe del nome del namespace corrente si risolve sempre. Pertanto, in un accesso interno al sistema o non incluso nel namespace del nome della classe, è necessario utilizzare il nome completo, ad esempio:
1, accedere alle classi globali in uno spazio dei nomi
<?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 类 ?>
Per le funzioni e costanti, la funzione non esiste o se le costanti namespace attuali, il PHP ripiegare a funzioni globali o costanti nello spazio.
2, funzione globale dello spazio dei nomi riservato / costanti
<?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"; } ?>
Se non si definisce un namespace, tutte le definizioni e le funzioni di classe sono in uno spazio globale e PHP come prima dell'introduzione del concetto di namespace. Prima il nome prefisso \ indica che il nome è uno spazio nome globale, è anche vero di altri namespace anche se il nome si trova.
Descrizione Usa spazio globale
<?php namespace A\B\C; /* 这个函数是 A\B\C\fopen */ function fopen() { /* it. */ $f = \fopen(it.); // 调用全局的fopen函数 return $f; } ?>
Dal momento che con lo spazio dei nomi, che è il più uso soggetto a errori di tempo di classe, per trovare il percorso di questa classe è ciò che il.
<?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" ?>
Risoluzione dei nomi seguenti regole: