PHP命令空间namespace及use的用法实践总结

admin

以下皆为本人自我理解内容，如有失误之处，请多多包涵。

7 \" v. j3 u& o1 N0 X8 ^* \4 f

文章大纲：

使用namespace的目的

namespace的使用方法

使用use的目的

use的使用方法

使用namespace的目的：

团队合作项目时，避免与团队其它成员新建的类发生冲突；个人负责项目时，避免前后新建的类发生冲突；

1 h5 r6 z. A1 Q5 p7 f7 ^. g

据个人理解，用到所需要的类时，需要先require或include引入，所以会发生类重定义的错误的前提是：两个相同命名的类都有被引入。目前有些php框架会自动加载（即include）所有新建的model类，所以为了避免你新建的model类和项目框架原生的核心类发生重名冲突，采用了namespace。（想了想，与团队成员新建的类产生冲突应该通过沟通避免，即使事发后也应该重新调整类名即时维护，避免后期造成因为对类的理解混淆而带来维护上的复杂度提高）

结合使用方法来进一步理解它的使用目的吧。

0 ^, n7 t8 c  o4 V& y0 K1 E6 B/ w
9 R- {8 e% F; b2 O2 u  {/ k# O. Anamespace的使用方法：

为了进行测试，我将创建3个文件：1.php和name.php（此文件用来执行测试），后面将不再说明，请自行注意代码的变化。

1.namespace后命名的定义不区分大小写

1. namespace one;
   
2. namespace One;
   
3. namespace ONE;

复制代码

如上写法都可以，选择一种作为自己的规范即可。（后面代码我采用第一种进行测试哈）

8 ^$ T2 j0 X' d$ |4 Z% t2. 没有定义命名空间，就理解为使用顶级命名空间。new类时，可以在类前加上反斜杠\,也可以不加。

1. //1.php   
   3 P6 Z2 v" D/ I; r* x1 L* h! D9 {
2. class Person{
   % ~" v9 o' A1 q
3.     function __construct(){
   
4.             echo 'I am one!';
   
5.         }
   
6. }

复制代码

1. //name.php
   / L! w/ [) A8 _+ y
2. require_once './1.php';
   
3. 
   ( B8 X: ^# t/ S, L! [3 p
4. new Person();     //输出 I am one!;
   
5. new \Person(); //输出 I am one!;

复制代码

3. new类时，带上命名空间时，之间一定用反斜杠字符，而不是顺斜杠。

记忆方法：按找%中斜杠的顺序理解为顺斜杠。（有时说反斜杠，自己都不知道是哪种方向，以前按自左向右上升方向这种方向记忆，现在感觉这个太不靠谱了）

1. //name.php
   
2. require_once './1.php';
   ; d' _" D( ]! I# g6 E5 y
3. new /Person();  // 代码报错：Parse error: syntax error, unexpected '/'

复制代码

4.类在指定命名空间下， new类时，一定要带上指定的命名空间。

没有带上指定的命名空间，按照第2点，php就会从顶级命名空间里找这个类。切记：这里不能按照顶级命名空间包含一切其它的命名空间来理解。而应该将顶级命名空间完完全全与其他命名空间区分开。

1. //1.php   
   
2. namespace one;
   
3. class Person{
   1 ~' @8 A$ O. Z- V! q+ u" n. s
4.     function __construct(){
   
5.             echo 'I am one!';
   + m$ o% D1 r$ R/ j& _
6.         }
   
7. }

复制代码

1. //name.php
   3 C; t( p1 n& L! ^. W7 B! N) [+ p8 v
2. require_once './1.php';
   
3. new \one\Person(); //输出 I am one!;
   
4. new \Person(); //代码报错：Fatal error: Class 'Person' not found

复制代码

5 g  E! x, y, F2 z

可以举个这个通俗例子来理解：带上指定命名空间代表某人的苹果（在他手里），顶级命名空间代表苹果箱里的苹果（在箱子里）。现在要找某人的苹果，就将某人的命名空间带上，否则就会从箱子里找某人的苹果，结果当然是找不到。

5.命名空间声明后的代码便属于这个命名空间，即使有include或require也不影响（重点是对后半句的理解，具体看代码）。
# M& z$ X5 Z' E! V* e+ c7 @$ K

1. //1.php   
   + Q$ A0 t1 U/ y4 `
2. namespace one;
   & [- k- P* p5 X0 d# A
3. class Person{
   
4.     function __construct(){
   
5.             echo 'I am one!';
   
6.         }
   % x( T' y: g( O5 E  g
7. }

复制代码

1. //name.php
   
2. namespace test;
   ! q1 g7 O3 U/ y% t" G
3. require './1.php';
   
4. new \one\Person(); //输出 I am one!;
   
5. new Person();      //这里结果会是什么呢，猜猜看
   
6. 最后一行结果报错：
   
7. Fatal error:  Class 'test\Person' not found

复制代码

7 N( x0 X, p: k6 j4 p7 a9 V  k5 u- ]首先，这里与第2点比较一下：

第2点，我说，没有命名空间时，new类时，有没有反斜杠意义一样。

在这里，有了命名空间，有和没有反斜杠的意义就不一样了。

最后一行换成

1. new \Person();

复制代码

6 U/ n5 Y$ ~8 I* S/ e. ]

结果报错：

1. Fatal error:  Class 'Person' not found

复制代码

+ d$ G) S! d' |/ u

接着，就说说当前这点。

我们可以发现，最后一行代码对应的命名空间为test，并没有受到require文件里的命名空间的影响。

进一步加强验证，我修改了name.php文件如下：

1. //name.php
   
2. namespace test;
   
3. require './1.php';
   1 Z8 N4 {3 C$ }9 ?
4. 
   ; D# \# B5 @* b8 G0 I% g! z
5. class Person{
   8 B: [1 T1 l5 |" s' D0 K8 n/ k
6.     function __construct(){
   
7.             echo 'I am test!';
   
8.         }
   $ a- A  R) w5 @; I( Q. A
9. }
   & F6 j3 l. ?9 m
10. 
    
11. new \one\Person(); //输出 I am one!;
    1 \4 S- @5 ^& Z9 f0 q9 S8 y
12. new Person();    //这里结果会是什么，自己猜猜看

复制代码

/ l) ~& E. l6 p" _9 W2 N9 [$ y

最后，这个例子刷新了我对require的认识了。

按照我以前对require的理解：PHP 程序在执行前，就会先读入 require 所指定引入的文件，使它变成 PHP 程序网页的一部分。所以我常常就简单的理解为替换，只不过把抽离出来的代码再放回原处而已。然后我试了将1.php文件内容放到name.php里：

1. //name.php
   5 h; A/ J/ w5 e5 M4 V' V7 L
2. namespace test;
   2 U; l6 [6 b$ z  B5 m9 e
3. namespace one;
   
4. class Person{
   3 s1 D0 z' H: Y. u
5.     function __construct(){
   : x& n% b! i) N8 a
6.             echo 'I am one!';
   
7.         }
   
8. }
   
9. 
   
10. class Person{
    " o! r: U7 ^' H6 q/ C8 Q
11.     function __construct(){
    6 c# O' E7 U/ d! ]2 U
12.             echo 'I am test!';
    
13.         }
    2 G0 ]8 J* q6 R. l, d! d0 X4 B8 e
14. }

复制代码

无需new类，该文件就会报错：

1. Fatal error:  Cannot redeclare class one\Person

复制代码

看来简单的把require理解为替换，在这里行不通。

6.namespace里不包含类名称，即使存在与类名称同名的部分，那也不代表类。new类时，还是得将这部分带上。
6 ^3 b. s+ o3 {+ o; T* }3 n  `

1. //name.php
   " z# Q, g, e! b, a1 s
2. 
   
3. namespace test\person;
   / [- b7 o+ S+ @3 U( U3 g$ B
4. 
   5 ?5 E# M! s* y3 h' ?7 u/ a- E# v
5. class Person{
   ) `3 E: {' D) j$ |3 L
6.     function __construct(){
   ) T. D* A, z8 t3 I1 B+ c6 U
7.             echo 'I am test!';
   " V. `' u- q* m3 g1 S
8.         }
   
9. }
   
10. new \test\person\Person();  //命名空间里person无法代表类名

复制代码

: l$ M' M- v3 h( O+ l( F- W/ Y

不过这样纯粹是画蛇添足，直接干脆点，namespace里不要带类名称就好。

7.一个php文件中可以存在多个命名空间，第一个命名空间前不能有任何代码。

只说第一个命名空间前不能有任何代码，之后的命名空间之前可以有代码。这个自行测试即可。

1. //name.php
   : z- M& V/ j3 D: V# ^, B
2. 
   / s3 X- `: K+ \- c3 \7 c5 t- n
3. namespace test;
   + e# w; `7 B& g. x9 O8 _3 Y
4. echo 'zhai14';
   
5. namespace zhai;
   ' U/ u8 n0 U. l; z9 S
6. require './1.php';

复制代码

php命名空间namespace告一段落了，接下来说说use的用途。

使用use的目的：

在命名空间字符串过长时，使用use可以相应的缩短命名空间。

use的使用方法：1.new类时，最前面无需用反斜杠。此外，use后没有as时，缩短的命名空间默认为最后一个反斜杠后的内容。

1. //name.php
   . v+ C4 j  {9 w: E
2. 
   . R9 }% Q. }4 W' R
3. namespace animal\dog;
   & A5 v  E$ ]  H7 w' c5 W/ d4 D" ?
4. 
   
5. class Life{
   
6.     function __construct(){
   
7.             echo 'dog life!';
   : R: L. Q8 G- c0 l* p% x: Q5 H
8.         }
   2 v7 d: C/ j5 z0 @6 @
9. }
   
10. 
    
11. namespace animal\cat;
    * S" \1 q' R! b
12. 
    - N% I7 k! ?. N" Q
13. class Life{
    
14.     function __construct(){
    
15.             echo 'cat life!';
    
16.         }
    7 d9 ~: r- C$ k" u' l
17. }
    
18. 
    * c3 t; c8 ~) F) p+ R$ k
19. new Life();  //按照代码执行顺序，这里默认animal\cat这个命名空间
    ! _& p7 k6 C# p1 D, C- S3 g2 T
20. new \animal\dog\Life();  //A
    
21. 
    
22. use animal\dog;  //a
    # _+ l% D1 k; K+ r# @
23. new dog\Life();  //B
    
24. 
    
25. use animal\dog as d;  //b
    
26. new d\Life();

复制代码

0 b2 f7 N9 f2 s) |4 l' b- Q8 m2 r

通过A、B行代码比较，需要注意：

使用use后，new类时，最前面没有反斜杠。

没使用use时，命名空间最前面有反斜杠

通过a、b行代码比较，可以理解：

use后没有as时，缩短的命名空间默认为最后一个反斜杠后的内容。如上的:

1. use animal\dog;

复制代码

: U; {6 |  d0 D& |" }6 p& G: E

相当于

1. use animal\dog as dog;

复制代码

2.namespace后面不建议加类名，但use后可以。
+ E/ I3 {5 H* g! S3 \! Z: H9 }

1. //name.php
   
2. 
   3 }& B4 @+ [, x$ u
3. namespace animal\dog;
   
4. 
   
5. class Life{
   
6.     function __construct(){
   ! K% k2 }) V* \' m: ]; r  l/ r2 `
7.             echo 'dog life!';
   
8.         }
   9 N6 P1 k0 ]: r$ b. I0 ^
9. }
   ' w4 g( a# H  e3 D3 P* Y
10. 
    
11. namespace animal\cat;
    $ a$ C. E) ?2 ^5 N8 u( h: R
12. 
    ) t6 m9 z3 L* N' F* P
13. class Life{
    
14.     function __construct(){
    
15.             echo 'cat life!';
    
16.         }
    & |2 {# X0 n( ?7 z& L5 s
17. }
    3 o" t2 K2 \; d8 J2 C/ O4 `2 r
18. 
    
19. use animal\dog\Life as dog;  
    
20. new dog();

复制代码

; ^% i% x; u& ^, J: M

如上所示，use后加上类名后，就相当于把类改了个名称：由Life改为dog了。

上面不用as dog就会报错：

1. Fatal error:  Cannot use animal\dog\Life as Life because the name is already in use

复制代码

因为cat下也有个一样名称的Life类。

可以理解为，使用use后，这个昵称对应的类只能归当前命名空间占有，其它命名空间下不允许存在该类。

1. //name.php
   & E- V1 t& ^% o
2. 
   
3. namespace animal\dog;
   9 V/ i, R( c, v1 \
4. 
   1 x7 O/ l4 q% B% Y; \+ X
5. class Life{
   
6.     function __construct(){
   
7.             echo 'dog life!';
   , {# y) E2 {9 S" _
8.         }
   
9. }
   ; ?$ @6 U4 P$ t$ a3 c- Z9 V8 Q+ W
10. class Dog{
    
11.     function __construct(){
    
12.             echo 'dog in dog!';
      F* N; }0 [; x, O0 c  Y/ y
13.         }
    # {' h: `+ C4 ]0 m. [$ H5 B0 k
14. }
    
15. 
    
16. namespace animal\cat;
    7 E  W' @0 E3 U$ M; d; f: \
17. 
    ) {8 o; }: N. n8 b4 z, V# k
18. // class Dog{
    8 \' r9 a( O+ j* r+ D8 ~
19. //     function __construct(){
    ) `) I1 j! U) h" h+ P  |
20. //             echo 'dog in cat!';
    
21. //         }
    
22. // }
    2 l6 f5 I6 m0 r& ~5 @8 `9 G1 f
23. class Life{
    ' \2 U4 J0 L+ Q. ]3 e, R9 {" Y/ P
24.     function __construct(){
    
25.             echo 'cat life!';
    9 ?6 s6 y- \! K5 w; b# y
26.         }
    ; m3 n: {1 G5 J
27. }
    4 y1 m. @; \5 i2 l+ s7 s
28. 
    # {9 o6 v+ y2 F+ _/ q) {0 e* v
29. use animal\dog;  
    
30. new dog\Dog();

复制代码

) A/ |. l# \) L* ^

如上，使用了

1. use animal\dog;

复制代码

" P+ q8 N* V: J5 }& ?8 l0 [

cat

通过上面代码，我想使用use的目的效果（缩短命名空间名称）就很明显了。

简单总结一下：

namespace就是划分领域的作用，代表这些东西是属于某个命名空间下的。

use就是起小名的作用，不论写起来还是说起来都可以省不少事儿。

) L8 i, g8 v0 b2 g4 U


5 r+ \0 Z/ F. ?% L