Complete mastery of php namespaces-PHP Tutorial-php.cn

Namespace is used to resolve name conflicts between user-written code and PHP internal classes/functions/constants or third-party classes/functions/constants. Create an alias (or short) name for a very long identifier name to improve source code readability.

Although any legal PHP code can be included in a namespace, only the following types of code are affected by the namespace: classes (including abstract classes and traits), interfaces, functions, and constants.

If a file contains a namespace, it must declare the namespace before all other code except one: declareKeyword, used to define the source file encoding declare statement. Code, including whitespace, cannot appear before a namespace declaration.

Different from other PHP language features, the same namespace can be defined in multiple files, which allows the contents of the same namespace to be divided and stored in different files.

Define sub-namespaces

<?phpnamespace MyProject\Sub\Level;const CONNECT_OK = 1;class Connection { /* ... */ }function connect() {/* ... */ }

Copy after login

Defining multiple namespaces in the same file

<?phpnamespace MyProject;const CONNECT_OK = 1;class Connection { /* ... */ }function connect() { /* ... */  }namespace AnotherProject;const CONNECT_OK = 1;class Connection { /* ... */ }function connect() { /* ... */  }

Copy after login

It is not recommended to use this syntax to define multiple namespaces in a single file. It is recommended to use the following curly bracket form of syntax.

<?phpnamespace MyProject {const CONNECT_OK = 1;class Connection { /* ... */ }function connect() { /* ... */  }
}namespace AnotherProject {const CONNECT_OK = 1;class Connection { /* ... */ }function connect() { /* ... */  }
}

Copy after login

In actual programming practice, it is highly discouraged to define multiple namespaces in the same file. This method is mainly used to combine multiple PHP scripts in the same file.

To combine the code in the global non-namespace with the code in the namespace, you can only use the syntax in the form of braces. Global code must be enclosed in curly braces with an unnamed namespace statement.

Classes can be referenced in three ways:

An unqualified name, or a class name without a prefix, such as $a=new foo(); or foo::staticmethod();. If the current namespace is currentnamespace, foo will be resolved to currentnamespace\foo. If the code using foo is global and does not contain code in any namespace, foo will be resolved as foo. Warning: If a function or constant in the namespace is undefined, the unqualified function name or constant name will be resolved to a global function name or constant name.
Qualified name, or name including a prefix, such as $a = new subnamespace\foo(); or subnamespace\foo:: staticmethod();. If the current namespace is currentnamespace, then foo will be resolved to currentnamespace\subnamespace\foo. If the code using foo is global and does not contain code in any namespace, foo will be resolved as subnamespace\foo.
Fully qualified name, or a name that includes a global prefix operator, for example, $a = new \currentnamespace\foo(); or \ currentnamespace\foo::staticmethod();. In this case, foo is always resolved to the literal name currentnamespace\foo in the code.

Note that to access any global class, function or constant, you can use a fully qualified name, such as \strlen() or \Exception or \INI_ALL.

Note: The relative path of the file contained in the child file contained by the parent file is for the parent file directory, not the child file directory.

PHP supports two abstract methods of accessing elements within the current namespace, __NAMESPACE__magic constants and namespace keywords.

__NAMESPACE__ can represent a string, and the others are the same as namesapce.

Use the use operator to import/use aliases

<?phpnamespace foo;use My\Full\Classname as Another;// 下面的例子与 use My\Full\NSname as NSname 相同use My\Full\NSname;// 导入一个全局类use ArrayObject;// importing a function (PHP 5.6+)use function My\Full\functionName;// aliasing a function (PHP 5.6+)use function My\Full\functionName as func;// importing a constant (PHP 5.6+)use const My\Full\CONSTANT;$obj = new namespace\Another; // 实例化 foo\Another 对象$obj = new Another; // 实例化 My\Full\Classname　对象NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func$a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象// 如果不使用 "use ArrayObject" ，则实例化一个 foo\ArrayObject 对象func(); // calls function My\Full\functionNameecho CONSTANT; // echoes the value of My\Full

Copy after login

Import/use aliases through the use operator, one line contains multiple use statements

<?phpuse My\Full\Classname as Another, My\Full\NSname;$obj = new Another; // 实例化 My\Full\Classname 对象NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func

Copy after login

Imports and dynamic names

The import operation is performed during compilation, but the dynamic class name, function name or constant name is not.

<?phpuse My\Full\Classname as Another, My\Full\NSname;$obj = new Another; // 实例化一个 My\Full\Classname 对象$a = &#39;Another&#39;;$obj = new $a;      // 实际化一个 Another 对象

Copy after login

Importing and fully qualified names

Import operations only affect unqualified and qualified names. Fully qualified names are not affected by imports because they are deterministic.

<?phpuse My\Full\Classname as Another, My\Full\NSname;$obj = new Another; // instantiates object of class My\Full\Classname$obj = new \Another; // instantiates object of class Another$obj = new Another\thing; // instantiates object of class My\Full\Classname\thing$obj = new \Another\thing; // instantiates object of class Another\thing

Copy after login

Use global space description

<?phpnamespace A\B\C;/* 这个函数是 A\B\C\fopen */function fopen() { 
     /* ... */
     $f = \fopen(...); // 调用全局的fopen函数
     return $f;
}

Copy after login

In a namespace, when PHP encounters an unqualified class, function, or constant name, it uses a different priority strategy to resolve the name . Class names always resolve to names in the current namespace. Therefore when accessing a class name that is internal to the system or not contained in a namespace, you must use the fully qualified name. For functions and constants, if the function or constant does not exist in the current namespace, PHP will fall back to using the function or constant in the global space.

<?phpnamespace A\B\C;class Exception extends \Exception {}$a = new Exception(&#39;hi&#39;); // $a 是类 A\B\C\Exception 的一个对象$b = new \Exception(&#39;hi&#39;); // $b 是类 Exception 的一个对象$c = new ArrayObject; // 致命错误, 找不到 A\B\C\ArrayObject 类

Copy after login

<?phpnamespace A\B\C;const E_ERROR = 45;function strlen($str){
    return \strlen($str) - 1;
}echo E_ERROR, "\n"; // 输出 "45"echo INI_ALL, "\n"; // 输出 "7" - 使用全局常量 INI_ALLecho strlen(&#39;hi&#39;), "\n"; // 输出 "1"if (is_array(&#39;hi&#39;)) { // 输出 "is not array"
    echo "is array\n";
} else {    echo "is not array\n";
}

Copy after login

Name resolution follows the following rules:

Calls to functions, classes, and constants with fully qualified names are resolved at compile time. For example new \A\B resolves to class A\B.
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 A\B\C is imported as C, then calls to C\D\e() are translated to A\B\C\D\e().
在命名空间内部，所有的没有根据导入规则转换的限定名称均会在其前面加上当前的命名空间名称。例如，在命名空间 A\B 内部调用 C\D\e()，则 C\D\e() 会被转换为 A\B\C\D\e() 。
非限定类名根据当前的导入规则在编译时转换（用全名代替短的导入名称）。例如，如果命名空间 A\B\C 导入为C，则 new C() 被转换为 new A\B\C() 。
在命名空间内部（例如A\B），对非限定名称的函数调用是在运行时解析的。例如对函数 foo() 的调用是这样解析的：

在当前命名空间中查找名为 A\B\foo() 的函数
尝试查找并调用全局(global) 空间中的函数 foo()。

在命名空间（例如A\B）内部对非限定名称或限定名称类（非完全限定名称）的调用是在运行时解析的。下面是调用 new C() 及 new D\E() 的解析过程： new C()的解析:
new D\E()的解析:
为了引用全局命名空间中的全局类，必须使用完全限定名称 new \C()。

在类名称前面加上当前命名空间名称变成：A\B\D\E，然后查找该类。
尝试自动装载类 A\B\D\E。
在当前命名空间中查找A\B\C类。
尝试自动装载类A\B\C。

<?phpnamespace 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 F();    // 使用导入规则，创建命名空间 "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"?>

Copy after login