命名空间一个最明确的目的就是解决重名问题，PHP中不允许两个函数或者类出现相同的名字，否则会产生一个致命的错误。这种情况下只要避免命名重复就可以解决

对于命名空间，官方文档已经说得很详细[查看]，我在这里做了一下实践和总结。

命名空间一个最明确的目的就是解决重名问题，PHP中不允许两个函数或者类出现相同的名字，否则会产生一个致命的错误。这种情况下只要避免命名重复就可以解决，最常见的一种做法是约定一个前缀。

例：项目中有两个模块：article和message board，它们各自有一个处理用户留言的类Comment。之后我可能想要增加对所有用户留言的一些信息统计功能，比如说我想得到所有留言的数量。这时候调用它们Comment提供的方法是很好的做法，但是同时引入各自的Comment类显然是不行的，代码会出错，在另一个地方重写任何一个Comment也会降低维护性。那这时只能重构类名，我约定了一个命名规则，在类名前面加上模块名，像这样：Article_Comment、MessageBoard_Comment

可以看到，名字变得很长，那意味着以后使用Comment的时候会写上更多的代码（至少字符多了）。并且，以后如果要对各个模块增加更多的一些整合功能，或者是互相调用，发生重名的时候就需要重构名字。当然在项目开始的时候就注意到这个问题，并规定命名规则就能很好的避免这个问题。另一个解决方法可以考虑使用命名空间。

注明：

本文提到的常量：PHP5.3开始const关键字可以用在类的外部。const和define都是用来声明常量的（它们的区别不详述），但是在命名空间里，define的作用是全局的，而const则作用于当前空间。我在文中提到的常量是指使用const声明的常量。

基础
命名空间将代码划分出不同的空间（区域），每个空间的常量、函数、类（为了偷懒，我下边都将它们称为元素）的名字互不影响，这个有点类似我们常常提到的‘封装'的概念。

创建一个命名空间需要使用namespace关键字，这样：

复制代码代码如下:

<?php

//创建一个名为'Article'的命名空间
namespace Article;

要注意的是，当前脚本文件的第一个命名空间前面不能有任何代码，下面的写法都是错误的：

复制代码代码如下:

//例一
//在脚本前面写了一些逻辑代码

<?php

$path = "/";

class Comment { }

namespace Article;

//例二
//在脚本前面输出了一些字符

<html></html>
<?php

namespace Article;

为什么要说第一个命名空间呢？因为同一脚本文件中可以创建多个命名空间。

下面我创建了两个命名空间，顺便为这两个空间各自添加了一个Comment类元素：

复制代码代码如下:

<?php

//创建一个名为'Article'的命名空间
namespace Article;

//此Comment属于Article空间的元素
class Comment { }

//创建一个名为'MessageBoard'的命名空间
namespace MessageBoard;

//此Comment属于MessageBoard空间的元素
class Comment { }
?>

在不同空间之间不可以直接调用其它元素，需要使用命名空间的语法：

复制代码代码如下:

<?php

namespace Article;

class Comment { }

namespace MessageBoard;

class Comment { }

//调用当前空间（MessageBoard）的Comment类
$comment = new Comment();

//调用Article空间的Comment类
$article_comment = new ArticleComment();

可以看到，在MessageBoard空间中调用article空间里的Comment类时，使用了一种像文件路径的语法：空间名元素名

除了类之外，对函数和常量的用法是一样的，下面我为两个空间创建了新的元素，并在MessageBoard空间中输出了它们的值。

复制代码代码如下:

<?php

namespace Article;

const PATH = '/article';

function getCommentTotal() {
return 100;
}

class Comment { }

namespace MessageBoard;

const PATH = '/message_board';

function getCommentTotal() {
return 300;
}

class Comment { }

//调用当前空间的常量、函数和类
echo PATH; ///message_board
echo getCommentTotal(); //300
$comment = new Comment();

//调用Article空间的常量、函数和类
echo ArticlePATH; ///article
echo ArticlegetCommentTotal(); //100
$article_comment = new ArticleComment();

然后我的确得到了Article空间的元素数据。

子空间
命名空间的调用语法像文件路径一样是有道理的，它允许我们自定义子空间来描述各个空间之间的关系。

抱歉我忘了说，article和message board这两个模块其实都是处于同一个blog项目内。如果用命名空间来表达它们的关系，是这样：

复制代码代码如下:

<?php

//我用这样的命名空间表示处于blog下的article模块
namespace BlogArticle;

class Comment { }

//我用这样的命名空间表示处于blog下的message board模块
namespace BlogMessageBoard;

class Comment { }

//调用当前空间的类
$comment = new Comment();

//调用BlogArticle空间的类
$article_comment = new BlogArticleComment();

而且，子空间还可以定义很多层次，比如说 BlogArticleArchivesDate

公共空间
我有一个common_inc.php脚本文件，里面有一些好用的函数和类：

复制代码代码如下:

<?php

function getIP() { }

class FilterXSS { }

在一个命名空间里引入这个脚本，脚本里的元素不会归属到这个命名空间。如果这个脚本里没有定义其它命名空间，它的元素就始终处于公共空间中：

复制代码代码如下:

<?php

namespace BlogArticle;

//引入脚本文件
include './common_inc.php';

$filter_XSS = new FilterXSS(); //出现致命错误：找不到BlogArticleFilterXSS类

$filter_XSS = new FilterXSS(); //正确

调用公共空间的方式是直接在元素名称前加就可以了，否则PHP解析器会认为我想调用当前空间下的元素。除了自定义的元素，还包括PHP自带的元素，都属于公共空间。

要提一下，其实公共空间的函数和常量不用加也可以正常调用（不明白PHP为什么要这样做），但是为了正确区分元素，还是建议调用函数的时候加上

名称术语
在说别名和导入之前，需要知道关于空间三种名称的术语，以及PHP是怎样解析它们的。官方文档说得非常好，我就直接拿来套了。

1.非限定名称，或不包含前缀的类名称，例如 $comment = new Comment();。如果当前命名空间是BlogArticle，Comment将被解析为BlogArticleComment。如果使用Comment的代码不包含在任何命名空间中的代码（全局空间中），则Comment会被解析为Comment。

2.限定名称，或包含前缀的名称，例如 $comment = new ArticleComment();。如果当前的命名空间是Blog，则Comment会被解析为BlogArticleComment。如果使用Comment的代码不包含在任何命名空间中的代码（全局空间中），则Comment会被解析为Comment。

3.完全限定名称，或包含了全局前缀操作符的名称，例如 $comment = new ArticleComment();。在这种情况下，Comment总是被解析为代码中的文字名(literal name)ArticleComment。

其实可以把这三种名称类比为文件名（例如 comment.php）、相对路径名（例如 ./article/comment.php）、绝对路径名（例如 /blog/article/comment.php），这样可能会更容易理解。

我用了几个示例来表示它们：

复制代码代码如下:

<?php

//创建空间Blog
namespace Blog;

class Comment { }

//非限定名称，表示当前Blog空间
//这个调用将被解析成 BlogComment();
$blog_comment = new Comment();

//限定名称，表示相对于Blog空间
//这个调用将被解析成 BlogArticleComment();
$article_comment = new ArticleComment(); //类前面没有反斜杆

//完全限定名称，表示绝对于Blog空间
//这个调用将被解析成 BlogComment();
$article_comment = new BlogComment(); //类前面有反斜杆

//完全限定名称，表示绝对于Blog空间
//这个调用将被解析成 BlogArticleComment();
$article_comment = new BlogArticleComment(); //类前面有反斜杆

//创建Blog的子空间Article
namespace BlogArticle;

class Comment { }

其实之前我就一直在使用非限定名称和完全限定名称，现在它们终于可以叫出它们的名称了。

别名和导入
别名和导入可以看作是调用命名空间元素的一种快捷方式。PHP并不支持导入函数或常量。

它们都是通过使用use操作符来实现：

复制代码代码如下:

<?php

namespace BlogArticle;

class Comment { }

//创建一个BBS空间（我有打算开个论坛）
namespace BBS;

//导入一个命名空间
use BlogArticle;
//导入命名空间后可使用限定名称调用元素
$article_comment = new ArticleComment();

//为命名空间使用别名
use BlogArticle as Arte;
//使用别名代替空间名
$article_comment = new ArteComment();

//导入一个类
use BlogArticleComment;
//导入类后可使用非限定名称调用元素
$article_comment = new Comment();

//为类使用别名
use BlogArticleComment as Comt;
//使用别名代替空间名
$article_comment = new Comt();

我注意到，如果导入元素的时候，当前空间有相同的名字元素将会怎样？显然结果会发生致命错误。

例：

复制代码代码如下:

<?php

namespace BlogArticle;

class Comment { }

namespace BBS;

class Comment { }

Class Comt { }

//导入一个类
use BlogArticleComment;
$article_comment = new Comment(); //与当前空间的Comment发生冲突，程序产生致命错误

//为类使用别名
use BlogArticleComment as Comt;
$article_comment = new Comt(); //与当前空间的Comt发生冲突，程序产生致命错误

动态调用
PHP提供了namespace关键字和__NAMESPACE__魔法常量动态的访问元素，__NAMESPACE__可以通过组合字符串的形式来动态访问：

复制代码代码如下:

<?php

namespace BlogArticle;

const PATH = '/Blog/article';

class Comment { }

//namespace关键字表示当前空间
echo namespacePATH; ///Blog/article
$comment = new namespaceComment();

//魔法常量__NAMESPACE__的值是当前空间名称
echo __NAMESPACE__; //BlogArticle
//可以组合成字符串并调用
$comment_class_name = __NAMESPACE__ . 'Comment';
$comment = new $comment_class_name();

字符串形式调用问题

上面的动态调用的例子中，我们看到了字符串形式的动态调用方式，如果要使用这种方式要注意两个问题。

1. 使用双引号的时候特殊字符可能被转义

复制代码代码如下:

<?php

namespace BlogArticle;

class name { }

//我是想调用BlogArticle ame
$class_name = __NAMESPACE__ . " ame"; //但是将被转义为换行符

$name = new $class_name(); //发生致命错误

2. 不会认为是限定名称

PHP在编译脚本的时候就确定了元素所在的空间，以及导入的情况。而在解析脚本时字符串形式调用只能认为是非限定名称和完全限定名称，而永远不可能是限定名称。

复制代码代码如下:

<?php

namespace Blog;

//导入Common类
use BlogArticleCommon;
//我想使用非限定名称调用BlogArticleCommon
$common_class_name = 'Common';
//实际会被当作非限定名称，也就表示当前空间的Common类，但我当前类没有创建Common类
$common = new $common_class_name(); //发生致命错误：Common类不存在

//我想使用限定名称调用BlogArticleCommon
$common_class_name = 'ArticleCommon';
//实际会被当作完全限定名称，也就表示Article空间下的Common类，但我下面只定义了BlogArticle空间而不是Article空间
$common = new $common_class_name(); //发生致命错误：ArticleCommon类不存在

namespace BlogArticle;

class Common { }

总结
我对PHP的命名空间刚刚接触，也不能随便给一些没有实践的建议。我个人认为命名空间的作用和功能都很强大，如果要写插件或者通用库的时候再也不用担心重名问题。不过如果项目进行到一定程度，要通过增加命名空间去解决重名问题，我觉得工作量不会比重构名字少。也不得不承认它的语法会对项目增加一定的复杂度，因此从项目一开始的时候就应该很好的规划它，并制定一个命名规范。

PHP 命名空间(namespace)

PHP 命名空间(namespace)是在PHP 5.3中加入的，如果你学过C#和Java，那命名空间就不算什么新事物。不过在PHP当中还是有着相当重要的意义。

PHP 命名空间可以解决以下两类问题：

用户编写的代码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突。
为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名（或简短）的名称，提高源代码的可读性。

定义命名空间

默认情况下，所有常量、类和函数名都放在全局空间下，就和PHP支持命名空间之前一样。

命名空间通过关键字namespace 来声明。如果一个文件中包含命名空间，它必须在其它所有代码之前声明命名空间。语法格式如下；

< ?php  
// 定义代码在 'MyProject' 命名空间中  
namespace MyProject;  
 
// ... 代码 ...

你也可以在同一个文件中定义不同的命名空间代码，如：

< ?php  
namespace MyProject1;  
// MyProject1 命名空间中的PHP代码  
 
namespace MyProject2;  
// MyProject2 命名空间中的PHP代码    
 
// 另一种语法
namespace MyProject3 {  
 // MyProject3 命名空间中的PHP代码    
}  
?>

在声明命名空间之前唯一合法的代码是用于定义源文件编码方式的 declare 语句。所有非 PHP 代码包括空白符都不能出现在命名空间的声明之前。

<?php
declare(encoding='UTF-8'); //定义多个命名空间和不包含在命名空间中的代码
namespace MyProject {

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */  }
}

namespace { // 全局代码
session_start();
$a = MyProjectconnect();
echo MyProjectConnection::start();
}
?>

以下代码会出现语法错误：

<html>
<?php
namespace MyProject; // 命名空间前出现了“<html>” 会致命错误 -　命名空间必须是程序脚本的第一条语句
?>

子命名空间

与目录和文件的关系很象，PHP 命名空间也允许指定层次化的命名空间的名称。因此，命名空间的名字可以使用分层次的方式定义：

<?php
namespace MyProjectSubLevel;  //声明分层次的单个命名空间

const CONNECT_OK = 1;
class Connection { /* ... */ }
function Connect() { /* ... */  }

?>

上面的例子创建了常量 MyProjectSubLevelCONNECT_OK，类 MyProjectSubLevelConnection 和函数 MyProjectSubLevelConnect。

命名空间使用

PHP 命名空间中的类名可以通过三种方式引用：

非限定名称，或不包含前缀的类名称，例如 $a=new foo(); 或 foo::staticmethod();。如果当前命名空间是 currentnamespace，foo 将被解析为 currentnamespacefoo。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，则 foo 会被解析为foo。警告：如果命名空间中的函数或常量未定义，则该非限定的函数名称或常量名称会被解析为全局函数名称或常量名称。
限定名称,或包含前缀的名称，例如 $a = new subnamespacefoo(); 或 subnamespacefoo::staticmethod();。如果当前的命名空间是 currentnamespace，则 foo 会被解析为 currentnamespacesubnamespacefoo。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，foo 会被解析为subnamespacefoo。
完全限定名称，或包含了全局前缀操作符的名称，例如， $a = new currentnamespacefoo(); 或 currentnamespacefoo::staticmethod();。在这种情况下，foo 总是被解析为代码中的文字名(literal name)currentnamespacefoo。

下面是一个使用这三种方式的实例：

file1.php 文件代码

<?php
namespace FooBarsubnamespace; 

const FOO = 1;
function foo() {}
class foo
{
    static function staticmethod() {}
}
?>

file2.php 文件代码

<?php
namespace FooBar;
include 'file1.php';

const FOO = 2;
function foo() {}
class foo
{
    static function staticmethod() {}
}

/* 非限定名称 */
foo(); // 解析为 FooBarfoo resolves to function FooBarfoo
foo::staticmethod(); // 解析为类 FooBarfoo的静态方法staticmethod。resolves to class FooBarfoo, method staticmethod
echo FOO; // resolves to constant FooBarFOO

/* 限定名称 */
subnamespacefoo(); // 解析为函数 FooBarsubnamespacefoo
subnamespacefoo::staticmethod(); // 解析为类 FooBarsubnamespacefoo,
                                  // 以及类的方法 staticmethod
echo subnamespaceFOO; // 解析为常量 FooBarsubnamespaceFOO
                                  
/* 完全限定名称 */
FooBarfoo(); // 解析为函数 FooBarfoo
FooBarfoo::staticmethod(); // 解析为类 FooBarfoo, 以及类的方法 staticmethod
echo FooBarFOO; // 解析为常量 FooBarFOO
?>

注意访问任意全局类、函数或常量，都可以使用完全限定名称，例如 strlen() 或 Exception 或 INI_ALL。

在命名空间内部访问全局类、函数和常量：

<?php
namespace Foo;

function strlen() {}
const INI_ALL = 3;
class Exception {}

$a = strlen('hi'); // 调用全局函数strlen
$b = INI_ALL; // 访问全局常量 INI_ALL
$c = new Exception('error'); // 实例化全局类 Exception
?>

命名空间和动态语言特征

PHP 命名空间的实现受到其语言自身的动态特征的影响。因此，如果要将下面的代码转换到命名空间中，动态访问元素。

example1.php 文件代码：

<?php
class classname
{
    function __construct()
    {
        echo __METHOD__,"
";
    }
}
function funcname()
{
    echo __FUNCTION__,"
";
}
const constname = "global";

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "
"; // prints global
?>

必须使用完全限定名称（包括命名空间前缀的类名称）。注意因为在动态的类名称、函数名称或常量名称中，限定名称和完全限定名称没有区别，因此其前导的反斜杠是不必要的。

动态访问命名空间的元素

<?php
namespace namespacename;
class classname
{
    function __construct()
    {
        echo __METHOD__,"
";
    }
}
function funcname()
{
    echo __FUNCTION__,"
";
}
const constname = "namespaced";

include 'example1.php';

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "
"; // prints global

/* note that if using double quotes, "\namespacename\classname" must be used */
$a = '
amespacenameclassname';
$obj = new $a; // prints namespacenameclassname::__construct
$a = 'namespacenameclassname';
$obj = new $a; // also prints namespacenameclassname::__construct
$b = 'namespacenamefuncname';
$b(); // prints namespacenamefuncname
$b = '
amespacenamefuncname';
$b(); // also prints namespacenamefuncname
echo constant('
amespacenameconstname'), "
"; // prints namespaced
echo constant('namespacenameconstname'), "
"; // also prints namespaced
?>

namespace关键字和NAMESPACE常量

PHP支持两种抽象的访问当前命名空间内部元素的方法，__NAMESPACE__ 魔术常量和namespace关键字。

常量__NAMESPACE__的值是包含当前命名空间名称的字符串。在全局的，不包括在任何命名空间中的代码，它包含一个空的字符串。

__NAMESPACE__ 示例, 在命名空间中的代码

<?php
namespace MyProject;

echo '"', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

__NAMESPACE__ 示例，全局代码

<?php

echo '"', __NAMESPACE__, '"'; // 输出 ""
?>

常量 __NAMESPACE__ 在动态创建名称时很有用，例如：

使用__NAMESPACE__动态创建名称

<?php
namespace MyProject;

function get($classname)
{
    $a = __NAMESPACE__ . '\' . $classname;
    return new $a;
}
?>

关键字 namespace 可用来显式访问当前命名空间或子命名空间中的元素。它等价于类中的 self 操作符。

amespace操作符，命名空间中的代码

<?php
namespace MyProject;

use blahlah as mine; // see "Using namespaces: importing/aliasing"

blahmine(); // calls function blahlahmine()
namespacelahmine(); // calls function MyProjectlahmine()

namespacefunc(); // calls function MyProjectfunc()
namespacesubfunc(); // calls function MyProjectsubfunc()
namespacecname::method(); // calls static method "method" of class MyProjectcname
$a = new namespacesubcname(); // instantiates object of class MyProjectsubcname
$b = namespaceCONSTANT; // assigns value of constant MyProjectCONSTANT to $b
?>

namespace操作符, 全局代码

<?php

namespacefunc(); // calls function func()
namespacesubfunc(); // calls function subfunc()
namespacecname::method(); // calls static method "method" of class cname
$a = new namespacesubcname(); // instantiates object of class subcname
$b = namespaceCONSTANT; // assigns value of constant CONSTANT to $b
?>

使用命名空间：别名/导入

PHP 命名空间支持有两种使用别名或导入方式：为类名称使用别名，或为命名空间名称使用别名。注意PHP不支持导入函数或常量。

在PHP中，别名是通过操作符 use 来实现的. 下面是一个使用所有可能的三种导入方式的例子：

1、使用use操作符导入/使用别名

<?php
namespace foo;
use MyFullClassname as Another;

// 下面的例子与 use MyFullNSname as NSname 相同
use MyFullNSname;

// 导入一个全局类
use ArrayObject;

$obj = new namespaceAnother; // 实例化 fooAnother 对象
$obj = new Another; // 实例化 MyFullClassname　对象
NSnamesubnsfunc(); // 调用函数 MyFullNSnamesubnsfunc
$a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象
// 如果不使用 "use ArrayObject" ，则实例化一个 fooArrayObject 对象
?>

2、一行中包含多个use语句

<?php
use MyFullClassname as Another, MyFullNSname;

$obj = new Another; // 实例化 MyFullClassname 对象
NSnamesubnsfunc(); // 调用函数 MyFullNSnamesubnsfunc
?>

导入操作是在编译执行的，但动态的类名称、函数名称或常量名称则不是。

3、导入和动态名称

<?php
use MyFullClassname as Another, MyFullNSname;

$obj = new Another; // 实例化一个 MyFullClassname 对象
$a = 'Another';
$obj = new $a;      // 实际化一个 Another 对象
?>

另外，导入操作只影响非限定名称和限定名称。完全限定名称由于是确定的，故不受导入的影响。

4、导入和完全限定名称

<?php
use MyFullClassname as Another, MyFullNSname;

$obj = new Another; // instantiates object of class MyFullClassname
$obj = new Another; // instantiates object of class Another
$obj = new Another	hing; // instantiates object of class MyFullClassname	hing
$obj = new Another	hing; // instantiates object of class Another	hing
?>

使用命名空间：后备全局函数/常量

在一个命名空间中，当 PHP 遇到一个非限定的类、函数或常量名称时，它使用不同的优先策略来解析该名称。类名称总是解析到当前命名空间中的名称。因此在访问系统内部或不包含在命名空间中的类名称时，必须使用完全限定名称，例如：

1、在命名空间中访问全局类

<?php
namespace ABC;
class Exception extends Exception {}

$a = new Exception('hi'); // $a 是类 ABCException 的一个对象
$b = new Exception('hi'); // $b 是类 Exception 的一个对象

$c = new ArrayObject; // 致命错误, 找不到 ABCArrayObject 类
?>

对于函数和常量来说，如果当前命名空间中不存在该函数或常量，PHP 会退而使用全局空间中的函数或常量。

2、命名空间中后备的全局函数/常量

<?php
namespace ABC;

const E_ERROR = 45;
function strlen($str)
{
    return strlen($str) - 1;
}

echo E_ERROR, "
"; // 输出 "45"
echo INI_ALL, "
"; // 输出 "7" - 使用全局常量 INI_ALL

echo strlen('hi'), "
"; // 输出 "1"
if (is_array('hi')) { // 输出 "is not array"
    echo "is array
";
} else {
    echo "is not array
";
}
?>

全局空间

如果没有定义任何命名空间，所有的类与函数的定义都是在全局空间，与 PHP 引入命名空间概念前一样。在名称前加上前缀表示该名称是全局空间中的名称，即使该名称位于其它的命名空间中时也是如此。

使用全局空间说明

<?php
namespace ABC;

/* 这个函数是 ABCfopen */
function fopen() { 
     /* ... */
     $f = fopen(...); // 调用全局的fopen函数
     return $f;
} 
?>

命名空间的顺序

自从有了命名空间之后，最容易出错的该是使用类的时候，这个类的寻找路径是什么样的了。

<?php
namespace A;
use BD, CE as F;

// 函数调用

foo();      // 首先尝试调用定义在命名空间"A"中的函数foo()
            // 再尝试调用全局函数 "foo"

foo();     // 调用全局空间函数 "foo" 

myfoo();   // 调用定义在命名空间"Amy"中函数 "foo" 

F();        // 首先尝试调用定义在命名空间"A"中的函数 "F" 
            // 再尝试调用全局函数 "F"

// 类引用

new B();    // 创建命名空间 "A" 中定义的类 "B" 的一个对象
            // 如果未找到，则尝试自动装载类 "AB"

new D();    // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象
            // 如果未找到，则尝试自动装载类 "BD"

new F();    // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象
            // 如果未找到，则尝试自动装载类 "CE"

new B();   // 创建定义在全局空间中的类 "B" 的一个对象
            // 如果未发现，则尝试自动装载类 "B"

new D();   // 创建定义在全局空间中的类 "D" 的一个对象
            // 如果未发现，则尝试自动装载类 "D"

new F();   // 创建定义在全局空间中的类 "F" 的一个对象
            // 如果未发现，则尝试自动装载类 "F"

// 调用另一个命名空间中的静态方法或命名空间函数

Bfoo();    // 调用命名空间 "AB" 中函数 "foo"

B::foo();   // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法
            // 如果未找到类 "AB" ，则尝试自动装载类 "AB"

D::foo();   // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法
            // 如果类 "BD" 未找到，则尝试自动装载类 "BD"

Bfoo();   // 调用命名空间 "B" 中的函数 "foo" 

B::foo();  // 调用全局空间中的类 "B" 的 "foo" 方法
            // 如果类 "B" 未找到，则尝试自动装载类 "B"

// 当前命名空间中的静态方法或函数

AB::foo();   // 调用命名空间 "AA" 中定义的类 "B" 的 "foo" 方法
              // 如果类 "AAB" 未找到，则尝试自动装载类 "AAB"

AB::foo();  // 调用命名空间 "AB" 中定义的类 "B" 的 "foo" 方法
              // 如果类 "AB" 未找到，则尝试自动装载类 "AB"
?>

名称解析遵循下列规则：

对完全限定名称的函数，类和常量的调用在编译时解析。例如 new AB 解析为类 AB。
所有的非限定名称和限定名称（非完全限定名称）根据当前的导入规则在编译时进行转换。例如，如果命名空间 ABC 被导入为 C，那么对 CDe() 的调用就会被转换为 ABCDe()。
在命名空间内部，所有的没有根据导入规则转换的限定名称均会在其前面加上当前的命名空间名称。例如，在命名空间 AB 内部调用CDe()，则 CDe() 会被转换为 ABCDe() 。
非限定类名根据当前的导入规则在编译时转换（用全名代替短的导入名称）。例如，如果命名空间 ABC 导入为C，则 new C() 被转换为 new ABC() 。
在命名空间内部（例如AB），对非限定名称的函数调用是在运行时解析的。例如对函数 foo() 的调用是这样解析的：
1. 在当前命名空间中查找名为 ABfoo() 的函数
2. 尝试查找并调用 全局(global) 空间中的函数 foo()。
在命名空间（例如AB）内部对非限定名称或限定名称类（非完全限定名称）的调用是在运行时解析的。下面是调用 new C() 及 new DE() 的解析过程： new C()的解析:
1. 在当前命名空间中查找ABC类。
2. 尝试自动装载类ABC。
new DE()的解析:
1. 在类名称前面加上当前命名空间名称变成：ABDE，然后查找该类。
2. 尝试自动装载类 ABDE。
为了引用全局命名空间中的全局类，必须使用完全限定名称 new C()。

php命名空间详解

PHP命名空间(Namespace)的使用详解

PHP 命名空间(namespace)

定义命名空间

子命名空间

命名空间使用

命名空间和动态语言特征

namespace关键字和NAMESPACE常量

使用命名空间：别名/导入

使用命名空间：后备全局函数/常量

全局空间

命名空间的顺序

php命名空间详解

PHP命名空间(Namespace)的使用详解

PHP 命名空间(namespace)

定义命名空间

子命名空间

命名空间使用

命名空间和动态语言特征

namespace关键字和__NAMESPACE__常量

使用命名空间：别名/导入

使用命名空间：后备全局函数/常量

全局空间

命名空间的顺序

namespace关键字和NAMESPACE常量