array ( 0 => 'index.php', 1 => 'PHP Manual', ), 'head' => array ( 0 => 'UTF-8', 1 => 'pt_BR', ), 'this' => array ( 0 => 'language.namespaces.rules.php', 1 => 'Regras de resolução de nomes', ), 'up' => array ( 0 => 'language.namespaces.php', 1 => 'Namespaces', ), 'prev' => array ( 0 => 'language.namespaces.fallback.php', 1 => 'Recorrendo ao espaço global', ), 'next' => array ( 0 => 'language.namespaces.faq.php', 1 => 'Perguntas Frequentes', ), 'alternatives' => array ( ), 'source' => array ( 'lang' => 'pt_BR', 'path' => 'language/namespaces.xml', ), ); $setup["toc"] = $TOC; $setup["toc_deprecated"] = $TOC_DEPRECATED; $setup["parents"] = $PARENTS; manual_setup($setup); ?>
(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"
?>