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

admin

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

" Q- w- P* J  S3 o/ v) _  S) u/ k5 p3 t

文章大纲：

使用namespace的目的

namespace的使用方法

使用use的目的

use的使用方法

使用namespace的目的：

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

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

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

5 f: \( ]& h/ W. b; Y+ Q
namespace的使用方法：

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

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

1. namespace one;
   0 \/ V& U  A4 Y7 c
2. namespace One;
   
3. namespace ONE;

复制代码

1 ~9 T% r8 I% w+ X: D& o

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

, o; [9 G% w, Z* F8 M2. 没有定义命名空间，就理解为使用顶级命名空间。new类时，可以在类前加上反斜杠\,也可以不加。

1. //1.php   
   
2. class Person{
   9 a! v, X& a/ }" ?  M
3.     function __construct(){
   & }; v8 ^# v5 j  T, ^  @+ ^
4.             echo 'I am one!';
   / `" h0 a7 B! v5 i/ ?5 ~# s
5.         }
   ) j+ H3 ?  R/ z7 I
6. }

复制代码

1. //name.php
   - L1 d7 Z# @) O% ~& T7 `
2. require_once './1.php';
   
3. 
   * v% ^! s. ?& C
4. new Person();     //输出 I am one!;
   
5. new \Person(); //输出 I am one!;

复制代码

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

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

1. //name.php
   ( m. u+ Q, ]% R1 w
2. require_once './1.php';
   
3. new /Person();  // 代码报错：Parse error: syntax error, unexpected '/'

复制代码

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

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

1. //1.php   
   
2. namespace one;
   
3. class Person{
   
4.     function __construct(){
   
5.             echo 'I am one!';
   
6.         }
   7 A9 D9 C+ W, k( L; y# }! W2 V3 H
7. }

复制代码

1. //name.php
   
2. require_once './1.php';
   
3. new \one\Person(); //输出 I am one!;
   8 `, B' s/ c+ m' X1 G
4. new \Person(); //代码报错：Fatal error: Class 'Person' not found

复制代码

# _/ r5 m7 k, X2 j$ w$ o

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

1 d0 J5 A; h$ j, F) `4 V& o) S5.命名空间声明后的代码便属于这个命名空间，即使有include或require也不影响（重点是对后半句的理解，具体看代码）。
2 y( ?8 M, g8 `( {% G+ q; T

1. //1.php   
   6 k& j6 s8 w% o/ L; c/ w% F
2. namespace one;
   
3. class Person{
   & U1 v, W( S+ {& ~2 p
4.     function __construct(){
   
5.             echo 'I am one!';
   
6.         }
   
7. }

复制代码

1. //name.php
   ! j% |& t# N# A9 J! E
2. namespace test;
   
3. require './1.php';
   3 G8 c  ?6 |3 S) O
4. new \one\Person(); //输出 I am one!;
   
5. new Person();      //这里结果会是什么呢，猜猜看
   . s1 y$ D" }% c9 q. Z/ m
6. 最后一行结果报错：
   , J+ j: U) j8 \3 c. q
7. Fatal error:  Class 'test\Person' not found

复制代码

3 K! g: C  _* B1 Q$ `7 K( j首先，这里与第2点比较一下：

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

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

最后一行换成

1. new \Person();

复制代码

结果报错：

1. Fatal error:  Class 'Person' not found

复制代码

接着，就说说当前这点。

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

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

1. //name.php
   
2. namespace test;
   
3. require './1.php';
   
4. 
   
5. class Person{
   9 _% A. a! S) ]) ^: ^: a) h
6.     function __construct(){
   
7.             echo 'I am test!';
   ! y/ x# F6 o7 p7 o* i+ v  p7 n$ |9 h
8.         }
   9 T) t1 N2 H. b5 P& H
9. }
   % k- ~6 G. v2 P! x6 _
10. 
    
11. new \one\Person(); //输出 I am one!;
    
12. new Person();    //这里结果会是什么，自己猜猜看

复制代码

: I4 |+ u# ~3 I* X: W# L

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

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

1. //name.php
   
2. namespace test;
   
3. namespace one;
   $ q+ ^1 x, E) S- G4 F) m
4. class Person{
   
5.     function __construct(){
   5 u1 h6 m9 y9 H5 N' Y' p
6.             echo 'I am one!';
   8 ^. z* b3 I9 }1 U2 G- c' N6 ~
7.         }
   & l/ M: e* s$ {7 O! O& E, T& N
8. }
   7 K4 f9 y. v% I1 K
9. 
   # Y8 }. B' M7 E! ~
10. class Person{
    2 A! f. Z) t" H6 m7 r
11.     function __construct(){
    # y' `5 s5 R6 G( A4 e, V
12.             echo 'I am test!';
    2 [  \  Q, I" J
13.         }
    5 q/ I) ^3 \) h9 ^" n
14. }

复制代码

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

1. Fatal error:  Cannot redeclare class one\Person

复制代码

1 j* G' d; K4 @. Z! r

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

  l7 G' j) Z; o% U7 h6.namespace里不包含类名称，即使存在与类名称同名的部分，那也不代表类。new类时，还是得将这部分带上。

1. //name.php
   
2. 
   
3. namespace test\person;
   ( [' }7 F- k" U1 w9 q' K7 q
4. 
   
5. class Person{
   ! {4 g6 P  }$ w  {
6.     function __construct(){
   ! M  h) _+ }$ `( G2 y# B( Z
7.             echo 'I am test!';
   & E4 c0 d$ X4 b8 u  k
8.         }
   5 j/ N! {3 e) C4 A
9. }
   
10. new \test\person\Person();  //命名空间里person无法代表类名

复制代码

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

8 Z- Q; w  [$ |; U7.一个php文件中可以存在多个命名空间，第一个命名空间前不能有任何代码。

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

1. //name.php
   
2. 
   
3. namespace test;
   
4. echo 'zhai14';
   0 G9 z# X8 g& R2 S% R0 {8 p$ I1 v
5. namespace zhai;
   2 ~, d3 l& g8 B
6. require './1.php';

复制代码

6 |5 S5 w* K( o

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

使用use的目的：

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

3 N8 {) v% ^2 D0 Uuse的使用方法：1.new类时，最前面无需用反斜杠。此外，use后没有as时，缩短的命名空间默认为最后一个反斜杠后的内容。
8 w5 S# Y. ~5 c' G: T5 G2 h/ _- o

1. //name.php
   
2. 
   1 j( f) E. O8 q) x  j( `# {
3. namespace animal\dog;
   
4. 
   
5. class Life{
   * D7 S' T; |- O7 A; j+ `: C' `
6.     function __construct(){
   / l& Z5 Y- n3 [3 q; e# }6 U
7.             echo 'dog life!';
   + ]/ e8 e5 _. d2 T5 ]9 ]7 c
8.         }
   
9. }
   
10. 
    8 Z2 j, w2 q% ^* Z) d8 R$ ]3 w
11. namespace animal\cat;
    2 b* Y9 Q' }6 j; W6 _2 n' _: h
12. 
    
13. class Life{
    ! ^. D' p; T: u! a" f- `5 a
14.     function __construct(){
    6 h9 n# z6 C5 S$ T+ B% B/ v3 W
15.             echo 'cat life!';
    5 N" d5 j' l/ Y- q& l# @
16.         }
    1 Z# m( B/ ?8 r, I2 P
17. }
    3 D6 P8 }2 h9 B; V; h  }6 i2 [
18. 
    ) e5 Z. D3 W# p% J- H
19. new Life();  //按照代码执行顺序，这里默认animal\cat这个命名空间
    2 ?! W5 T+ T& D4 L5 _7 F
20. new \animal\dog\Life();  //A
    
21. 
    
22. use animal\dog;  //a
    % R3 ~' M4 K; C9 Q* n& g
23. new dog\Life();  //B
    ; ]  }" l5 t. N8 D4 ~$ I+ _
24. 
    ' m/ z6 p6 g! E1 Q% I6 O9 t4 m
25. use animal\dog as d;  //b
    
26. new d\Life();

复制代码

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

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

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

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

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

1. use animal\dog;

复制代码

相当于

1. use animal\dog as dog;

复制代码

2.namespace后面不建议加类名，但use后可以。

1. //name.php
   
2. 
   . S. W6 [; n7 q7 W
3. namespace animal\dog;
   - ?; h3 a/ z9 f
4. 
   
5. class Life{
   
6.     function __construct(){
   3 F, k2 Z2 L" X* ~1 \8 I, x) z$ k
7.             echo 'dog life!';
   5 x; k) ~& O# C1 d0 {
8.         }
   7 S2 M2 [4 z% k; U3 A& [
9. }
   : x% g  {+ ?: [0 {8 a+ O
10. 
    
11. namespace animal\cat;
    
12. 
    
13. class Life{
    ; p- ~4 \+ i5 E2 M3 E% j* h9 v
14.     function __construct(){
    : L6 r  V# M7 p1 p8 E; a, F( ?& j. l, i
15.             echo 'cat life!';
    7 |3 u2 t9 z9 P% z
16.         }
    / V% w) p1 B# p4 `
17. }
    8 A  `- ^* E$ k% y
18. 
    
19. use animal\dog\Life as dog;  
    
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

复制代码

- u! y/ X0 e- b9 k/ q# S  e, k

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

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

1. //name.php
   # I6 m" Z5 y! }0 T4 F; q
2. 
   
3. namespace animal\dog;
   
4. 
   & t) C, W# S, G5 S6 ?3 R* r
5. class Life{
   $ N6 E# q6 e7 V- j
6.     function __construct(){
   
7.             echo 'dog life!';
   
8.         }
   
9. }
   ) P; g6 d% {9 [9 G
10. class Dog{
    ) M" a, Y9 D8 c% q2 i9 K
11.     function __construct(){
    5 R9 m2 k4 X' [) `6 i/ }
12.             echo 'dog in dog!';
    6 d7 a) J: u3 V5 @
13.         }
    
14. }
    
15. 
    ) r) `) V: I! L$ A
16. namespace animal\cat;
    
17. 
    " k4 ]( ~8 @, L% L
18. // class Dog{
    
19. //     function __construct(){
    4 b2 C  I) H$ y, a: J% G
20. //             echo 'dog in cat!';
    ) q$ h8 l1 @3 }# l5 w: X
21. //         }
    
22. // }
    $ U: Q: I0 a* h% p  r# G" M1 |. K) C
23. class Life{
    # R4 I/ d& w. O) F' y
24.     function __construct(){
    
25.             echo 'cat life!';
    3 l& i2 S2 q! C- e
26.         }
    
27. }
    # u& k* C% A2 m1 T8 M1 C
28. 
    5 l$ F1 q$ U, Q; f
29. use animal\dog;  
    
30. new dog\Dog();

复制代码

$ `0 w5 P+ L2 A/ Y% p

如上，使用了

1. use animal\dog;

复制代码

2 ]! j; h8 I) _

cat

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

简单总结一下：

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

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

; o/ t$ O. @7 J6 Z/ o
0 o/ [$ h- T  T4 N

# I4 `- ^9 I. C6 A