PHP namespace rule parsing and advanced features

One of the most important new features of PHP 5.3 that has recently been released is the addition of namespaces. This article describes some of the terms of the PHP namespace, its parsing rules, and the application of some advanced features, in the hope that it will help readers actually use namespaces in their projects.

Here we introduce the use of the PHP namespace and the namespace keyword, and in this article we will look at the usage command and how PHP resolves the name of the namespace.

For ease of comparison, I've defined two almost identical blocks of code, only the names of namespaces are different.

< PHP //Application library 1 namespace APP\LIB1; Const Myconst = ' App\lib1\myconst '; function MyFunction () { return __function__; } class MyClass { Static function WhoAmI () { Eturn __method__; } } ?>

lib2.php

< PHP //Application Library 2 namespace App\lib2; Const Myconst = ' App\lib2\myconst '; function MyFunction () { return __function__; } class MyClass { Static function WhoAmI () { Eturn __method__; } } ?>

Before you begin, understand several PHP namespace-related terms.

Fully qualified name (fully-qualified name)

Any PHP code can refer to a fully qualified name, which is an identifier that begins with a namespace backslash, such as \app\lib1\myconst,\app\lib2\myfunction ().

The fully qualified name is not ambiguous, the beginning of the backslash and file path function is somewhat similar, it represents the "root" global space, if we implement a different myfunction in the global Space (), you can use the \myfunction () Call it from lib1.php or lib2.php.

Fully qualified names are useful for one-off function calls or object initialization, but they have no practical value when you produce a large number of calls, as we will see in the discussion below that PHP offers other options to remove the annoyance of typing in namespaces.

Qualified names (qualified name)

An identifier for at least one namespace delimiter, such as lib1\myfunction ().

Unqualified names (unqualified name)

An identifier that does not have a namespace delimiter, such as MyFunction ().

Work within the same namespace

Think carefully about the following code:

myapp1.php

< PHP namespace APP\LIB1; require_once (' lib1.php '); require_once (' lib2.php '); Header (' Content-type:text/plain '); Echo Myconst. "\ n"; Echo MyFunction (). "\ n"; Echo Myclass::whoami (). "\ n"; ?>

Even if we include the lib1.php and Lib2.php,myconst,myfunction and MyClass identifiers can only be referenced in lib1.php, this is because the myapp1.php code is in the same APP\LIB1 namespace.

Execution results:

1. App\lib1\myconst
2. App\lib1\myfunction
3. App\lib1\myclass::whoami

Namespace Import

You can import namespaces using the use operator, such as:

myapp2.php

1. < PHP
2. Use APP\LIB2;
4. require_once (' lib1.php ');
5. require_once (' lib2.php ');
7. Header (' Content-type:text/plain ');
8. Echo Lib2\myconst. "\ n";
9. Echo Lib2\myfunction (). "\ n";
10. Echo Lib2\myclass::whoami (). "\ n";
11. ?>

You can define any number of use statements, or separate namespaces with commas, in which we import the App\lib2 namespace, but we still can't refer to myconst,myfunction and MyClass directly, because our code is still in global space, But if we add the "lib2\" prefix, they become qualified names, and PHP searches for the imported namespaces until a match is found.

Execution results:

1. App\lib2\myconst
2. App\lib2\myfunction
3. App\lib2\myclass::whoami

Name Space Alias

Namespace aliases may be the most useful idea, and aliases allow us to refer to long namespaces with shorter names.

myapp3.php

< PHP Use APP\LIB1 as L; Use App\lib2\myclass as OBJ; Header (' Content-type:text/plain '); require_once (' lib1.php '); require_once (' lib2.php '); Echo L\myconst. "\ n"; Echo L\myfunction (). "\ n"; Echo L\myclass::whoami (). "\ n"; Echo Obj::whoami (). "\ n"; ?>

The first Use statement defines APP\LIB1 as "L", and any qualified name that uses "L" is translated to "APP\LIB1" at compile time, so we can reference l\myconst and l\myfunction rather than fully qualified names.

The second use statement defines "obj" as an alias to the MyClass class in the App\lib2\ namespace, which is only suitable for classes and cannot be used for constants and functions, and we now have the option of using new obj () or running static methods like the above.

Execution results:

1. App\lib1\myconst
2. App\lib1\myfunction
3. App\lib1\myclass::whoami
4. App\lib2\myclass::whoami

PHP Naming resolution rules

The PHP identifier name is parsed using the following namespace rules, please refer to the PHP user's manual for more detailed information:

1. Call a fully qualified function, class, or constant at compile time;

2. Unqualified names and qualified names are translated according to the import rules, for example, if a\b\c is imported as C, the call to C\d\e () is translated to A\b\c\d\e ();

3. Within the PHP namespace, all qualified names have not been converted according to the import rule, for example, if C\d\e () is invoked in the namespace a\b, it is translated to a\b\c\d\e ();

4. Unqualified class names are converted according to the current import rule, replacing the imported short name with the full name, for example, if class C is imported as X in the namespace a\b, then New X () is translated to New a\b\c ();

5. Non-qualifying function calls in namespaces are parsed at run time, for example, if MyFunction () is invoked in the namespace a\b, PHP first looks for the function \a\b\myfunction (), if it is not found, then finds \myfunction in the global space ( )；

6. Calling the unqualified or qualified class name is parsed at run time, for example, if we call New C () in the namespace a\b, PHP will look for the class a\b\c, and if not, PHP will try to load a\b\c automatically.

PHP namespace Advanced Features

Next, let's take a look at some of the advanced features of the PHP namespace.

__namespace__ Constants

__namespace__ is a PHP string that always returns the name of the current namespace, which is an empty string in the global space.

< PHP namespace APP\LIB1; Echo __namespace__; ?>

This value is useful when debugging, and it can also be generated by dynamically generating a fully qualified class name, such as:

< ?php   namespace app\lib1;     class  myclass {    public   function  whoami ()  {  return   __method__ ;       }     $c  =& Nbsp;__namespace__ .  ' \\MyClass ' ;   $m  =  new   $c ;   echo  $m ->whoami ()  //  Outputs: app\lib1\myclass::whoami   ?>

namespace keyword

The namespace keyword can be used to explicitly reference an item in the current namespace or child namespace, which is equivalent to the self namespace in the class:

< ?php   namespace  App\Lib1;     class  myclass {    public   function< /font>  whoami ()  {  return  < Strong>__method__ ;       }     $m  =  new  namespace\MyClass;   echo  $m ->whoami ()  //  Outputs: app\lib1\myclass::whoami   ?>

Automatically load namespace classes

The most time-saving and time-saving feature of PHP 5 is automatic loading, in the Global (namespace) PHP code, you can write a standard automatic loading function:

< PHP $obj= new MyClass1 (); $obj= new MyClass2 (); function __autoload ($class _name) { require_once ("classes/$class _name.php"); } ?>

In PHP 5.3, you can create an instance of a namespace class, in which case the fully qualified namespace and class name are passed to the __autoload function, for example, the value of the $class _name may be app\lib1\myclass. You can place all the PHP class files in the same folder and extract the namespaces from the string, but that can cause file name collisions.

In addition, your class file hierarchy is organized according to the namespace structure, for example, myclass.php files can be created under the/CLASSES/APP/LIB1 folder:

/classes/app/lib1/myclass.php

< PHP namespace APP\LIB1; class MyClass { Public function WhoAmI () { return __method__; } } ?>

The file under the root folder uses the following code:

myapp.php

< PHP Use App\lib1\myclass as MC; $obj = new MC (); echo $obj->whoami (); //AutoLoad function function __autoload ($class) { //Convert namespace to full file path $class = ' classes/' . Str_replace (' \ \', '/', $class). '. php '; require_once ($class); } ?>

Explain:

1. The alias of Class App\lib1\myclass is MC;

2. New MC () is translated into new App\lib1\myclass () at compile time;

3. The string App\lib1\myclass is passed to the __autoload function, replaces the backslash in all namespaces with the file path forward slash, and then modifies the string, classes\app\lib1\myclass.php the file is automatically loaded;

Summarize

For the use of the PHP namespace here, I hope you have a new understanding of the PHP namespace and that you will be able to really use namespaces in your new project.