Names are resolved following these resolution rules:
All qualified names are translated during compilation according to current
import rules. In example, if the namespace A::B::C is imported, a call to
C::D::e() is translated to A::B::C::D::e().
Unqualified class names are translated during compilation according to current
import rules (full name substituted for short imported name). In example, if
the namespace A::B::C is imported, new C() is
translated to new A::B::C().
Inside namespace, calls to unqualified functions that are defined in the
current namespace (and are known at the time the call is parsed) are
interpreted as calls to these namespace functions, at compile time.
Inside namespace (say A::B), calls to unqualified functions that are not
defined in current namespace are resolved at run-time. Here is how a
call to function foo() is resolved:
It looks for a function from the current namespace:
A::B::foo().
It tries to find and call the internal function
foo().
To call a user defined function in the global namespace,
::foo() has to be used.
Inside namespace (say A::B), calls to unqualified class names are
resolved at run-time. Here is how a call to
new C() is resolved:
It looks for a class from the current namespace:
A::B::C.
It tries to find and call the internal class
C.
It attemts to autoload A::B::C.
To reference a user defined class in the global namespace,
new ::C() has to be used.
Calls to qualified functions are resolved at run-time. Here is how a call
to A::B::foo() is resolved:
It looks for a function foo() in the namespace
A::B.
It looks for a class A::B and call its static
method foo(). It will autoload the class if
necessary.
Qualified class names are resolved in compile-time as class from corresponding
namespace. For example, new A::B::C() refers to class
C from namespace A::B.
Example #1 Name resolutions illustrated
<?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 ?>
add a note
User Contributed Notes Name resolution rules
There are no user contributed notes for this page.
Namespaces
