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

文章大纲：

使用namespace的目的

namespace的使用方法

使用use的目的

use的使用方法

* X5 C0 e! Y" ?* `! T
8 G& U, D& m( f' S8 G5 O$ c8 r; D使用namespace的目的：

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

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

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

; q* M& q* k! f+ a9 r  wnamespace的使用方法：

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

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

1. namespace one;
   - w+ F1 f4 t  }: ]8 E( c6 B; H
2. namespace One;
   " P1 z. d7 c" l  w
3. namespace ONE;

复制代码

$ Y6 ^+ P: C4 ]

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

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

1. //1.php   
   
2. class Person{
   * I7 M+ _" v- r8 l4 s
3.     function __construct(){
   6 R2 o) [5 Z7 T" R
4.             echo 'I am one!';
   
5.         }
   
6. }

复制代码

1. //name.php
   
2. require_once './1.php';
   
3. 
   
4. new Person();     //输出 I am one!;
   , \6 V3 U7 Z+ n8 M( q7 w# n* N
5. new \Person(); //输出 I am one!;

复制代码

$ R/ o  f5 b2 e' v( t3. new类时，带上命名空间时，之间一定用反斜杠字符，而不是顺斜杠。

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

1. //name.php
   & \  [- d& T2 s
2. require_once './1.php';
   
3. new /Person();  // 代码报错：Parse error: syntax error, unexpected '/'

复制代码

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

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

1. //1.php   
   9 u, V1 n* l3 p- h" r0 K% H- W; I& S
2. namespace one;
   $ z8 u  s, y. }, Q
3. class Person{
   ; I$ o" ~' W, x7 z5 y- w" ~
4.     function __construct(){
   * D+ {+ g1 ]- O
5.             echo 'I am one!';
   , I- U! S" y: G7 ^4 Z0 X8 k" _
6.         }
   
7. }

复制代码

1. //name.php
   7 L5 J' T# F* k8 p% H. X1 v
2. require_once './1.php';
   + F7 n3 `" k) S3 Y
3. new \one\Person(); //输出 I am one!;
   
4. new \Person(); //代码报错：Fatal error: Class 'Person' not found

复制代码

! w  d7 E4 a4 [$ W1 X

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

% w5 ~- c! [3 n8 {1 p9 X5.命名空间声明后的代码便属于这个命名空间，即使有include或require也不影响（重点是对后半句的理解，具体看代码）。
" [3 p: `3 f% H

1. //1.php   
   
2. namespace one;
   
3. class Person{
   
4.     function __construct(){
   ' n- o8 u+ n! m! v; ]: k
5.             echo 'I am one!';
   
6.         }
   
7. }

复制代码

1. //name.php
   
2. namespace test;
   : w* ~, e  `8 U/ ?, j1 a
3. require './1.php';
   
4. new \one\Person(); //输出 I am one!;
   
5. new Person();      //这里结果会是什么呢，猜猜看
   # p" M( ^7 H3 S1 W
6. 最后一行结果报错：
   8 z: n5 T8 ], S4 I' h3 v
7. Fatal error:  Class 'test\Person' not found

复制代码

3 ~/ `  |$ q& p) q- k. t: K# s+ X

( X, a( H  Y6 N9 @; D5 \1 t首先，这里与第2点比较一下：

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

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

最后一行换成

1. new \Person();

复制代码

. Y( g6 \( m3 Y

结果报错：

1. Fatal error:  Class 'Person' not found

复制代码

接着，就说说当前这点。

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

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

1. //name.php
   ! D+ u, ?& O" d
2. namespace test;
   
3. require './1.php';
   
4. 
   
5. class Person{
   
6.     function __construct(){
   
7.             echo 'I am test!';
   : e4 y. }7 m% ]8 f- |( B" }( k* T" P
8.         }
   
9. }
   
10. 
    . Y: u% j- i- O; {  o
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;
   , W: c- V8 y. x$ v# T$ i. X5 d
3. namespace one;
   
4. class Person{
   2 d/ b8 {2 l9 _
5.     function __construct(){
   7 p0 K+ A0 v  A6 l. g6 ]
6.             echo 'I am one!';
   
7.         }
   9 x3 u9 D/ S  Y! W2 ~0 b$ ?+ j
8. }
   3 W- d0 T9 Q2 k8 b  G8 r' N  h) u/ A
9. 
   
10. class Person{
    
11.     function __construct(){
    * x, }9 @6 D2 g) `0 R
12.             echo 'I am test!';
    ) @* s  E/ [$ r: M( ~
13.         }
    
14. }

复制代码

- a9 H* J0 e% X

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

1. Fatal error:  Cannot redeclare class one\Person

复制代码

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

( s/ ^( i; S& c# n0 B! ]0 t6.namespace里不包含类名称，即使存在与类名称同名的部分，那也不代表类。new类时，还是得将这部分带上。

1. //name.php
   
2. 
   7 D- R" d! y2 b( _: e
3. namespace test\person;
   
4. 
   1 ?3 j4 O8 O5 J0 A+ v: z1 P8 X  q
5. class Person{
   
6.     function __construct(){
   ' l+ H% T2 K  D9 o9 t; I/ @7 j9 Z
7.             echo 'I am test!';
   
8.         }
   
9. }
   8 k) B1 I: x- R: x. y8 C" h" t
10. new \test\person\Person();  //命名空间里person无法代表类名

复制代码

; n( k. J) S( N. e9 `  @

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

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

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

1. //name.php
   : B. P  o0 V  K3 N: A& m
2. 
   5 T; Y8 V1 Z" L! @0 i6 L- z! o0 E
3. namespace test;
   
4. echo 'zhai14';
   
5. namespace zhai;
   
6. require './1.php';

复制代码

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

使用use的目的：

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

" x! E5 l: @8 w3 }% u, p! Ouse的使用方法：1.new类时，最前面无需用反斜杠。此外，use后没有as时，缩短的命名空间默认为最后一个反斜杠后的内容。
- J* C  d) `: L! i4 s

1. //name.php
   - \' |* g. [& {0 g: t- J7 ^6 x
2. 
   ; U5 a8 z# B9 z
3. namespace animal\dog;
   ; S  r/ R0 L& G- P" s
4. 
   ) ^# p. z( W% q5 `
5. class Life{
   + u2 C' J, `) `; g3 H& s6 d9 ]
6.     function __construct(){
   
7.             echo 'dog life!';
   
8.         }
   
9. }
   
10. 
    
11. namespace animal\cat;
    + O; L5 N1 k1 Y. a+ d
12. 
    
13. class Life{
    
14.     function __construct(){
    
15.             echo 'cat life!';
    & q' w+ Y6 U6 F0 j
16.         }
    : z( b8 ~. |+ R& ?$ E
17. }
    
18. 
    9 x; g8 N5 F5 K% C* f
19. new Life();  //按照代码执行顺序，这里默认animal\cat这个命名空间
    
20. new \animal\dog\Life();  //A
    
21. 
    
22. use animal\dog;  //a
    0 {$ N0 @; i; o
23. new dog\Life();  //B
    
24. 
    4 x9 z) V% w* @6 L7 o! a
25. use animal\dog as d;  //b
    
26. new d\Life();

复制代码

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

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

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

1 }2 E, H/ K7 v, ]

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

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

1. use animal\dog;

复制代码

相当于

1. use animal\dog as dog;

复制代码

2.namespace后面不建议加类名，但use后可以。
( N$ }4 o2 ~6 Y( A7 G$ v: ]

1. //name.php
   
2. 
   . l; k8 b5 z0 O. A/ C! b
3. namespace animal\dog;
   $ B& _  P: h' L+ ^+ X7 c# L
4. 
   # v' Z6 F6 w& D% k
5. class Life{
   8 M8 d$ r& y  f; a  ?, F5 Y0 Y/ k
6.     function __construct(){
   
7.             echo 'dog life!';
   2 i% X( n/ N6 E+ O/ F
8.         }
   ) X: O  }  @, S# R. Y5 `6 @9 {0 s
9. }
   
10. 
    7 _$ h, T( {' Z5 D# c) e3 [2 b/ i0 v
11. namespace animal\cat;
    
12. 
    ! b" q: f& U1 g: b! T
13. class Life{
    
14.     function __construct(){
    
15.             echo 'cat life!';
    ) L/ P% d0 m- h2 m  q6 ^
16.         }
    
17. }
    ' F; ]2 V, B. d! ~* e4 u7 }9 i4 U: Q0 B
18. 
    + c; b& L$ I! b+ `# }5 v/ K% g
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

复制代码

' @& O+ b6 \% e" y5 |

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

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

1. //name.php
   
2. 
   
3. namespace animal\dog;
   
4. 
   7 C7 a  j/ O# c; D- B! d
5. class Life{
   
6.     function __construct(){
   
7.             echo 'dog life!';
   
8.         }
   + [9 W, y: m; x( q! r- L: H  x
9. }
   
10. class Dog{
    ; {2 o; D8 f- f" Z, k- O7 P" e
11.     function __construct(){
    5 S8 a$ ~6 Q2 z9 e
12.             echo 'dog in dog!';
    
13.         }
    
14. }
    
15. 
    
16. namespace animal\cat;
    7 c! y' @# Z. q% n
17. 
    6 D. q( [, i! Y% }. S# H0 s
18. // class Dog{
    
19. //     function __construct(){
    1 c7 n" I- G! l( N# b
20. //             echo 'dog in cat!';
    ; w! K/ }* }. U( `% u, d, ^. B
21. //         }
    
22. // }
    
23. class Life{
    + D& F: P0 ], h1 I( F9 h
24.     function __construct(){
    
25.             echo 'cat life!';
    . c7 I: ]% W1 T7 u& m
26.         }
    " A9 `$ O$ l% H+ r; W  ~; |
27. }
    
28. 
    7 n6 v- m. U, F3 h. u0 R
29. use animal\dog;  
    
30. new dog\Dog();

复制代码

如上，使用了

1. use animal\dog;

复制代码

cat

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

简单总结一下：

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

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

& {$ T: r! y$ l" u9 _1 f* A9 k
2 u5 K, L5 G1 ]3 @+ ]
0 \; i0 ^8 D  [8 [/ M
; j$ |+ d0 N( X9 I; s* u
, U* l: h; \0 L1 s