PHP espacio de nombres (namespace)

Se añade PHP espacio de nombres (namespace) en PHP 5.3, si usted aprendió C # y Java, espacio de nombres que no es nada cosas nuevas. Pero en PHP que todavía tiene un significado muy importante.

espacios de nombres de PHP pueden resolver los dos problemas siguientes:

código escrito por el usuario dentro de PHP clases / funciones / constantes o conflictos de nombres de terceros clases / funciones / constantes entre.
Como nombres de los identificadores largos (normalmente para aliviar la primera categoría definida) crear un alias (o corto) el nombre de mejorar la legibilidad del código fuente.

La definición de espacios de nombres

Por defecto, todas las constantes, clases y nombres de funciones se colocan en el espacio global, lo mismo que antes de que el soporte para PHP espacio de nombres.

declaración de espacio por espacio de nombres de palabras clave. Si un nombre de archivo contiene espacios, debe declarar el espacio de nombres antes de cualquier otro código. Sintaxis es la siguiente;

< ?php  
// 定义代码在 'MyProject' 命名空间中  
namespace MyProject;  
 
// ... 代码 ...

También se pueden definir diferentes espacios de nombres en el mismo archivo en el código, tales como:

< ?php  
namespace MyProject1;  
// MyProject1 命名空间中的PHP代码  
 
namespace MyProject2;  
// MyProject2 命名空间中的PHP代码    
 
// 另一种语法
namespace MyProject3 {  
 // MyProject3 命名空间中的PHP代码    
}  
?>

Antes de declarar un código legal único espacio de nombres se utiliza para definir el archivo de origen métodos de codificación declaran comunicado. Todo el código PHP no incluye espacios en blanco no puede aparecer antes de la declaración de espacio de nombres.

<?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();
}
?>

se producirá el siguiente código de error de sintaxis:

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

subespacios

Relación con los directorios y archivos muy similar, espacios de nombres de PHP también permite especificar el nombre del espacio de nombres jerárquico. Así, el nombre del espacio de nombres se puede definir mediante una manera jerárquica:

<?php
namespace MyProject\Sub\Level;  //声明分层次的单个命名空间

const CONNECT_OK = 1;
class Connection { /* ... */ }
function Connect() { /* ... */  }

?>

El ejemplo anterior crea constante MiProyecto \ Sub \ Nivel \ CONNECT_OK, escriba MyProject \ Sub \ Nivel \ Su conexión y funcionamiento MiProyecto \ Sub \ Nivel \ Connect.

Los espacios de nombres

PHP nombre de la clase de espacio de nombres se puede hacer referencia de tres maneras:

Nombre no calificado, o el nombre de la clase no contiene un prefijo, por ejemplo, $ a = new foo (); o foo :: métodoestático ();. Si el espacio de nombres actual es currentnamespace, foo será interpretado como espaciodenombresactual \ foo. Si foo es código global, el código no contiene ningún espacio de nombres, se analiza como foo foo. Advertencia: Si no se define la función de espacio de nombres o constante, entonces el nombre de la función o el nombre de la constante no calificado se resolverán con el nombre de la función global, o el nombre de constante.
nombre completo o el nombre contiene el prefijo, por ejemplo, $ a = new subespaciodenombres \ foo ( ); o subespaciodenombres \ foo :: métodoestático ();. Si el espacio de nombres actual es currentnamespace, entonces foo se procesarán como espaciodenombresactual \ subespaciodenombres \ foo. Si foo es código global, el código no contiene ningún espacio de nombres, foo será resuelta a subespaciodenombres \ foo.
Totalmente nombre completo, o incluir un nombre global operador de prefijo, por ejemplo, $ a = new \ espaciodenombresactual \ foo (); o \ espaciodenombresactual \ foo :: métodoestático () ;. En este caso, foo siempre se resolverá con el nombre de las palabras de código (literal nombre) espaciodenombresactual \ foo.

He aquí un ejemplo de estas tres maneras:

código del archivo file1.php

<?php
namespace Foo\Bar\subnamespace; 

const FOO = 1;
function foo() {}
class foo
{
    static function staticmethod() {}
}
?>

código del archivo 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
?>

Tenga en cuenta que para acceder a cualquier clase, función global o constante, puede utilizar el nombre completo, tal como \ strlen () o \ excepción o \ INI_ALL.

Espacio de nombres Acceder a clases globales, funciones y constantes:

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

Los espacios de nombres y características dinámicas del lenguaje

Implementar PHP espacio de nombres afectados por sus propias características dinámicas del lenguaje. Por lo tanto, si desea que el código siguiente en los espacios de nombres, elementos de acceso dinámico.

código del archivo 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
?>

Debe utilizar un nombre completo (incluyendo el nombre de la clase del prefijo de espacio de nombres). Tenga en cuenta que debido a que en una dinámica de nombres de clase, nombre de la función, o el nombre de constante, nombre completo y el nombre completo es ninguna diferencia, por lo que la barra invertida inicial es innecesaria.

elemento de espacio de nombres de acceso dinámico

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

La palabra clave namespace y constantes NAMESPACE

PHP soporta dos formas de acceder a los elementos de espacio de nombres actual abstractas interiores, __ constantes NAMESPACE__ mágicas y palabra clave namespace.

__NAMESPACE__ Valor constante es una cadena que contiene el nombre del espacio de nombres actual. En global, el código no incluye ningún espacio de nombres que contiene una cadena vacía.

Ejemplo __NAMESPACE__, en un código de espacio de nombres

<?php
namespace MyProject;

echo '"', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

Ejemplo __NAMESPACE__, código global

<?php

echo '"', __NAMESPACE__, '"'; // 输出 ""
?>

__NAMESPACE__ Constante crea dinámicamente cuando el nombre es útil, por ejemplo:

Utilice __NAMESPACE__ nombre creado de forma dinámica

<?php
namespace MyProject;

function get($classname)
{
    $a = __NAMESPACE__ . '\\' . $classname;
    return new $a;
}
?>

Espacio de nombres palabra clave puede utilizarse para acceder explícitamente el espacio de nombres actual o una sub-elementos de espacio de nombres. Es equivalente a la clase de operador mismo.

espacio de nombres de código de espacio de nombres del operador

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

operador de espacio de nombre, código global

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

Usar espacios de nombres: Aliasing / Importación

espacios de nombres de PHP apoyan el uso de alias dos o importador: Utilice un alias para el nombre de la clase, o un alias para un nombre de espacio de nombres. Tenga en cuenta que PHP no soporta la importación de una función o constante.

En PHP, alias para el uso del operador para alcanzar el siguiente es un uso de todas las maneras posibles para importar tres ejemplos:

1, usando el operador uso de importación / 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 línea que contiene varias instrucciones de 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
?>

La operación de importación se realiza en tiempo de compilación, pero un nombre de clase dinámica, nombre de la función, o el nombre no es constante.

3, la importación y la dinámica de nombres

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化一个 My\Full\Classname 对象
$a = 'Another';
$obj = new $a;      // 实际化一个 Another 对象
?>

Además, la operación de importación sólo afecta a los nombres no cualificados y cualificados. Totalmente nombre cualificado que ya está definido, no se ve afectada por la importación.

4, Importación y nombres completos

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

Usar espacios de nombres: una alternativa a funciones / constantes globales

En un espacio de nombres, cuando PHP se encuentra con una clase no calificado, función o nombre de constante, que utiliza una estrategias prioritarias diferentes para resolver el nombre. El nombre de la clase del nombre de espacio de nombres actual siempre se resuelve a. Por lo tanto, en un acceso interno al sistema o no incluido en el espacio de nombres del nombre de la clase, debe utilizar el nombre completo, por ejemplo:

1, acceder a las clases globales en un espacio de nombres

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

Para funciones y constantes, la función no existe o si las constantes espacios de nombres actuales, PHP caerá de nuevo a funciones o constantes globales en el espacio.

2, la función global de espacio de nombres reservados / constantes

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

espacio global

Si no se define ningún espacio de nombres, todas las definiciones y funciones de clase están en un espacio global y PHP que antes de la introducción del concepto de espacios de nombres. Antes de que el nombre con prefijo \ indica que el nombre es un espacio de nombres global, también es cierto espacio de nombres de la otra, incluso si el nombre se encuentra.

Descripción Uso espacio global

<?php
namespace A\B\C;

/* 这个函数是 A\B\C\fopen */
function fopen() { 
     /* ... */
     $f = \fopen(...); // 调用全局的fopen函数
     return $f;
} 
?>

espacio de nombres fin

Ya que con el espacio de nombres, que es el uso más propenso a errores de tiempo de clase, para encontrar el camino de esta clase es lo que el.

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

Resolución de nombres Siga las siguientes reglas:

Función nombre completo de la clase y las constantes llamadas resueltas en tiempo de compilación. Por ejemplo nueva \ A \ B resuelve con la clase A \ B.
Todos los nombres no cualificados y cualificados (no los nombres completos) convertidos en tiempo de compilación basado en reglas actuales de importación. Por ejemplo, si el espacio de nombres A \ B \ C se importa como C, a continuación, una llamada a C \ D \ e () se convertirá a A \ B \ C \ D \ e ().
Espacio de nombres en el interior, todos los nombres cualificados no traducidas de acuerdo con las normas de importación será añadido al nombre de espacio de nombres actual frente a ella. Por ejemplo, en el espacio de nombres A \ B Interno llamada C \ D \ e (), entonces C \ D \ e () se traduce a A \ B \ C \ D \ e ().
nombre de la clase no cualificado del convertidor (con el nombre completo en lugar del nombre de una breve introducción) en tiempo de compilación basado en reglas actuales de importación. Por ejemplo, si el espacio de nombres A \ B \ C se importa como C, el nuevo C () se convierten a la nueva A \ B \ C () .
Espacio de nombres interno (por ejemplo, A \ B), llama a una función no calificado se resuelve en tiempo de ejecución. Por ejemplo, una llamada a la función foo () se resuelve de esta manera:
1. Encuentra llamado A \ B \ foo en el espacio de nombres actual () Función
2. Trate de encontrar y llamar a la función foo espacio (mundial) mundial ().
Espacio de nombres (por ejemplo, A \ B) interna al nombre no calificado o cualificada de los nombres de las clases (no nombres totalmente calificados) llamada se resuelve en tiempo de ejecución. Esta es la llamada a la nueva C () y el nuevo D \ E () del proceso de resolución: nuevo () C de análisis:
1. Encontrar una clase \ B \ C en el espacio de nombres actual.
2. Se trata de autocarga A \ B \ C
nueva D \ E () el análisis:
1. En el nombre de la clase precedido por el nombre de espacio de nombres actual se convierte en: A \ B \ D \ E , a continuación, busque la clase.
2. Se trata de autocarga A \ B \ D \ E.
Para hacer referencia a la clase mundial espacio de nombres global, debe utilizar el nombre completo nuevo \ C ().

Anterior: PHP variable de la magia

Siguiente: PHP DOP

PHP curso

PHP formulario

PHP Tutorial avanzado

PHP 7 nuevas características

PHP base de datos

PHP XML

PHP & AJAX

PHP Manual de referencia

PHP espacio de nombres (namespace)

La definición de espacios de nombres

subespacios

Los espacios de nombres

Los espacios de nombres y características dinámicas del lenguaje

La palabra clave namespace y constantes NAMESPACE

Usar espacios de nombres: Aliasing / Importación

Usar espacios de nombres: una alternativa a funciones / constantes globales

espacio global

espacio de nombres fin

PHP curso

PHP formulario

PHP Tutorial avanzado

PHP 7 nuevas características

PHP base de datos

PHP XML

PHP & AJAX

PHP Manual de referencia

PHP espacio de nombres (namespace)

La definición de espacios de nombres

subespacios

Los espacios de nombres

Los espacios de nombres y características dinámicas del lenguaje

La palabra clave namespace y constantes __NAMESPACE__

Usar espacios de nombres: Aliasing / Importación

Usar espacios de nombres: una alternativa a funciones / constantes globales

espacio global

espacio de nombres fin

La palabra clave namespace y constantes NAMESPACE