Yii2框架：命名空间

命名空间概述
 
(PHP 5 >= 5.3.0, PHP 7)
什么是命名空间？从广义上来说，命名空间是一种封装事物的方法。在很多地方都可以见到这种抽象概念。例如，在操作系统中目录用来将相关文件分组，对于目录中的文件来说，它就扮演了命名空间的角色。具体举个例子，文件foo.txt 可以同时在目录/home/greg 和 /home/other 中存在，但在同一个目录中不能存在两个 foo.txt 文件。另外，在目录 /home/greg 外访问 foo.txt 文件时，我们必须将目录名以及目录分隔符放在文件名之前得到/home/greg/foo.txt。这个原理应用到程序设计领域就是命名空间的概念。
在PHP中，命名空间用来解决在编写类库或应用程序时创建可重用的代码如类或函数时碰到的两类问题：

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

PHP 命名空间提供了一种将相关的类、函数和常量组合到一起的途径。
 
如何声明？
 
(PHP 5 >= 5.3.0, PHP 7)
虽然任意合法的PHP代码都可以包含在命名空间中，但只有以下类型的代码受命名空间的影响，它们是：类（包括抽象类和traits）、接口、函数和常量。

命名空间通过关键字namespace 来声明。如果一个文件中包含命名空间，它必须在其它所有代码之前声明命名空间，除了一个以外：declare关键字。
test1.php

<?php

namespace MyProject;



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }

?>



test2.php

<html>

<?php

namespace MyProject; // 致命错误 -　命名空间必须是程序脚本的第一条语句

?>

 在声明命名空间之前唯一合法的代码是用于定义源文件编码方式的 declare 语句。另外，所有非 PHP 代码包括空白符都不能出现在命名空间的声明之前。另外，与PHP其它的语言特征不同，同一个命名空间可以定义在多个文件中，即允许将同一个命名空间的内容分割存放在不同的文件中。

定义子命名空间

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

namespace MyProject\Sub\Level;



const CONNECT_OK = 1;             //常量MyProject\Sub\Level\CONNECT_OK

class Connection { /* ... */ }    //类 MyProject\Sub\Level\Connection

function connect() { /* ... */  } //函数MyProject\Sub\Level\connect

?>
在同一个文件中定义多个命名空间

也可以在同一个文件中定义多个命名空间。在同一个文件中定义多个命名空间有两种语法形式。
 
<?php

namespace MyProject;



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }



namespace AnotherProject;



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }

?>



//不建议使用这种语法在单个文件中定义多个命名空间。建议使用下面的大括号形式的语法



//定义多个命名空间，大括号语法

<?php

namespace MyProject {



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }

}



namespace AnotherProject {



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }

}

?>
在实际的编程实践中，非常不提倡在同一个文件中定义多个命名空间。这种方式的主要用于将多个 PHP 脚本合并在同一个文件中。

将全局的非命名空间中的代码与命名空间中的代码组合在一起，只能使用大括号形式的语法。全局代码必须用一个不带名称的 namespace 语句加上大括号括起来。
//定义多个命名空间和不包含在命名空间中的代码

<?php

declare(encoding='UTF-8'); //除了开始的declare语句外，命名空间的括号外不得有任何PHP代码。

namespace MyProject {



const CONNECT_OK = 1;

class Connection { /* ... */ }

function connect() { /* ... */  }

}



namespace { // global 



codesession_start();

$a = MyProject\connect();

echo MyProject\Connection::start();

}

?>

 使用命名空间：基础
 
在讨论如何使用命名空间之前，必须了解 PHP是如何知道要使用哪一个命名空间中的元素的。可以将 PHP命名空间与文件系统作一个简单的类比。在文件系统中访问一个文件有三种方式：
  1. 相对文件名形式如foo.txt。它会被解析为currentdirectory/foo.txt，其中 currentdirectory表示当前目录。因此如果当前目录是/home/foo，则该文件名被解析为/home/foo/foo.txt。
  2. 相对路径名形式如subdirectory/foo.txt。它会被解析为currentdirectory/subdirectory/foo.txt。
  3. 绝对路径名形式如/main/foo.txt。它会被解析为/main/foo.txt。


PHP 命名空间中的元素使用同样的原理。例如，类名可以通过三种方式引用：
  1. 非限定名称，或不包含前缀的类名称，例如 $a=new foo(); 或foo::staticmethod();。如果当前命名空间是currentnamespace，foo 将被解析为currentnamespace\foo。如果使用 foo的代码是全局的，不包含在任何命名空间中的代码，则 foo 会被解析为foo。警告：如果命名空间中的函数或常量未定义，则该非限定的函数名称或常量名称会被解析为全局函数名称或常量名称。
  2. 限定名称,或包含前缀的名称，例如$a = new subnamespace\foo(); 或subnamespace\foo::staticmethod();。如果当前的命名空间是currentnamespace，则 foo 会被解析为currentnamespace\subnamespace\foo。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，foo会被解析为subnamespace\foo。
  3. 完全限定名称，或包含了全局前缀操作符的名称，例如，$a = new \currentnamespace\foo(); 或 \currentnamespace\foo::staticmethod();。在这种情况下，foo 总是被解析为代码中的文字名(literal name)currentnamespace\foo。

file1.php



<?php

namespace Foo\Bar\subnamespace;



const FOO = 1;

function foo() {}

class foo{    

    static function staticmethod() {}

}

?>



file2.php



<?php

namespace Foo\Bar;

include 'file1.php';



const FOO = 2;

function foo() {}

class foo{    

    static function staticmethod() {}

}



/* 非限定名称 */

foo(); // 解析为 Foo\Bar\foo resolves to function Foo\Bar\foo

foo::staticmethod(); // 解析为类 Foo\Bar\foo的静态方法staticmethod。resolves to class Foo\Bar\foo, method staticmethod

echo FOO; // resolves to constant Foo\Bar\FOO



/* 限定名称 */

subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo

subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo,                                  

                                  // 以及类的方法 staticmethod

echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO                                  



/* 完全限定名称 */

\Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo

\Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod

echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO

?>
注意访问任意全局类、函数或常量，都可以使用完全限定名称，例如\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

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

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

<?php

namespace MyProject;



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

?>



//__NAMESPACE__ 示例，全局代码

<?php



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

?>



//使用__NAMESPACE__动态创建名称

<?php

namespace MyProject;

function get($classname){    

    $a = __NAMESPACE__ . '\\' . $classname;    

    return new $a;

}

?>



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

<?php

namespace MyProject;



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

blah\mine();                    // calls function MyProject\blah\mine()

namespace\blah\mine();          // calls function MyProject\blah\mine()

namespace\func();               // calls function MyProject\func()

namespace\sub\func();           // calls function MyProject\sub\func()

namespace\cname::method();      // calls static method "method" of class MyProject\cname

$a = new namespace\sub\cname(); // instantiates object of class MyProject\sub\cname

$b = namespace\CONSTANT;        // assigns value of constant MyProject\CONSTANT to $b



?>



//namespace操作符, 全局代码

<?php

namespace\func();            // calls function func()

namespace\sub\func();        // calls function sub\func()

namespace\cname::method();   // calls static method "method" of class cname



$a = new namespace\sub\cname(); // instantiates object of class sub\cname

$b = namespace\CONSTANT;        // assigns value of constant CONSTANT to $b

?>

 使用命名空间：别名/导入
 
允许通过别名引用或导入外部的完全限定名称，是命名空间的一个重要特征。这有点类似于在类
unix 文件系统中可以创建对其它的文件或目录的符号连接。

所有支持命名空间的PHP版本支持三种别名或导入方式：为类名称使用别名、为接口使用别名或为命名空间名称使用别名。PHP 5.6开始允许导入函数或常量或者为它们设置别名。

在PHP中，别名是通过操作符 use 来实现的.
 
//使用use操作符导入/使用别名

<?php

namespace foo;



use My\Full\Classname as Another;

// 下面的例子与 use My\Full\NSname as NSname 相同

use My\Full\NSname;



// 导入一个全局类

use ArrayObject;



// importing a function (PHP 5.6+)

use function My\Full\functionName;



// aliasing a function (PHP 5.6+)

use function My\Full\functionName as func;



// importing a constant (PHP 5.6+)

use const My\Full\CONSTANT;



$obj = new namespace\Another; // 实例化 foo\Another 对象

$obj = new Another; // 实例化 My\Full\Classname　对象

NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func

$a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象

// 如果不使用 "use \ArrayObject" ，则实例化一个 foo\ArrayObject 对象

func(); // calls function My\Full\functionName

echo CONSTANT; // echoes the value of My\Full\CONSTANT

?>
注意对命名空间中的名称（包含命名空间分隔符的完全限定名称如 Foo\Bar以及相对的不包含命名空间分隔符的全局名称如 FooBar）来说，前导的反斜杠是不必要的也不推荐的，因为导入的名称必须是完全限定的，不会根据当前的命名空间作相对解析。

为了简化操作，PHP还支持在一行中使用多个use语句。
 
//通过use操作符导入/使用别名，一行中包含多个use语句

<?php

use My\Full\Classname as Another, My\Full\NSname;



$obj = new Another; // 实例化 My\Full\Classname 对象

NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func

?>



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

<?php

use My\Full\Classname as Another, My\Full\NSname;



$obj = new Another; // 实例化一个 My\Full\Classname 对象

$a = 'Another';

$obj = new $a;      // 实际化一个 Another 对象

?>



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

<?php

use My\Full\Classname as Another, My\Full\NSname;



$obj = new Another; // instantiates object of class My\Full\Classname

$obj = new \Another; // instantiates object of class Another

$obj = new Another\thing; // instantiates object of class My\Full\Classname\thing

$obj = new \Another\thing; // instantiates object of class Another\thing

?>

 全局空间

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

namespace A\B\C;



/* 这个函数是 A\B\C\fopen */

function fopen() {      

    /* ... */     

    $f = \fopen(...); // 调用全局的fopen函数     

    return $f;

} 

?>
名称解析规则​
 
命名空间名称定义
  • 非限定名称Unqualified name：名称中不包含命名空间分隔符的标识符，例如 Foo
  • 限定名称Qualified name：名称中含有命名空间分隔符的标识符，例如 Foo\Bar
  • 完全限定名称Fully qualified name：称中包含命名空间分隔符，并以命名空间分隔符开始的标识符，例如 \Foo\Bar。 namespace\Foo 也是一个完全限定名称。


名称解析遵循下列规则：

对完全限定名称的函数，类和常量的调用在编译时解析。例如 new \A\B 解析为类 A\B。

所有的非限定名称和限定名称（非完全限定名称）根据当前的导入规则在编译时进行转换。例如，如果命名空间A\B\C 被导入为 C，那么对 C\D\e() 的调用就会被转换为 A\B\C\D\e()。

在命名空间内部，所有的没有根据导入规则转换的限定名称均会在其前面加上当前的命名空间名称。例如，在命名空间 A\B 内部调用 C\D\e()，则 C\D\e() 会被转换为 A\B\C\D\e() 。
非限定类名根据当前的导入规则在编译时转换（用全名代替短的导入名称）。例如，如果命名空间A\B\C 导入为C，则 new C()被转换为 new A\B\C() 。
在命名空间内部（例如A\B），对非限定名称的函数调用是在运行时解析的。例如对函数foo() 的调用是这样解析的：

在当前命名空间中查找名为 A\B\foo() 的函数
尝试查找并调用 全局(global) 空间中的函数 foo()。

在命名空间（例如A\B）内部对非限定名称或限定名称类（非完全限定名称）的调用是在运行时解析的。下面是调用new C() 及 new D\E() 的解析过程：

new C()的解析:

在当前命名空间中查找A\B\C类。
尝试自动装载类A\B\C。

new D\E()*的解析:

在类名称前面加上当前命名空间名称变成：A\B\D\E，然后查找该类。
尝试自动装载类 A\B\D\E。

为了引用全局命名空间中的全局类，必须使用完全限定名称 new \C()。
<?php

namespace A;

use B\D, C\E as F;



// 函数调用

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

            // 再尝试调用全局函数 "foo"



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



my\foo();   // 调用定义在命名空间"A\my"中函数 "foo"



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

            // 再尝试调用全局函数 "F"



// 类引用

new B();    // 创建命名空间 "A" 中定义的类 "B" 的一个对象            

            // 如果未找到，则尝试自动装载类 "A\B"



new D();    // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象            

            // 如果未找到，则尝试自动装载类 "B\D"



new F();    // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象            

            // 如果未找到，则尝试自动装载类 "C\E"



new \B();   // 创建定义在全局空间中的类 "B" 的一个对象            

            // 如果未发现，则尝试自动装载类 "B"



new \D();   // 创建定义在全局空间中的类 "D" 的一个对象            

            // 如果未发现，则尝试自动装载类 "D"



new \F();   // 创建定义在全局空间中的类 "F" 的一个对象            

            // 如果未发现，则尝试自动装载类 "F"



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



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



B::foo();   // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法            

            // 如果未找到类 "A\B" ，则尝试自动装载类 "A\B"



D::foo();   // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法            

            // 如果类 "B\D" 未找到，则尝试自动装载类 "B\D"



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



\B::foo();  // 调用全局空间中的类 "B" 的 "foo" 方法            

            // 如果类 "B" 未找到，则尝试自动装载类 "B"



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



A\B::foo();   // 调用命名空间 "A\A" 中定义的类 "B" 的 "foo" 方法              

              // 如果类 "A\A\B" 未找到，则尝试自动装载类 "A\A\B"



\A\B::foo();  // 调用命名空间 "A\B" 中定义的类 "B" 的 "foo" 方法              

              // 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"

?>

文／洞房花猪（简书作者）
原文链接：http://www.jianshu.com/p/9e01d16a2e1c
著作权归作者所有，转载请联系作者获得授权，并标注“简书作者”。
 
0
分享 2016-12-20

0 个评论

要回复文章请先登录或注册

Copyright © 2007 ~ 2024