Examples of detailed explanation of PHP namespace usage

The namespace is mainly to solve the problem of possible conflicts between classes and functions in the code. This article introduces the key features of PHP, namespace, including the definition of namespace and other knowledge points. Friends who need it can refer to it

Namespace is mainly to solve the problem of possible conflicts between classes and functions in the code. , while other languages ​​have had this feature for a long time, PHP came late. 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 parsed 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 citation 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 no definitions of functions and constants are found in the current scope, PHP will not report an error. 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, the 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" ;
  }
}

Write another piece of code The code test.php is also the 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 you want to use the name If the space hierarchy is long and numerous, it is particularly troublesome to use. Therefore, you can use the use keyword to import namespaces, classes, constants, functions, etc., and then use them to directly reference the complete names. The alias keyword can rename imported classes and functions.

For example, how to use the use keyword, this 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:

•Unlike Python, 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, code that uses the namespace needs to introduce its own library files (all files ), it doesn’t matter how the library files are organized; 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.

The above is the detailed content of Examples of detailed explanation of PHP namespace usage. For more information, please follow other related articles on the PHP Chinese website!