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

admin

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

文章大纲：

使用namespace的目的

namespace的使用方法

使用use的目的

use的使用方法

( [. A; E) X! L: _使用namespace的目的：

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

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

0 Q/ v: b. k+ \1 w+ D结合使用方法来进一步理解它的使用目的吧。

3 U! S# n$ H2 T0 i" @
namespace的使用方法：

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

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

1. namespace one;
   
2. namespace One;
   $ Y1 a, u* z0 M& `
3. namespace ONE;

复制代码

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

2. 没有定义命名空间，就理解为使用顶级命名空间。new类时，可以在类前加上反斜杠\,也可以不加。

1. //1.php   
   
2. class Person{
   
3.     function __construct(){
   9 p6 T: @& `1 S9 _+ J
4.             echo 'I am one!';
   
5.         }
   
6. }

复制代码

1. //name.php
   
2. require_once './1.php';
   # K9 L9 ?- w) i( L/ g( V, E
3. 
   
4. new Person();     //输出 I am one!;
   
5. new \Person(); //输出 I am one!;

复制代码

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

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

1. //name.php
   
2. require_once './1.php';
   2 o% o& s( X0 d1 P' q  r' m
3. new /Person();  // 代码报错：Parse error: syntax error, unexpected '/'

复制代码

/ h( n2 a! }: {( X6 {" u$ G1 }4.类在指定命名空间下， new类时，一定要带上指定的命名空间。

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

1. //1.php   
   
2. namespace one;
   9 I6 w8 `; G( ~' K
3. class Person{
   & J) [. R: }3 @9 C
4.     function __construct(){
   
5.             echo 'I am one!';
   
6.         }
   # r9 V5 H0 v' d
7. }

复制代码

1. //name.php
   ( ^; l1 {5 _( c* v/ b7 L! K% B
2. require_once './1.php';
   
3. new \one\Person(); //输出 I am one!;
   
4. new \Person(); //代码报错：Fatal error: Class 'Person' not found

复制代码

3 n+ K6 g/ x8 Z% O! M* i3 l

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

5.命名空间声明后的代码便属于这个命名空间，即使有include或require也不影响（重点是对后半句的理解，具体看代码）。
4 K9 x' v- [  k- Y/ ~

1. //1.php   
   . j5 ?% y; ~. ], h8 t
2. namespace one;
   
3. class Person{
   
4.     function __construct(){
   
5.             echo 'I am one!';
   / O0 T( _) K) q. s: v
6.         }
   : c3 ]+ P* i) M3 Y" l/ z$ F
7. }

复制代码

1. //name.php
   . O& V* Q$ W- w' V& P
2. namespace test;
   ; y' Y+ K' [! ~) O
3. require './1.php';
   / G' D' v1 R- M) j5 J/ x
4. new \one\Person(); //输出 I am one!;
   - Y. q  n1 ]( C* Y! r, w* a* X
5. new Person();      //这里结果会是什么呢，猜猜看
   / j; o3 p7 U" B8 N  |4 O; ^, B
6. 最后一行结果报错：
   6 k3 }$ |' i6 ^4 H) {3 @
7. Fatal error:  Class 'test\Person' not found

复制代码

. ^0 h9 }( \/ J! \( X) h% g7 }

首先，这里与第2点比较一下：

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

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

最后一行换成

1. new \Person();

复制代码

结果报错：

1. Fatal error:  Class 'Person' not found

复制代码

接着，就说说当前这点。

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

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

1. //name.php
   : j5 _2 h3 J( i' L* ~0 k( L! r
2. namespace test;
   + J, L7 P4 F6 }9 \
3. require './1.php';
   
4. 
   
5. class Person{
   7 e; s  K, G- L
6.     function __construct(){
   . W* C2 P) v/ [0 n3 Z) v* \
7.             echo 'I am test!';
   * M* B4 H+ C" g7 C
8.         }
   
9. }
   
10. 
    
11. new \one\Person(); //输出 I am one!;
    
12. new Person();    //这里结果会是什么，自己猜猜看

复制代码

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

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

1. //name.php
   $ z4 c6 k/ T$ I4 M& A
2. namespace test;
   6 u1 |2 Z0 C) q5 z
3. namespace one;
   
4. class Person{
   
5.     function __construct(){
   ' `( L' k: g7 E8 L3 V/ q
6.             echo 'I am one!';
   6 u: y8 ?  J0 x; j( \0 n
7.         }
   
8. }
   
9. 
   ! ^/ j  w+ v' T* l4 Q
10. class Person{
    9 f' `7 L5 t. ?" k, Y
11.     function __construct(){
    
12.             echo 'I am test!';
    ) H1 O7 A/ Q/ t5 _3 O
13.         }
    3 @4 f- d1 f: M2 `
14. }

复制代码

$ X2 s; k7 C! b1 Z2 ?) u8 H2 t4 u5 }

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

1. Fatal error:  Cannot redeclare class one\Person

复制代码

8 `2 l0 N3 M# n! Z  S

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

, B5 ^: K- u! \0 r+ v6.namespace里不包含类名称，即使存在与类名称同名的部分，那也不代表类。new类时，还是得将这部分带上。
6 n+ A, r3 ^* K* Z6 O6 l5 h

1. //name.php
   * j3 n# h4 J  c+ u
2. 
   
3. namespace test\person;
   # i3 f' I8 C- {0 L
4. 
   / l3 _& \( Q5 T- J
5. class Person{
   , `( j8 a! S  R+ D. ]
6.     function __construct(){
   : }7 a1 i1 P3 }0 a/ ^! t( K
7.             echo 'I am test!';
   5 c7 }# F2 a  @( d: B) j
8.         }
   
9. }
   5 ~- P, z) i+ i* r2 q/ b; b
10. new \test\person\Person();  //命名空间里person无法代表类名

复制代码

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

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

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

1. //name.php
   ! H( e  S7 J4 Q- r! m
2. 
   ( ]9 ]( `/ s, f
3. namespace test;
   # b9 ^$ n6 f' J9 m
4. echo 'zhai14';
   
5. namespace zhai;
   - D" v% Q  Q4 o
6. require './1.php';

复制代码

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

使用use的目的：

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

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

1. //name.php
   
2. 
   
3. namespace animal\dog;
   
4. 
   : \7 h( n* d8 D3 M. o
5. class Life{
   
6.     function __construct(){
   2 x- B/ E9 [3 E
7.             echo 'dog life!';
   + q: k% o' ~$ _& J! v
8.         }
   
9. }
   
10. 
    
11. namespace animal\cat;
    ; G: e9 K& l' l! H" r6 r) U* Z1 ~; J+ Y! m
12. 
    
13. class Life{
    9 F4 i/ Z$ m3 W* q, A
14.     function __construct(){
    % Y% B- N; e6 p
15.             echo 'cat life!';
    9 z% I6 H% |0 A
16.         }
    
17. }
    3 R$ ~* V% f- x  ^! w5 f$ T
18. 
    
19. new Life();  //按照代码执行顺序，这里默认animal\cat这个命名空间
    ) ?' j# R6 e" j5 ]' [4 c% i
20. new \animal\dog\Life();  //A
    & W; u6 P# p6 w# I# T3 x
21. 
    . p# R1 ?# h+ q% C& v& v) f
22. use animal\dog;  //a
    
23. new dog\Life();  //B
    " `' j1 Y4 H4 I* r; I0 q+ j. r
24. 
    
25. use animal\dog as d;  //b
    : o# C0 r6 K& }, Q# s
26. new d\Life();

复制代码

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

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

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

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

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

1. use animal\dog;

复制代码

% P5 J" F' N+ p7 V

相当于

1. use animal\dog as dog;

复制代码

2.namespace后面不建议加类名，但use后可以。
! J$ ]* @1 }  C0 Q

1. //name.php
   1 w+ X" @# E! D+ s" G) y
2. 
   
3. namespace animal\dog;
   - t; t1 [% w: d5 f
4. 
   - I0 C6 a: ]3 O2 R
5. class Life{
   9 t' e+ S" C/ G  i
6.     function __construct(){
   
7.             echo 'dog life!';
   
8.         }
   3 O) I# Y5 [% Y/ Z$ Y
9. }
   
10. 
    # j$ l! a  z- S
11. namespace animal\cat;
    7 R8 @+ J; M( T% z% _% q
12. 
    " Y# F1 d2 l# v$ P6 O
13. class Life{
    
14.     function __construct(){
    
15.             echo 'cat life!';
    
16.         }
    % t  u1 ~. Y. A. j% |& ?
17. }
    
18. 
    
19. use animal\dog\Life as dog;  
    ' u4 [0 B, v2 f+ z
20. new dog();

复制代码

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

上面不用as dog就会报错：

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

复制代码

( a) a+ z% X  z2 g8 A5 u

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

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

1. //name.php
   6 @$ D$ o) [, I. D/ u; p
2. 
   4 L+ n+ ?1 I' |" T- l+ L
3. namespace animal\dog;
   
4. 
   
5. class Life{
   2 X/ W% B- f, C1 w* z
6.     function __construct(){
   
7.             echo 'dog life!';
   4 t6 ~& r  _% f  X
8.         }
   * K" t6 d4 Q+ ]& y0 D4 t  ~
9. }
   
10. class Dog{
    , @+ ~* k, _7 b$ U: S! ~, P3 |6 y' d
11.     function __construct(){
    
12.             echo 'dog in dog!';
    
13.         }
    ( p& B7 V' h. Y" v# i
14. }
    1 ~  @* P' m' X5 [- g. Y3 l  s: H
15. 
    
16. namespace animal\cat;
    
17. 
    / W6 X' p# Z3 V3 X2 l
18. // class Dog{
    
19. //     function __construct(){
    , {* V2 S. [3 ~- g
20. //             echo 'dog in cat!';
    
21. //         }
    $ s' A9 f- ]/ f4 J& C4 @
22. // }
    # u3 U) J; I! Q/ g
23. class Life{
    3 C2 g. Y2 f5 S; e  t& @9 z; N9 g
24.     function __construct(){
    
25.             echo 'cat life!';
    
26.         }
    ' l# m) b# d" q. J- X
27. }
    
28. 
    
29. use animal\dog;  
    
30. new dog\Dog();

复制代码

. H% f7 Q4 }3 I: m* E

如上，使用了

1. use animal\dog;

复制代码

cat

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

; l! }4 H( J  x* q; f7 f" G& |- i

简单总结一下：

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

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

5 z, G4 j  M# m; i+ h7 K
0 z9 G& X% p, Z5 R0 ^2 r3 Z/ A

5 G& O6 b7 b( L