PHP 5.3 New Feature namespace rule parsing and advanced features _php tutorial

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

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

For the sake of comparison, I defined two almost the same block of code, with only a different name for the namespace.

< 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 reference 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 the role of the file path is somewhat similar, it represents the "root" global space, if we implement a different MyFunction in the global Space (), you can use \myfunction () Call it from lib1.php or lib2.php.

Fully qualified names are useful for one-time function calls or object initialization, but when you generate a large number of calls they are of no practical value, as we will see in the following discussion that PHP offers other options to relieve us of the hassle of typing in namespaces.

Qualified name (qualified name)

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

Unqualified names (Unqualified name)

An identifier without a namespace delimiter, such as MyFunction ().

Working 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 both the lib1.php and the Lib2.php,myconst,myfunction and the MyClass identifiers can only be referenced in lib1.php, this is because the myapp1.php code is within the same APP\LIB1 namespace.

Execution Result:

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

Namespace Import

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

myapp2.php

< PHP use app\lib2; require_once ( ' lib1.php ' ); require_once ( ' lib2.php ' ); header ( "content-type:text/ Plain ' ); echo lib2\myconst. "\ n" ; echo lib2\myfunction (). "\ n" ; echo Lib2\myclass::whoami (). "\ n" ; ?>

Any number of use statements can be defined, or separated into separate namespaces using commas, in which case we have imported the App\lib2 namespace, but we still cannot refer directly to Myconst,myfunction and MyClass because our code is still in the global space. But if we add the "lib2\" prefix, they become qualified names, and PHP will search for the imported namespaces until a match is found.

Execution Result:

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

namespace aliases

Namespace aliases are probably the most useful idea, and aliases allow us to reference very 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 using "L" will be translated to "APP\LIB1" at compile time, so we can refer to L\myconst and l\myfunction instead of fully qualified names.

The second use statement defines "obj" as an alias for the MyClass class in the App\lib2\ namespace, which is only suitable for classes, not constants and functions, and now we can run static methods using new obj () or as above.

Execution Result:

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

PHP Naming resolution rules

PHP identifier names are resolved using the following namespace rules, please refer to the PHP user manual for more detailed information:

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

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

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

4. The unqualified class name is 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 the namespace are resolved at run time, for example, if MyFunction () is called in the namespace a\b, PHP first looks for the function \a\b\myfunction (), and if it is not found, then finds \myfunction in the global space ( )；

6. Call unqualified or qualified class names are parsed at run time, for example, if we call New C () in the namespace a\b, PHP will look for class a\b\c, and if not found, PHP will attempt to automatically load a\b\c.

PHP namespace Advanced Features

Now 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 ?>

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 = __namespace__. ' \\MyClass ' ; $m = New $c; Echo $m->whoami (); //Outputs:app\lib1\myclass::whoami ?>

namespace keywords

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 WhoAmI () { return __method__; } } $m = New Namespace\myclass; Echo $m->whoami (); //Outputs:app\lib1\myclass::whoami ?>

Automatically load namespace classes

The most time-saving feature in PHP 5 is auto-loading, and in the global (non-namespace) PHP code, you can write a standard auto-load function:

< PHP $obj = New MyClass1 (); //classes/myclass1.php is auto-loaded $obj = New MyClass2 (); //classes/myclass2.php is auto-loaded //AutoLoad function 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 $class _name may be app\lib1\myclass. You can place all the PHP class files under the same folder, extracting the namespaces from the string, but that can cause file name collisions.

In addition, your class file hierarchy will be re-organized according to the structure of the namespace, for example, the myclass.php file 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, replacing the backslash in all namespaces with a file-path forward slash, and then modifying the string, classes\app\lib1\myclass.php the file is automatically loaded;

Summarize

The use of the PHP namespace is introduced here, I hope you can have a new understanding of the PHP namespace, and I hope you can really use the namespace in the new project.

http://www.bkjia.com/PHPjc/321331.html www.bkjia.com true http://www.bkjia.com/PHPjc/321331.html techarticle one of the most important new features of PHP 5.3 that has been released recently is the addition of namespaces. This article describes some of the terminology of the PHP namespace, its parsing rules, and the application of some advanced features ...

