(PHP 5 >= 5.3.0, PHP 7, PHP 8)
Para efeitos destas regras de resolução, aqui estão algumas definições importantes:
Este é um identificador sem separador de namespace, como Foo.
Este é um identificador com separador de namespace, como Foo\Bar.
Este é um identificador com separador de namespace que começa com um
separador de namespace, como \Foo\Bar. O namespace
\Foo também é um nome totalmente qualificado.
Este é um identificador que começa com namespace, como
namespace\Foo\Bar.
Os nomes são resolvidos seguindo estas regras de resolução:
\A\B será resolvido para A\B.
namespace substituído
pelo namespace atual. Se o nome ocorrer no namespace global, o
prefixo namespace\ será removido. Por exemplo, namespace\A
dentro do namespace X\Y será resolvido para X\Y\A. O mesmo nome
dentro do namespace global será resolvido para A.
A\B\C for
importado como C, o nome C\D\E será traduzido para
A\B\C\D\E.
C\D\E dentro do namespace A\B,
será resolvido para A\B\C\D\E.
use A\B\C; um uso como new C() será resolvido para o nome
A\B\C(). Da mesma forma, após a declaração use function A\B\foo; um uso
como foo() será resolvido para o nome A\B\foo.
new C() dentro do namespace
A\B será resolvido para o nome A\B\C.
A\B, é assim que uma chamada para a função
foo() será resolvida:
A\B\foo().
foo().
Exemplo #1 Resoluções de nomes ilustradas
<?php
namespace A;
use B\D, C\E as F;
// chamadas de funções
foo(); // primeiro tenta chamar "foo" definida no namespace "A"
// então chama a função global "foo"
\foo(); // chama a função "foo" definida no escopo global
minha\foo(); // chama a função "foo" definida no namespace "A\minha"
F(); // primeiro tenta chamar "F" definida no namespace "A"
// e então chama a função global "F"
// referências de classe
new B(); // cria um objeto da classe "B" definida no namespace "A"
// se não for encontrada, tenta carregar automaticamente a classe "A\B"
new D(); // usando regras de importação, cria um objeto da classe "D" definida no namespace "B"
// se não for encontrada, tenta carregar automaticamente a classe "B\D"
new F(); // usando regras de importação, cria um objeto da classe "E" definida no namespace "C"
// se não for encontrada, tenta carregar automaticamente a classe "C\E"
new \B(); // cria um objeto da classe "B" definida no escopo global
// se não for encontrada, tenta carregar automaticamente a classe "B"
new \D(); // cria um objeto da classe "D" definida no escopo global
// se não for encontrado, tenta carregar automaticamente a classe "D"
new \F(); // cria um objeto da classe "F" definida no escopo global
// se não for encontrada, tenta carregar automaticamente a classe "F"
// métodos estáticos/funções de namespace de outro namespace
B\foo(); // chama a função "foo" do namespace "A\B"
B::foo(); // chama o método "foo" da classe "B" definida no namespace "A"
// se a classe "A\B" não for encontrada, tenta carregar automaticamente a classe "A\B"
D::foo(); // usando regras de importação, chama o método "foo" da classe "D" definida no namespace "B"
// se a classe "B\D" não for encontrada, tenta carregar automaticamente a classe "B\D"
\B\foo(); // chama a função "foo" do namespace "B"
\B::foo(); // chama o método "foo" da classe "B" do escopo global
// se a classe "B" não for encontrada, tenta carregar automaticamente a classe "B"
// métodos estáticos/funções de namespace do namespace atual
A\B::foo(); // chama o método "foo" da classe "B" do namespace "A\A"
// se a classe "A\A\B" não for encontrada, tenta carregar automaticamente a class "A\A\B"
\A\B::foo(); // chama o método "foo" da classe "B" do namespace "A"
// se a classe "A\B" não for encontrada, tenta carregar automaticamente a classe "A\B"
?>