远航

为了远方的诗以及苟且

PHP 定名空间(namespace)

PHP 定名空间(namespace)是在PHP 5.3中退出的,若是你学过C#以及Java,那定名空间就不算甚么新事物。 不外在PHP傍边仍是有着相称首要的意思。

PHP 定名空间可以解决如下两类问题:

  1. 用户编写的代码与PHP外部的类/函数/常量或者第三方类/函数/常量之间的名字抵触。
  2. 为很长的标识符名称(一般是为了减缓第一类问题而界说的)创立一个体名(或者冗长)的名称,普及源代码的可读性。

界说定名空间

默许环境下,一切常量、类以及函数名都放在全局空间下,就以及PHP支持定名空间以前同样。

定名空间经由过程关头字namespace 来声明。若是一个文件中包括定名空间,它必需在其它一切代码以前声明定名空间。语法格局以下;

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

你也能够在统一个文件中界说差别的定名空间代码,如:

<?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() { /* ... */  }
}
?>

将全局的横死名空间中的代码与定名空间中的代码组合在一路,只能应用大括号模式的语法。全局代码必需用一个不带名称的 namespace 语句加之大括号括起来,例如:

<?php
namespace MyProject {

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

namespace { // 全局代码
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>

在声明定名空间以前独一非法的代码是用于界说源文件编码体式格局的 declare 语句。一切非 PHP 代码包含空缺符都不克不及呈现在定名空间的声明以前。

<?php
declare(encoding='UTF-8'); //界说多个定名空间以及不包括在定名空间中的代码
namespace MyProject {

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

namespace { // 全局代码
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>

如下代码会呈现语法差错:

<html>
<?php
namespace MyProject; // 定名空间前呈现了“<html>” 会致命差错 - 定名空间必需是法式剧本的第一条语句
?>

子定名空间

与目次以及文件的瓜葛很像,PHP 定名空间也容许指定条理化的定名空间的名称。是以,定名空间的名字可使用分条理的体式格局界说:

<?php
namespace MyProject\Sub\Level;  //声明分条理的单个定名空间

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

?>

下面的例子创立了常量 MyProject\Sub\Level\CONNECT_OK,类 MyProject\Sub\Level\Connection 以及函数 MyProject\Sub\Level\Connect。


定名空间应用

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
foo::staticmethod(); // 剖析为类 Foo\Bar\foo ,法子为 staticmethod
echo FOO; // 剖析为常量 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
?>

定名空间以及动静言语特征

PHP 定名空间的完成遭到其言语本身的动静特征的影响。是以,若是要将上面的代码转换到定名空间中,动静拜访元素。

example1.php 文件代码:

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

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

必需应用彻底限制名称(包含定名空间前缀的类名称)。注重由于在动静的类名称、函数名称或者常量名称中,限制名称以及彻底限制名称没有区分,是以其前导的反斜杠是不用要的。

动静拜访定名空间的元素

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

include 'example1.php';

$a = 'classname';
$obj = new $a; // 输入 classname::__construct
$b = 'funcname';
$b(); // 输入函数名
echo constant('constname'),"\n"; // 输入 global

/* 若是应用双引号,应用法子为"\\namespacename\\classname"*/
$a = '\namespacename\classname';
$obj = new $a; // 输入 namespacename\classname::__construct
$a = 'namespacename\classname';
$obj = new $a; // 输入 namespacename\classname::__construct
$b = 'namespacename\funcname';
$b(); // 输入 namespacename\funcname
$b = '\namespacename\funcname';
$b(); // 输入 namespacename\funcname
echo constant('\namespacename\constname'),"\n"; // 输入 namespaced
echo constant('namespacename\constname'),"\n"; // 输入 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 操作符。

namespace操作符,定名空间中的代码

<?php
namespace MyProject;

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

blah\mine(); // calls function blah\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
?>

应用定名空间:别号/导入

PHP 定名空间支持 有两种应用别号或者导入体式格局:为类名称应用别号,或者为定名空间名称应用别号。

在PHP中,别号是经由过程操作符 use 来完成的. 上面是一个应用一切能够的三种导入体式格局的例子:

一、应用use操作符导入/应用别号

<?php
namespace foo;
use My\Full\Classname as Another;

// 上面的例子与 use My\Full\NSname as NSname 沟通
use My\Full\NSname;

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

$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 对象
?>

2、 一行中包括多个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; // 实例化 My\Full\Classname 类
$obj = new \Another; // 实例化 Another 类
$obj = new Another\thing; // 实例化 My\Full\Classname\thing 类
$obj = new \Another\thing; // 实例化 Another\thing 类
?>

应用定名空间:后备全局函数/常量

在一个定名空间中,当 PHP 遇到一个非限制的类、函数或者常量名称时,它应用差别的优先战略来剖析该名称。类名称老是剖析到以后定名空间中的名称。是以在拜访体系外部或者不包括在定名空间中的类名称时,必需应用彻底限制名称,例如:

一、在定名空间中拜访全局类

<?php
namespace A\B\C;
class Exception extends \Exception {}

$a = new Exception('hi'); // $a 是类 A\B\C\Exception 的一个对象
$b = new \Exception('hi'); // $b 是类 Exception 的一个对象

$c = new ArrayObject; // 致命差错, 找不到 A\B\C\ArrayObject 类
?>

关于函数以及常量来讲,若是以后定名空间中不存在该函数或者常量,PHP 会退而应用全局空间中的函数或者常量。

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

<?php
namespace A\B\C;

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

echo E_ERROR,"\n"; // 输入"45"
echo INI_ALL,"\n"; // 输入"7" - 应用全局常量 INI_ALL

echo strlen('hi'),"\n"; // 输入"2"
if (is_array('hi')) { // 输入"is not array"
    echo"is array\n";
} else {
    echo"is not array\n";
}
?>

全局空间

若是没有界说任何定名空间,一切的类与函数的界说都是在全局空间,与 PHP 引入定名空间观点前同样。在名称前加之前缀 \ 暗示该名称是全局空间中的名称,即便该名称位于其它的定名空间中时也是如斯。

应用全局空间阐明

<?php
namespace A\B\C;

/* 这个函数是 A\B\C\fopen */
function fopen() { 
     /* ... */
     $f = \fopen(...); // 挪用全局的fopen函数
     return $f;
} 
?>

定名空间的次序

自从有了定名空间之后,最容易堕落的该是应用类的时辰,这个类的寻觅途径是甚么样的了。

<?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" 的"foo" 法子
              // 若是类"A\B" 未找到,则测验考试自动装载类"A\B"
?>

名称剖析遵守下列规定:

  1. 对彻底限制名称的函数,类以及常量的挪用在编译时剖析。例如 new \A\B 剖析为类 A\B
  2. 一切的非限制名称以及限制名称(非彻底限制名称)按照以后的导入规定在编译时举行转换。例如,若是定名空间 A\B\C 被导入为 C,那末对 C\D\e() 的挪用就会被转换为 A\B\C\D\e()
  3. 在定名空间外部,一切的没有按照导入规定转换的限制名称均会在其后面加之以后的定名空间名称。例如,在定名空间 A\B 外部挪用 C\D\e(),则 C\D\e() 会被转换为 A\B\C\D\e() 。
  4. 非限制类名按照以后的导入规定在编译时转换(用全名取代短的导入名称)。例如,若是定名空间 A\B\C 导入为C,则 new C() 被转换为 new A\B\C() 
  5. 在定名空间外部(例如A\B),对非限制名称的函数挪用是在运转时剖析的。例如对函数 foo() 的挪用是如许剖析的:
    1. 在以后定名空间中查找名为 A\B\foo() 的函数
    2. 测验考试查找并挪用 全局(global) 空间中的函数 foo()
  6. 在定名空间(例如A\B)外部对非限制名称或者限制名称类(非彻底限制名称)的挪用是在运转时剖析的。上面是挪用 new C() 及 new D\E()的剖析进程: new C()的剖析:
    1. 在以后定名空间中查找A\B\C类。
    2. 测验考试自动装载类A\B\C

    new D\E()的剖析:

    1. 在类名称后面加之以后定名空间名称酿成:A\B\D\E,而后查找该类。
    2. 测验考试自动装载类 A\B\D\E

    为了援用全局定名空间中的全局类,必需应用彻底限制名称 new \C()

时尚潮水的男士衬衣,帅你一脸绿色才是风行色绿元素手表推举

1 篇条记 写条记

  1.    Alex Gump  182淫乱69281@163.com 四川一公交车产生爆炸现场黑烟滚可以把非限制名称类比为文件名(例如 co妹妹ent.php)、.限制名称类比为绝对途径名(例如 /article/co妹妹ent.php)、彻底限制名称类比为相对途径名(例如 /blog/article/co妹妹ent.php),如许能够会更易懂得。再添一例:<?php
    //创立空间Blog
    namespace Blog;
    class Co妹妹ent { }
    //非限制名称,暗示以后Blog空间
    //这个挪用将被剖析成 Blog\Co妹妹ent();
    $blog_co妹妹ent = new Co妹妹ent();
    //限制名称,暗示绝对于Blog空间
    //这个挪用将被剖析成 Blog\Article\Co妹妹ent();
    $article_co妹妹ent = new Article\Co妹妹ent(); //类后面没有反斜杆\
    //彻底限制名称,暗示相对于Blog空间
    //这个挪用将被剖析成 Blog\Co妹妹ent();
    $article_co妹妹ent = new \Blog\Co妹妹ent(); //类后面有反斜杆\
    //彻底限制名称,暗示相对于Blog空间
    //这个挪用将被剖析成 Blog\Article\Co妹妹ent();
    $article_co妹妹ent = new \Blog\Article\Co妹妹ent(); //类后面有反斜杆\

    //创立Blog的子空间Article
    namespace Blog\Article;
    class Co妹妹ent { }
    ?>