php name resolution rules

Before explaining the name resolution rules, let’s look at some important definitions:

Namespace name definition

Unqualified name

An identifier that does not contain a namespace separator in its name, such as Foo

Qualified name

An identifier whose name contains a namespace delimiter, such as FooBar

Fully qualified name

An identifier whose name contains a namespace delimiter and starts with a namespace delimiter, such as FooBar. namespaceFoo is also a fully qualified name.

Name resolution follows the following rules:

Calls to functions, classes and constants with fully qualified names are resolved at compile time. For example, new AB resolves to class AB.

All unqualified names and qualified names (non-fully qualified names) are converted at compile time according to the current import rules. For example, if namespace ABC was imported as C, then calls to CDe() would be converted to ABCDe().

Within the namespace, all qualified names that are not converted according to the import rules will be preceded by the current namespace name. For example, if CDe() is called within namespace AB, CDe() will be converted to ABCDe().

Unqualified class names are converted at compile time according to the current import rules (full names are used instead of short import names). For example, if namespace ABC is imported as C, then new C() is converted to new ABC() .

Within a namespace (e.g. AB), function calls to unqualified names are resolved at runtime. For example, a call to function foo() is parsed like this:

Find a function named ABfoo() in the current namespace

Try to find and call function foo() in the global space.

Calls to unqualified names or qualified name classes (non-fully qualified names) inside a namespace (e.g. AB) are resolved at runtime. The following is the parsing process of calling new C() and new DE(): Parsing of new C():

Parsing of new DE():

In order to refer to the global class in the global namespace, the fully qualified name new must be used C().

Add the current namespace name in front of the class name to become: ABDE, and then search for the class.

Try autoloading class ABDE.

Find class ABC in the current namespace.

Try autoloading class ABC.

Name resolution example

<?php
    namespace A;
    use B\D, C\E as F;
    // 函数调用
    foo(); // 首先尝试调用定义在命名空间"A"中的函数foo()
    // 再尝试调用全局函数 "foo"
    \foo(); // 调用全局空间函数 "foo"
    my\foo(); // 调用定义在命名空间"A\my"中函数 "foo"
    F(); // 首先尝试调用定义在命名空间"A"中的函数 "F"
    // 再尝试调用全局函数 "F"
    // 类引用
    new B(); // 创建命名空间 "A" 中定义的类 "B" 的一个对象
    // 如果未找到，则尝试自动装载类 "A\B"
    new D(); // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象
    // 如果未找到，则尝试自动装载类 "B\D"
    new E(); // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象
    // 如果未找到，则尝试自动装载类 "C\E"
    
    new \B(); // 创建定义在全局空间中的类 "B" 的一个对象
    // 如果未发现，则尝试自动装载类 "B"
    
    new \D(); // 创建定义在全局空间中的类 "D" 的一个对象
    // 如果未发现，则尝试自动装载类 "D"
    
    new \F(); // 创建定义在全局空间中的类 "F" 的一个对象
    // 如果未发现，则尝试自动装载类 "F"
    
    // 调用另一个命名空间中的静态方法或命名空间函数
    B\foo(); // 调用命名空间 "A\B" 中函数 "foo"
    B::foo(); // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法
    // 如果未找到类 "A\B" ，则尝试自动装载类 "A\B"
    
     D::foo(); // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法
    // 如果类 "B\D" 未找到，则尝试自动装载类 "B\D"
    
    \B\foo(); // 调用命名空间 "B" 中的函数 "foo"
    \B::foo(); // 调用全局空间中的类 "B" 的 "foo" 方法
    // 如果类 "B" 未找到，则尝试自动装载类 "B"
    
    // 当前命名空间中的静态方法或函数
    A\B::foo(); // 调用命名空间 "A\A" 中定义的类 "B" 的 "foo" 方法
    // 如果类 "A\A\B" 未找到，则尝试自动装载类 "A\A\B"
    
    \A\B::foo(); // 调用命名空间 "A\B" 中定义的类 "B" 的 "foo" 方法
    // 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"
?>