Some thoughts on namespaces, a key feature of PHP! ! !

Do you know that namespaces are mainly used to solve the problem of possible conflicts between classes and functions in the code? This feature has been available in other languages ​​for a long time, but PHP was late in arriving. Its emergence gave birth to PSR-4, which also gave birth to the rise of Composer, so it is a very important feature.

Definition of namespace

A namespace is a container, which is mainly used to identify the classes and functions under it. Once a namespace is defined, the code below it belongs to this namespace, so the definition of the namespace should be at the very beginning of the code.

For the same package, the code in the same namespace or sub-namespace does not need to be defined in a PHP file. The code in the sub-namespace is to complete the work of a specific module. When combined, it becomes a Package complete namespace.

If the code you write does not define a namespace, it means that it belongs to the global namespace (\ symbol), so you can directly reference the class or function (without adding the \ symbol).

Three ways to reference namespace identifiers

(1) Fully-qualified name

is similar to the absolute path on the operating system, and It is the complete path, so there will be no misunderstanding when understanding it.
For example, in new \A\B\C, then C will be resolved to the C class under the A\B namespace.

(2) Qualified name

is similar to a relative path on the operating system. It contains part of the name and is referenced to the current namespace.
For example, if B\C() is called under namespace A, the finally referenced namespace is A\B\C().

(3) Unqualified name

is similar to Qualified name, but does not include sub-namespaces.
For example, if C() is called under the namespace A\B, the finally referenced namespace is A\B\C().

Illustrate the three reference methods through an example:

namespace \Example;
require_once "fnction.php";
class ClassA {}
function Function() {}

//完全限定名称
\Example\Function();
\Example\B\Function(); 

//限定名称
B\Function(); //指向 \Example\B\Function();

//非限定名称
$test = new ClassA(); //resolves to \Example\ClassA
Function(); //指向 \Example\Function

Note:

• Inside a namespace, if it is not found in the current scope For the definition of functions and constants, PHP will not report errors. Instead, look for it in the global namespace.
• Inside a namespace, if no class definition is found in the current scope, PHP will report an error directly and will not go to the global scope to find the corresponding class, so if you need to reference an internal or user-defined class , a fully qualified name must be used.

Let’s take a simple example first. First write a piece of code (defined in the namespace) and name it function.php:

namespace Foo\Bar\subnamespace;
const FOO = 1;
function foo() 
{
    return "foo\r\n";
}
class foo 
{
    static function staticmethod()
    {
        return __METHOD__ . "\r\n" ;
    }

    function foofunction()
    {
        return __METHOD__ . "\r\n" ;
    }
}

Then write a piece of code test.php, too. Code under the namespace:

namespace secondsp;
include 'function.php';

class foo
{
    function foofunction()
    {
        return __METHOD__ . "\r\n" ;
    }
}

function is_file($file)
{
    return true ;
}
 
//非限定名称:实例化secondsp\foo类对象
$obj = new foo;  
echo $obj->foofunction();

//实例化Foo\Bar\subnamespace\foo 类对象
$obj = new Foo\Bar\subnamespace\foo ;
echo $obj->foofunction();

//代码会报错，在命名空间内部，假如无法找到当前命名空间下的类，则会报错
//$obj = new ArrayObject(array(1)); 
$obj = new \ArrayObject(array(1)); 

//在命名空间内部，假如无法找到当前命名空间下的函数或者常量，则会寻找 native function
echo  strlen("nihao");

 //引用当前命名空间下的函数
var_dump(is_file('nihao')); //True
//引用全局函数
var_dump(\is_file('nihao')); //False

Import, alias

If the namespace level to be used is long and numerous, it will be particularly troublesome to use. , so you can use the use keyword to import namespaces, classes, constants, functions, etc., and then use them to directly reference the full name. The alias keyword can rename imported classes and functions.

For example, how to use the use keyword, the code is under the global namespace:

include 'function.php';

use Foo\Bar\subnamespace\foo ;
$obj = new foo;
echo $obj->foofunction();

use Foo\Bar\subnamespace\foo  as aliasfunname;
$obj = new aliasfunname;
echo $obj->foofunction();
 
use Foo\Bar\subnamespace ; 
$obj = new subnamespace\foo ;
echo $obj->foofunction();

use Foo\Bar\subnamespace  as aliasname;
$obj = new aliasname\foo ;
echo $obj->foofunction();

//由于调用代码并不在命名空间内，所以对于全局的类，无需引入使用
$obj = new ArrayObject(array(1)); 

//导入一个函数
use function Foo\Bar\subnamespace\foo   ;
echo foo();
 
use function Foo\Bar\subnamespace\foo  as func;
echo func();
 
use const  Foo\Bar\subnamespace\FOO;
//echo FOO;

Summary:

• and Python Differently, the namespace in PHP is a semantic concept and has nothing to do with the location and layout of the specific code. In other words, the code that uses the namespace needs to import the library files (all files) by itself. As for how the library files are organized It doesn't matter; in Python, if there is an __init__.py file in a module or package, the Python parser will automatically import the files of the package or all modules.
• The concept of scope in PHP is very weak, and the global domain and the local domain are clearly distinguished. For example, variables in the global space cannot be referenced in functions or classes. The situation is different in namespaces. If the code that defines the namespace cannot find the constants and functions in the corresponding namespace, it will use global constants and functions; and if it cannot find the class in the corresponding namespace (including its own Define class), the code will report an error directly.
• If you use the namespace through the use keyword, you do not need to import it through the fully qualified name (\ symbol), because PHP already assumes that the imported namespace is a fully qualified namespace.
• Constants, functions, classes, interfaces, and other namespaces can be imported through the use keyword.

• Namespace is a language feature. In order to pursue more effective use, there should be a usage specification and automatic loading mechanism. This is the PSR-4 specification.

Recommended learning: "PHP Video Tutorial"

The above is the detailed content of Some thoughts on namespaces, a key feature of PHP! ! !. For more information, please follow other related articles on the PHP Chinese website!