Forum und email
Namespaces
PHP Manual

Regras de resolução de nomes

Nomes são resolvidos seguindo estas regras de resolução:

  1. Todos nomes qualificados são traduzidos durante a compilação de acordo com a atual regra do import. Por exemplo, se o namespace A::B::C é importado, uma chamada para C::D::e() é traduzida para A::B::C::D::e().
  2. Nomes não qualificados de classes são traduzidos durante compilação de acordo com a atual regra de import (nome completo substituído pelo pequeno nome importado). Por exemplo, se o namespace A::B::C é importado, new C() é traduzido para new A::B::C().
  3. Dentro do namespace, chamadas para nomes não qualificados de funções que são definidos no atual namespace (e é conhecido na hora que a chamada é analisada) são interpretados como chamadas para estas funções do namespace, em tempo de compilação.
  4. Dentro do namespace (digo A::B), chamadas para funções não qualificadas que não são definidas no atual namespace são resolvidos em tempo de execução. Veja como uma chamada para uma função foo() é resolvida:
    1. Ele procura por uma função do atual namespace: A::B::foo().
    2. Ele procura e tenta chamar a função interna foo().
    Para chamar a função definida do usuário no namespace global, ::foo() tem que ser usado.
  5. Dentro do namespace (digo A::B), chamadas para não qualificados nomes de classes são resolvidos em tempo de execução. Veja como uma chamada para new C() é resolvida:
    1. Ele verifica por uma classe do namespace atual: A::B::C().
    2. Ele tenta buscar e chamar a classe interna C().
    3. Ele tenta fazer autoload A::B::C(). C().
    Para referenciar a classe definida pelo usuário no namespace global, new ::C() tem que ser usado.
  6. Chamadas para qualificadas funções são resolvidas em tempo de execução. Veja como a chamada para A::B::foo() é resolvida:
    1. Ele verifica por uma função foo() no namespace A::B.
    2. Ele verifica por uma classe A::B e chama o método estático foo(). Irá fazer autoload da class se necessário.
  7. Qualificados nomes de classes são resolvidos em tempo de compilação como classes correspondentes do namespace. Por exemplo, new A::B::C() refere-se a classe C do namespace >A::B.

Example#1 Ilustrando resolução de nomes

<?php
namespace A;

// function calls

foo();      // first tries to call "foo" defined in namespace "A"
            // then calls internal function "foo"

::foo();    // calls function "foo" defined in global scope

// class references

new B();    // first tries to create object of class "B" defined in namespace "A"
            // then creates object of internal class "B"

new ::B();  // creates object of class "B" defined in global scope

// static methods/namespace functions from another namespace

B::foo();   // first tries to call function "foo" from namespace "A::B"
            // then calls method "foo" of internal class "B"

::B::foo(); // first tries to call function "foo" from namespace "B"
            // then calls method "foo" of class "B" from global scope

// static methods/namespace functions of current namespace

A::foo();   // first tries to call function "foo" from namespace "A::A"
            // then tries to call method "foo" of class "A" from namespace "A"
            // then tries to call function "foo" from namespace "A"
            // then calls method "foo" of internal class "A" 

::A::foo(); // first tries to call function "foo" from namespace "A"
            // then calls method "foo" of class "A" from global scope
?>
Namespaces
PHP Manual