cncml手绘网

标题: PHP命令空间namespace及use的用法实践总结 [打印本页]

---

作者: admin    时间: 2020-7-1 23:37
标题: PHP命令空间namespace及use的用法实践总结

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

文章大纲：

使用namespace的目的

namespace的使用方法

使用use的目的

use的使用方法

0 Y7 n% ^) M$ {4 ^5 D/ U
使用namespace的目的：

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

' \; _$ n3 H+ q- }- B3 D+ |- V7 ?

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

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

namespace的使用方法：

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

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

1. namespace one;
   
2. namespace One;
   : S2 z; a" H2 ]4 x
3. namespace ONE;

复制代码

3 l% e' }: e7 g+ k) @/ |  G

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

0 y# u4 ?. n$ k' H* F4 I! V% K; q5 M2. 没有定义命名空间，就理解为使用顶级命名空间。new类时，可以在类前加上反斜杠\,也可以不加。

1. //1.php   
   . @' L, Y1 n/ `3 T# [( i
2. class Person{
   
3.     function __construct(){
   1 ^$ X8 [. u) e. b
4.             echo 'I am one!';
   
5.         }
   
6. }

复制代码

1. //name.php
   1 h1 P1 B8 \* [, d% p' J
2. require_once './1.php';
   2 W( H, }6 _  m$ W. k7 u+ C
3. 
   
4. new Person();     //输出 I am one!;
   $ e; |6 n2 H$ N
5. new \Person(); //输出 I am one!;

复制代码

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

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

1. //name.php
   ; t% B* [  ]7 _" C3 L5 v
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{
   : T1 H) g, c/ \( ~& o, b9 Y2 I
4.     function __construct(){
   ' \6 O" N# S' }  g: x& f. ~5 w
5.             echo 'I am one!';
   ) @7 n/ U7 }3 ^
6.         }
   9 T9 i* d) l1 v+ ^9 Z) i. ~3 f
7. }

复制代码

1. //name.php
   6 e  y- q- m9 z
2. require_once './1.php';
   
3. new \one\Person(); //输出 I am one!;
   
4. new \Person(); //代码报错：Fatal error: Class 'Person' not found

复制代码

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

$ v2 Z) [6 e) e5.命名空间声明后的代码便属于这个命名空间，即使有include或require也不影响（重点是对后半句的理解，具体看代码）。

1. //1.php   
   
2. namespace one;
   % c$ Q, o( n* E$ Y
3. class Person{
   " X2 ?) F8 x6 }- j) b" v5 D
4.     function __construct(){
   
5.             echo 'I am one!';
   1 H* P4 P- m& i) p8 k) s3 ^
6.         }
   
7. }

复制代码

1. //name.php
   6 {. v" b- U3 o4 e, C
2. namespace test;
   
3. require './1.php';
   
4. new \one\Person(); //输出 I am one!;
   
5. new Person();      //这里结果会是什么呢，猜猜看
   4 G* j  `: Y4 U' R/ f3 \, S6 n. H; R
6. 最后一行结果报错：
   1 H$ [' w7 ^8 x# K- ]3 m
7. Fatal error:  Class 'test\Person' not found

复制代码

  |$ ^. K! u/ x

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

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

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

最后一行换成

1. new \Person();

复制代码

; e5 ]' s$ |. `

结果报错：

1. Fatal error:  Class 'Person' not found

复制代码

+ G  `" P. x% `& E5 g+ Z' }# Z8 J

接着，就说说当前这点。

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

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

1. //name.php
   
2. namespace test;
   
3. require './1.php';
   - r) T0 G" ^* I4 H  H8 y/ L9 a$ C
4. 
   1 G6 F  }- R5 }5 t
5. class Person{
   
6.     function __construct(){
   
7.             echo 'I am test!';
   * Q/ _; I) j# {( h
8.         }
   
9. }
   
10. 
    
11. new \one\Person(); //输出 I am one!;
    2 C; G1 `# N) T& o
12. new Person();    //这里结果会是什么，自己猜猜看

复制代码

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

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

1. //name.php
   ; V4 k5 V; e3 Q7 h0 _3 H
2. namespace test;
   1 }) @( D0 y  a7 n4 h, X
3. namespace one;
   1 I" ]8 p: s8 d, u
4. class Person{
   
5.     function __construct(){
   
6.             echo 'I am one!';
   ' E$ ]) [2 k9 m% X, n# q
7.         }
   
8. }
   ) `( i+ i: A) e: c  ?
9. 
   
10. class Person{
    
11.     function __construct(){
    
12.             echo 'I am test!';
    . y* G$ \2 P- I7 g- Z5 }
13.         }
    6 J$ Y, [6 K3 P1 L4 B2 ~
14. }

复制代码

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

1. Fatal error:  Cannot redeclare class one\Person

复制代码

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

7 d8 @8 f" I$ {2 T) c2 ?+ g( ^6.namespace里不包含类名称，即使存在与类名称同名的部分，那也不代表类。new类时，还是得将这部分带上。

1. //name.php
   1 u+ @, u  v( S+ [
2. 
   7 |8 b& ~$ X! S$ E* k
3. namespace test\person;
   
4. 
   
5. class Person{
   # X" u( m: G! O* M
6.     function __construct(){
   5 ]( K" V4 z' I0 n
7.             echo 'I am test!';
   
8.         }
   
9. }
   
10. new \test\person\Person();  //命名空间里person无法代表类名

复制代码

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

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

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

1. //name.php
   
2. 
   6 E( A, w1 P  f+ O2 n4 N$ M5 O
3. namespace test;
   ) z. v/ }% |* R
4. echo 'zhai14';
   
5. namespace zhai;
   ; Z. m$ H0 a. Z! a! {
6. require './1.php';

复制代码

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

使用use的目的：

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

use的使用方法：1.new类时，最前面无需用反斜杠。此外，use后没有as时，缩短的命名空间默认为最后一个反斜杠后的内容。
; \4 Z1 p1 l; o$ y) f$ m

1. //name.php
   
2. 
   : Z: Q7 J: B5 v& ]* Y( ^
3. namespace animal\dog;
   ' m& V5 X- I: @
4. 
   2 w+ B/ O% v7 b3 G; c
5. class Life{
   $ s) J$ S+ n0 Y; Z% g
6.     function __construct(){
   . n2 L5 A) @' M& W( s' E
7.             echo 'dog life!';
   
8.         }
   % W6 a0 u& E, E  L/ s1 M0 l4 g
9. }
   
10. 
    : O! N: R* k9 x" t
11. namespace animal\cat;
    
12. 
    
13. class Life{
    
14.     function __construct(){
    ) g  J2 {! G' y1 q8 S& n
15.             echo 'cat life!';
    ( a  d, W% H9 u! g4 j% B
16.         }
    
17. }
    
18. 
    
19. new Life();  //按照代码执行顺序，这里默认animal\cat这个命名空间
    9 o1 Z1 M, ?$ X
20. new \animal\dog\Life();  //A
    
21. 
    
22. use animal\dog;  //a
    " g  t' ~( s5 \% ?
23. new dog\Life();  //B
    ; ]* Z7 K% D3 F4 h" r
24. 
    ! S" W) N+ V& K0 I6 C% _6 {, T* j
25. use animal\dog as d;  //b
    3 U) T: w; r8 `/ C- u
26. new d\Life();

复制代码

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

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

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

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

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

1. use animal\dog;

复制代码

, @4 |0 X  r* H+ C9 W9 ~& }- B: j

相当于

1. use animal\dog as dog;

复制代码

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

1. //name.php
   % m% V; Z' I( b8 N
2. 
   , g8 \" N, V7 N# r
3. namespace animal\dog;
   * @. D% [+ c9 N# S- T: m
4. 
   
5. class Life{
   " n' j  g8 k- @7 F, z  x( B
6.     function __construct(){
   
7.             echo 'dog life!';
   
8.         }
   9 [3 W# [2 e4 u
9. }
     [! g! D6 O1 u; h
10. 
    - e/ E) h1 {6 v! }, U
11. namespace animal\cat;
    0 `6 |; ]: |: M- n) ^: W8 J* t/ w
12. 
    
13. class Life{
    
14.     function __construct(){
    
15.             echo 'cat life!';
    # M2 I5 n* z8 d/ }5 B
16.         }
    0 q6 T" s: f" R  W7 ~0 T, a
17. }
    
18. 
    
19. use animal\dog\Life as dog;  
    
20. new dog();

复制代码

7 T$ \  }& O* a% d* ?+ Q

如上所示，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
   ! T! @- q, h, m
2. 
   ) T5 N  {, N7 r
3. namespace animal\dog;
   9 H8 P( ^3 i9 R
4. 
   ( F8 i. u2 _8 P
5. class Life{
   1 B) Q& ?# ]2 M+ B: _
6.     function __construct(){
   ! c5 V" e0 y* Q! ~3 D, e% B
7.             echo 'dog life!';
   5 W# z+ o3 H' R# z
8.         }
   
9. }
   
10. class Dog{
    8 R  h# t- p' F2 M
11.     function __construct(){
    
12.             echo 'dog in dog!';
    
13.         }
    / d. p3 Y( X2 C+ f- {. O
14. }
    
15. 
    7 q: X# j2 K- U6 P* o6 X
16. namespace animal\cat;
    - b) D/ m7 J/ K( v$ d1 L
17. 
    
18. // class Dog{
    # O) A. g% t1 N- z- e# H- {% P
19. //     function __construct(){
    
20. //             echo 'dog in cat!';
    ( R" w) e# |, u
21. //         }
    / f6 p9 {  ~( B. C2 ^/ v5 o( \, i
22. // }
    2 t0 T* n" a! ^0 f" s9 i% F
23. class Life{
    ' g( ?" |- @; e0 M/ h* Z1 L
24.     function __construct(){
    1 k( S. g. T' a! M$ I- R
25.             echo 'cat life!';
    2 j0 [! h% {/ w7 t+ y$ B
26.         }
    ! s6 r7 D; D, C3 E6 Y
27. }
    * z5 P0 V+ Q/ _$ H% e# Q" u
28. 
    " d- V+ g, q; ?! R! p! @
29. use animal\dog;  
    
30. new dog\Dog();

复制代码

如上，使用了

1. use animal\dog;

复制代码

- v/ e& j, \( ]8 G: S! D

cat

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

$ u3 z2 p' {0 l6 y; q

简单总结一下：

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

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

- y2 z) R# L% m9 z; U


' Q4 Q" N4 i6 @9 y0 {

---

欢迎光临 cncml手绘网 (http://www.cncml.com/)

Powered by Discuz! X3.2