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

文章大纲：

使用namespace的目的

namespace的使用方法

使用use的目的

use的使用方法

- O! \, b; _1 l! I+ _. E! q9 }使用namespace的目的：

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

& M# o& e# N. [  v

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

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

" G* w) n0 d. r' i' t; ?- wnamespace的使用方法：

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

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

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

复制代码

8 \$ P  P- G/ I5 C) B

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

  {6 b3 q* K# {- k5 {# j2. 没有定义命名空间，就理解为使用顶级命名空间。new类时，可以在类前加上反斜杠\,也可以不加。

1. //1.php   
   / }0 V9 ?+ h% J
2. class Person{
   
3.     function __construct(){
   
4.             echo 'I am one!';
   ' r+ D! d6 Z1 d& z  s5 v' g
5.         }
   
6. }

复制代码

1. //name.php
   8 G8 `: y- d9 P+ X$ E# B
2. require_once './1.php';
   5 G  P8 \$ Q0 a; M: f# p- Z9 F
3. 
   
4. new Person();     //输出 I am one!;
   $ V" x; T# `) r) j
5. new \Person(); //输出 I am one!;

复制代码

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

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

1. //name.php
   
2. require_once './1.php';
   
3. new /Person();  // 代码报错：Parse error: syntax error, unexpected '/'

复制代码

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

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

1. //1.php   
   
2. namespace one;
   4 [7 P' c. k. X" [
3. class Person{
     g- Y) `! G0 S- l! x9 k  }- \
4.     function __construct(){
   
5.             echo 'I am one!';
   $ U2 t7 z0 ?# I2 P0 d: ]
6.         }
   
7. }

复制代码

1. //name.php
   . M7 }' ^4 ]* }+ D% \6 P5 e
2. require_once './1.php';
   
3. new \one\Person(); //输出 I am one!;
   
4. new \Person(); //代码报错：Fatal error: Class 'Person' not found

复制代码

5 Y0 D' _+ L: u$ ]2 r7 |7 O

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

5 O$ }1 W+ \: D" B5.命名空间声明后的代码便属于这个命名空间，即使有include或require也不影响（重点是对后半句的理解，具体看代码）。

1. //1.php   
   9 ^" u% [' P- X0 s7 t+ X
2. namespace one;
   
3. class Person{
   , C! j% K7 O8 q3 j
4.     function __construct(){
   3 i/ `5 {3 r# `; U9 q
5.             echo 'I am one!';
   
6.         }
   
7. }

复制代码

1. //name.php
   - L* d7 ?. q/ _9 b4 s' z
2. namespace test;
   
3. require './1.php';
   & x% n# [# F+ S8 K5 z' `
4. new \one\Person(); //输出 I am one!;
   3 F5 e2 \( o" O# `3 \7 ^5 C
5. new Person();      //这里结果会是什么呢，猜猜看
   8 |5 `' n3 e0 f' l5 |. p' g2 P" I
6. 最后一行结果报错：
   " y6 {( j; }* ]
7. Fatal error:  Class 'test\Person' not found

复制代码

9 @& w1 _' K0 w# S2 _% j0 D

9 A* D) \6 Y. l首先，这里与第2点比较一下：

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

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

最后一行换成

1. new \Person();

复制代码

结果报错：

1. Fatal error:  Class 'Person' not found

复制代码

接着，就说说当前这点。

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

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

1. //name.php
     Q/ O; O8 j# d, B( \$ c
2. namespace test;
   * D% U% R7 o1 u5 ^; h4 V
3. require './1.php';
   # d3 {: y7 D% U% G$ {" c" M
4. 
   
5. class Person{
   
6.     function __construct(){
   
7.             echo 'I am test!';
   
8.         }
   
9. }
   8 @! O4 D- o7 p8 u6 m# N8 {
10. 
    
11. new \one\Person(); //输出 I am one!;
    
12. new Person();    //这里结果会是什么，自己猜猜看

复制代码

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

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

1. //name.php
   
2. namespace test;
   
3. namespace one;
   
4. class Person{
   2 c/ H( I9 p3 p% H( ?! A/ t) g, O) p
5.     function __construct(){
   + \# f. X" K! s! L7 F0 ?
6.             echo 'I am one!';
   , ?' m8 k! L" ^- o" [
7.         }
   : [/ \6 u: k- L$ ~" f0 R; t" X# W
8. }
   6 m( W) r* m* X3 g5 x& s
9. 
   
10. class Person{
    : C1 D4 N- ]3 O
11.     function __construct(){
    6 s. T7 N, Q. |, F- a, _
12.             echo 'I am test!';
    ; H8 U" p; A2 D+ z
13.         }
    
14. }

复制代码

% X; \/ S- [$ z. Q) F

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

1. Fatal error:  Cannot redeclare class one\Person

复制代码

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

6.namespace里不包含类名称，即使存在与类名称同名的部分，那也不代表类。new类时，还是得将这部分带上。

1. //name.php
     T; Z! r: d! o0 a0 V/ U
2. 
   - K( `% d! ?$ ]! X3 L7 W4 }: `
3. namespace test\person;
   
4. 
   
5. class Person{
   + c1 Z6 _3 e# p1 ~$ U3 k) j
6.     function __construct(){
   
7.             echo 'I am test!';
   & Z. k8 t  n% [' G
8.         }
   , J( e. j) e8 E9 I' R
9. }
   
10. new \test\person\Person();  //命名空间里person无法代表类名

复制代码

  W* t2 b2 N6 T! h& d! K7 O( o: g( \: S

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

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

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

1. //name.php
   
2. 
   0 w" O2 G) p9 Y
3. namespace test;
   5 `2 f- b6 ]% _2 a7 s
4. echo 'zhai14';
   ) D2 K, a0 n# V' E
5. namespace zhai;
   
6. require './1.php';

复制代码

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

使用use的目的：

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

: ]5 L) d2 k5 N5 q8 ouse的使用方法：1.new类时，最前面无需用反斜杠。此外，use后没有as时，缩短的命名空间默认为最后一个反斜杠后的内容。
6 N9 S& v+ |$ D0 ~+ j5 L1 ?, G

1. //name.php
   & j/ R" N1 K# C8 Q. s+ A' \
2. 
   ( @9 q- m0 g# j" W
3. namespace animal\dog;
   
4. 
   5 x1 O8 x1 y! g/ |$ \& b
5. class Life{
   
6.     function __construct(){
   2 ]! C5 M9 k" d- I% E$ @; }
7.             echo 'dog life!';
   
8.         }
   
9. }
   & W8 [- x/ Z8 m
10. 
    
11. namespace animal\cat;
    
12. 
    
13. class Life{
    6 V: @4 i% d, K& }
14.     function __construct(){
    
15.             echo 'cat life!';
    
16.         }
    ( ?. Y: c9 ?( p2 R: _
17. }
    
18. 
    8 I8 y7 e: w( M, @& g1 s- q
19. new Life();  //按照代码执行顺序，这里默认animal\cat这个命名空间
    2 }$ w; a/ q. Z7 \) q3 P- d
20. new \animal\dog\Life();  //A
    
21. 
    ; X; E# A1 y6 _; ^8 _2 R6 h+ O
22. use animal\dog;  //a
    
23. new dog\Life();  //B
    
24. 
    
25. use animal\dog as d;  //b
      D3 t7 j% w) F, n6 e
26. new d\Life();

复制代码

6 k) s0 Z- O8 y; D5 R5 K

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

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

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

" \! J" D4 q' K, J/ q

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

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

1. use animal\dog;

复制代码

* b) t& ^6 R% u; Y5 w. z& }6 j

相当于

1. use animal\dog as dog;

复制代码

% X( o, L% j4 |& t: P5 N2.namespace后面不建议加类名，但use后可以。

1. //name.php
   
2. 
   
3. namespace animal\dog;
   - m# I/ l+ y0 y! F7 G
4. 
   
5. class Life{
   
6.     function __construct(){
   * l  \* q3 v. A! d  a
7.             echo 'dog life!';
   5 z) _2 |; K( v) d7 v# P  v
8.         }
   
9. }
   
10. 
    
11. namespace animal\cat;
    / A$ I; {7 }% h6 [7 f* }
12. 
    
13. class Life{
    
14.     function __construct(){
    $ j9 G; }' `  w# P& y3 K
15.             echo 'cat life!';
    
16.         }
    
17. }
    9 Z, k6 W( k% @- Z7 V: p5 o4 E7 S
18. 
    
19. use animal\dog\Life as dog;  
    0 {7 y" o7 }( J4 V
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

复制代码

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

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

1. //name.php
   
2. 
   
3. namespace animal\dog;
   
4. 
   
5. class Life{
   
6.     function __construct(){
   ' R. X3 X% }; ^/ }" X
7.             echo 'dog life!';
   ; V  a4 I3 ^2 R5 E& c* r8 y
8.         }
   
9. }
   
10. class Dog{
    , V, A* H0 _) v$ n) H
11.     function __construct(){
    . e8 }2 P" w6 I4 S
12.             echo 'dog in dog!';
    1 F& |. a1 ~; c7 n! |# |+ p( R
13.         }
    
14. }
    4 ^( }* q$ K. z; I- b2 I
15. 
    
16. namespace animal\cat;
    4 {1 h$ b7 H" I& L
17. 
    " w$ a- @8 p- }# L/ `+ P6 u
18. // class Dog{
    , a! `7 m- s  i$ H& c4 e
19. //     function __construct(){
    2 X+ {: N2 z0 r5 [9 ]" l+ f0 ~4 o
20. //             echo 'dog in cat!';
    
21. //         }
    3 K% h) x/ C! s  m& a9 A
22. // }
    " n+ j3 @9 R/ K8 v4 |
23. class Life{
    # b' F8 v. q6 s8 l# v
24.     function __construct(){
    / J- d" a6 P1 [9 J  f7 y0 X! p
25.             echo 'cat life!';
    
26.         }
    
27. }
    4 e! N9 B7 z; J% D! ]- ~1 V& O$ D
28. 
    
29. use animal\dog;  
    : }$ s# z" M6 Q! H% R# A
30. new dog\Dog();

复制代码

" Z! i% T4 s2 Q/ r8 _6 D8 `; z

如上，使用了

1. use animal\dog;

复制代码

cat

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

: T: F) S2 Q2 s3 P

简单总结一下：

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

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

, Y8 s0 Z, r) ]% \
% Y( u& t9 m7 ]+ \7 B
) C3 C0 d% ?+ g& q  W5 H

- v5 ?5 a6 _6 U- _0 L& \