Namespaces no PHP - José Malcher Jr.

Namespaces fornecem uma maneira de evitar conflitos para os membros do grupo em uma hierarquia. Qualquer código pode ser contido dentro de um espaço de namespace, mas apenas quatro construções de código são afetados: classes, interfaces, funções e constantes.

Criação de Namespaces

Uma classe que não está incluído um namespace pertence ao namespace global.

<?php
// Global code/namespace
class MyClass {}

Para atribuir a classe de um outro namespace a directiva namespace é definido. Quaisquer classes de código abaixo da diretiva de namespace irá pertencer ao namespace. A convenção de nomenclatura para namespaces é minúsculo.

<?php
namespace my;
// Pertence ao meu namespace
class MyClass {}

Um arquivo de script contendo código namespace deve declarar o namespace no topo do arquivo antes de qualquer outra PHP ou código HTML.

<?php
namespace my;
class MyClass {}
?>
<html><body></body></html>

Namespaces aninhados

Namespaces podem ser aninhados a qualquer número de níveis de profundidade para definir ainda mais a hierarquia de namespace. Como os diretórios e arquivos no Windows, namespaces e seus membros são separados por uma barra invertida.

namespace my\sub;
class MyClass {} // my\sub\MyClass

Sintaxe alternativa

Alternativamente, namespaces pode ser definida com a sintaxe entre colchetes comumente usado em outras linguagens de programação. Assim como com a sintaxe regular, nenhum texto ou código pode existir fora do namespace.

<?php
namespace my
{
class MyClass {}
?>
<html><body></body></html>
<?php }?>

Vários namespaces podem ser declaradas no mesmo arquivo, embora isso não seja considerado uma boa prática de codificação. Se o código global é para ser combinado com o código namespace então a sintaxe suportado deve ser usado. O código global é então fechado em um bloco de namespace sem nome.

// Namespace code
namespace my
{
const PI = 3.14;
}
// Global code
namespace
{
echo my\PI; // "3.14"
}

Ao contrário de outras classes do PHP, o mesmo namespace pode ser definido em mais de um arquivo. Isso permite que o conteúdo do namespace posso ser dividido em vários arquivos.

Referenciando namespaces

Um membro namespace pode ser referido em três modos: totalmente qualificados, qualificados e não qualificados. O nome completo pode ser sempre utilizado. Trata-se do operador de prefixo global (\) seguido do caminho namespace do membro. O operador prefixo global indica que o caminho é relativo ao espaço global.

namespace my
{
class MyClass {}
}
namespace other
{
// Nome totalmente qualificado
$obj = new \my\MyClass();
}

O nome qualificado inclui o caminho namespace, mas não o operador de prefixo global. Ele só pode, portanto, ser usado se o membro desejado é definido em um namespace abaixo do namespace atual na hierarquia.

namespace my
{
class MyClass {}
}
namespace
{
// Nome Qualificado
$obj = new my\MyClass();
}

O nome do membro por si só, ou nome não qualificado, só pode ser usado dentro do namespace que define o membro.

namespace my
{
class MyClass {}
// Unqualified name
$obj = new MyClass();
}

Nomes de classe e interface não qualificados só resolve o namespace atual. Em contrapartida, se uma função ou uma constante não qualificada não existe no namespace atual, eles vão tentar resolver sendo uma função global ou sendo uma constante com o mesmo nome.

namespace
{
    function myPrint() { echo 'global'; }
}
namespace my
{
    // Cai de volta para namespace global
    myPrint(); // "global"
}

Como alternativa, o operador de prefixo global pode ser usado para se referir explicitamente ao membro global. Isto seria necessário se o espaço continha uma função com o mesmo nome.

namespace my
{
    function myPrint() { echo 'my'; }
 
// Chamar função de namespace global
\myPrint();  // "global"
myPrint();  // "my"
}

Aliases Namespace

Aliases podem ser criados para encurtar nomes qualificados, a fim de melhorar a legibilidade do código fonte. Os nomes para classes, interfaces e namespaces podem ser encurtadas, enquanto que a função e constantes aliases não são suportados. Um alias é definido com uma directiva use, que deve ser colocado logo após o nome do namespace.

namespace my;
class MyClass {}
 
namespace foo;
use my\MyClass as MyAlias;
$obj = new MyAlias();

Com a sintaxe entre parênteses, todas as diretrizes de uso são colocados antes do colchete de abertura.

use my\MyClass as MyAlias;
{
    $obj = new MyAlias();
}

A cláusula é opcional, pode ser ser deixado de fora para importar o membro sob seu nome atual.

namespace foo;
 
// Igual a my\MyClass as MyClass
use \my\MyClass;
$obj = new MyClass();

Não é possível a importar em massa os membros de outro namespace. No entanto, existe um atalho sintático para a importação de vários membros da mesma declaração uso.

namespace foo;
use my\Class1 as C1, my\Class2 as C2;

Tenha em mente que aliases só se aplicam ao arquivo de script que os define. Um arquivo importado, portanto, não herdarão aliases do arquivo principal.

Palavras-chaves (keyword) Namespace

A palavra-chave namespace pode ser usado como uma constante que irá avaliar o namespace atual, ou uma string vazia em código global. Ele pode ser usado para se referir explicitamente ao namespace atual.

namespace my\name
{
    function myPrint() { echo 'Hi'; }
}
namespace my
{
    namespace\name\myPrint(); // "Hi"
    name\myPrint(); // o mesmo que acima
}

Diretrizes para namespace

Como o número de componentes envolvidos em uma aplicação web cresce com o tempo, assim também aumenta o potencial de conflitos de nomes. Uma solução para isto é usar o prefixo dos nomes com o nome do componente. No entanto, isso cria nomes longos que reduzem a legibilidade do código fonte. Por esta razão PHP 5.3 introduziu o namespace, que permitem que os desenvolvedores de código agrupem cada componente em “recipientes” e chamadas separadas.