PHP namespace (spazio dei nomi)

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:

codice-utente scritto all'interno di PHP classi / funzioni / costanti o di terze parti nome classi / funzioni / costanti conflitti tra.
Come identificatori lunghi (di solito per alleviare la prima categoria definita) creare un alias (o corto) il nome di migliorare la leggibilità del codice sorgente.

Definire gli spazi dei nomi

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;  
 
// ... 代码 ...

È 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 { /* ... */ }
function connect() { /* ... */  }
}

namespace { // 全局代码
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>

si verificherà il seguente errore di sintassi di codice:

<html>
<?php
namespace MyProject; // 命名空间前出现了“<html>” 会致命错误 -　命名空间必须是程序脚本的第一条语句
?>

sottospazi dei nomi

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 { /* ... */ }
function Connect() { /* ... */  }

?>

L'esempio sopra crea costante MyProject \ sub \ Livello \ CONNECT_OK, digitare il progetto \ sub \ Livello \ collegamento e la funzione MyProject \ sub \ Livello \ Connect.

Namespace

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

Namespace e caratteristiche del linguaggio dinamico

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

namespace parola chiave e costanti NAMESPACE

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

Utilizzando spazi dei nomi: Aliasing / importazione

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

Utilizzando spazi dei nomi: fallback di funzione globale / costante

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";
}
?>

spazio globale

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() { 
     /* ... */
     $f = \fopen(...); // 调用全局的fopen函数
     return $f;
} 
?>

namespace ordine

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:

Funzione nome completo della classe e le chiamate continue risolti in fase di compilazione. Per esempio nuovo \ A \ B delibera di classe A \ B.
Tutti i nomi non qualificati e qualificati (non i nomi pienamente qualificati) convertite al momento della compilazione in base alle regole di importazione in vigore. Ad esempio, se lo spazio dei nomi A \ B \ C viene importato come C, quindi una chiamata a C \ D \ e () sarà convertito in A \ B \ C \ D \ E ().
Namespace dentro, tutti i nomi qualificati non tradotti in base alle leggi di importazione verrà aggiunto al nome del namespace corrente di fronte ad essa. Ad esempio, nello spazio dei nomi A \ B interno chiamata C \ D \ E (), allora C \ D \ e () è tradotto in A \ B \ C \ D \ E ().
nome della classe non qualificato del convertitore (con il nome completo invece del nome di una breve introduzione) al momento della compilazione in base alle regole di importazione in vigore. Ad esempio, se il namespace A \ B \ C viene importato come C, il nuovo C () vengono convertiti nuova A \ B \ C () .
Spazio dei nomi interno (ad esempio A \ B), chiamate a non qualificato nome della funzione viene risolto in fase di esecuzione. Ad esempio, una chiamata alla funzione foo () è stato risolto in questo modo:
1. Trovare chiamato A \ B \ foo nello spazio dei nomi corrente () funzione
2. Prova a trovare e chiamare il mondiale (globale) funzione di spazio foo ().
Spazio dei nomi (per esempio, A \ B) interno al nome non qualificato o qualificata dei nomi delle classi (non i nomi pienamente qualificati) chiamata viene risolto in fase di esecuzione. Ecco la chiamata alla nuova C () e il nuovo D \ E () del processo di risoluzione: new () analisi C:
1. Trova A \ B classe \ C nello spazio dei nomi corrente.
2. Si cerca di caricare automaticamente A \ B \ C.
nuovo D \ E () analisi:
1. In nome della classe preceduto dal nome del namespace corrente diventa: A \ B \ D \ E , quindi cercare la classe.
2. Si cerca di caricare automaticamente A \ B \ D \ E.
Per fare riferimento alla classe globale namespace globale, è necessario utilizzare il nome completo nuovo \ C ().

Precedente: PHP variabile magia

Successivo: PHP DOP

PHP corso

PHP modulo

PHP Tutorial avanzato

PHP 7 nuove funzionalità

PHP Database

PHP XML

PHP & AJAX

PHP Manuale di riferimento

PHP namespace (spazio dei nomi)

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 corso

PHP modulo

PHP Tutorial avanzato

PHP 7 nuove funzionalità

PHP Database

PHP XML

PHP & AJAX

PHP Manuale di riferimento

PHP namespace (spazio dei nomi)

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

namespace parola chiave e costanti NAMESPACE