接着昨天的内容，第二部分主要整理的是命名空间别名的使用以及namespace关键字和__NAMESPACE__常量的运用,需要的朋友可以参考下。

一：命名空间里的namespace关键字和__NAMESPACE__常量的运用

PHP支持两种抽象的访问当前命名空间内部元素的方法，__NAMESPACE__ 魔术常量和namespace关键字。

常量__NAMESPACE__会储存当前命名空间的名字字符串，如果当前是全局非命名空间，则保存的是空字符串。

关键字 namespace 可用来显式访问当前命名空间或子命名空间中的元素。它等价于类中的 self 操作符。如果不在当前是全局环境的话，那么显式访问的就是全局限定的元素。

__NAMESPACE__实例：

1. <?php  
2. namespace Index\Name{  
3.  var_dump(__NAMESPACE__); //打印string(10) "Index\Name"  
4.    
5.  function foo($classname){  
6.   return __NAMESPACE__.'\\'.$classname;  
7.  }  
8. }  
9.    
10. namespace{  
11.  var_dump(__NAMESPACE__); //打印string(0) ""  
12.    
13.  var_dump(Index\Name\foo('ceshi')); //打印string(16) "Index\Name\ceshi"  
14. }  
15. ?> 

namespace实例：

1. <?php  
2. namespace Index\Name\Index{  
3.  function foo(){  
4.   return 2;  
5.  }  
6. }  
7.    
8. namespace Index\Name{  
9.  var_dump(namespace\Index\foo()); //打印2  
10.    
11.  function foo(){  
12.   return 1;  
13.  }  
14. }  
15.    
16. namespace{  
17.  var_dump(namespace\Index\Name\foo()); //打印1  
18. }  
19. ?> 

二：使用命名空间的别名/导入

命名空间具备允许别名导入以及导入的功能，命名空间导入需使用use关键字，如果还需要设置别名则需要use与as进行配合。

1）导入支持范围：

1：为类名称使用别名

2：为接口名称使用别名

3：为命名空间使用别名

4：5.6以上的php版本，允许函数或者常量使用别名。

2）别名/导入格式

导入格式：use [函数/常量] 命名空间完全限定名[类/接口/函数/常量]

别名导入格式：use [函数/常量] 命名空间完全限定名[类/接口/函数/常量] as 别名

注意：如果没有使用完全限定名的话，也和之前使用命名空间一样，会变成当前命名空间+限定名称来组合出完整的命名空间，所以如果不写完全限定名称，这里一定要多留意组合的结果是否是正确的命名空间。

导入实例：

1. <?php  
2. namespace Index\Col\Ads{  
3.    
4.  const INSTANCE='const_val';  
5.    
6.  function functionName(){  
7.   return 'function_val';  
8.  }  
9.    
10.  class className{  
11.   static function classv(){  
12.    return 'class_val';  
13.   }  
14.  }  
15. }  
16.    
17. namespace Col{  
18.  const INSTANCE='const_val_col';  
19.    
20.  function functionName(){  
21.   return 'function_val_col';  
22.  }  
23.    
24.  class className{  
25.   static function classv(){  
26.    return 'class_val_col';  
27.   }  
28.  }  
29. }  
30.    
31.    
32. namespace Index{  
33. /*引入Index\Col\Ads命名空间*/ 
34. use \Index\Col\Ads;  
35. /*读取引入的命名空间的常量*/ 
36. echo \Index\Col\Ads\INSTANCE.'<br/>'; //打印class_val  
37. /*读取引入的命名空间的函数*/ 
38. echo \Index\Col\Ads\functionName().'<br/>'; //打印class_val  
39. /*读取引入的命名空间的类，接口也是一样的*/ 
40. echo \Index\Col\Ads\className::classv().'<br/>'; //打印class_val  
41.    
42. /*引入常量*/ 
43. use const \Col\INSTANCE;  
44. /*读取常量*/ 
45. echo INSTANCE.'<br/>'; //打印const_val_col  
46.    
47. /*引入函数*/ 
48. use function \Col\functionName;  
49. /*读取函数*/ 
50. echo functionName().'<br/>'; //打印function_val_col  
51.    
52. /*引入类或者接口*/ 
53. use \Col\className;  
54. /*读取类或者接口*/ 
55. echo className::classv().'<br/>'; //打印classname_val_col  
56.    
57. }  
58. ?> 

以上的例子里Index的命名空间里写的是完全限定名，Index\Col\Ads如果没有前面的\全局操作符的话，就会变成Index\Index\Col\Ads的命名空间了，一定要注意。

别名导入实例：

1. <?php  
2. namespace Index\Col\Ads{  
3.    
4.  const INSTANCE='const_val';  
5.    
6.  const NS='namespace';  
7.    
8.  function functionName(){  
9.   return 'function_val';  
10.  }  
11.    
12.  class className{  
13.   static function classv(){  
14.    return 'class_val';  
15.   }  
16.  }  
17. }  
18.    
19.    
20. namespace{  
21. /*引入Index\Col\Ads命名空间，并设置别名Ads*/ 
22. use Index\Col\Ads as Ads;  
23.    
24. /*引入Index\Col\Ads命名空间的常量INSTANCE，并设置别名con*/ 
25. use const Index\Col\Ads\INSTANCE as con;  
26.    
27. /*引入Index\Col\Ads命名空间的函数functionName，并设置别名func*/ 
28. use function Index\Col\Ads\functionName as func;  
29.    
30. /*引入Index\Col\Ads命名空间的类className，并设置别名classn，接口的别名设置方式和这个一样*/ 
31. use Index\Col\Ads\className as classn;  
32.    
33. echo Ads\NS.'<br/>'; //打印namespace  
34. echo con.'<br/>'; //打印const_val  
35. echo func().'<br/>'; //打印function_val  
36. echo classn::classv().'<br/>'; //打印class_val  
37. }  
38. ?> 

这个例子里是全局的非命名空间，所以没有全局操作符也不会影响导入的命名空间。

三：特别补充

1：命名空间首字符不能是数字，必须是字母或者是下划线，否则会报出farse error。

2：define在命名空间内设置的常量默认是全局的（例外：一个文件内多个命名空间用括号包起来的方式define默认设置的是该命名空间的常量），所以如果需要命名空间下的常量，需要特别写明在常量名称里，例如define('Index\CON','CON')和define(__NAMESPACE__.'\CON','CON')这两种方式都是设置命名空间下的常量CON。

常量实例：

1. <?php  
2. namespace Col;  
3. /*define默认设置的是全局的常量*/ 
4. define('CON','globals');  
5.    
6. /*特别声明设立的是当前命名空间下的常量*/ 
7. define(__NAMESPACE__.'\CON','col');  
8.    
9. /*特别声明设立的是Index命名空间下的常量*/ 
10. define('Index\CON','index');  
11.    
12. /*全局操作符后直接跟常量名，所以获取到的是全局的常量CON*/ 
13. var_dump(\CON); //globals  
14.    
15. /*没有任何限定，所以获取的是当前命名空间的常量CON*/ 
16. var_dump(CON); //col  
17.    
18. /*全局限定，读取其对应的Col命名空间的常量CON*/ 
19. var_dump(\Col\CON); //col  
20.    
21. /*全局限定，读取其对应的Index命名空间的常量CON*/ 
22. var_dump(\Index\CON); //index  
23. ?> 

3：看到上面的实例，推及到函数及类（接口）就不一样了，在命名空间里设置的函数及类（接口）都是属于该命名空间的内容，不管是不是一个文件多个命名空间大括号里设置的。

函数和类的实例：可以看出在命名空间内的函数和类是属于命名空间的

index.php

1. <?php  
2. function foo(){  
3.  return 'global';  
4. }  
5.    
6. class fool{  
7.  static function ceshi(){  
8.   return 'global';  
9.  }  
10. }  
11. ?> 

col.php

1. <?php  
2. namespace Col;  
3. require './index.php'; //如果不引入index.php文件，那么下面的\foo()和\foo::ceshi()都会报fatal error  
4.    
5. function foo(){  
6.  return 1;  
7. }  
8.    
9. class fool{  
10.  static function ceshi(){  
11.   return 2;  
12.  }  
13. }  
14.    
15. var_dump(\foo());   //global  
16. var_dump(foo());   //打印1  
17. var_dump(\Col\foo());  //打印1  
18.    
19. var_dump(\fool::ceshi());  //global  
20. var_dump(fool::ceshi());  //打印2  
21. var_dump(\Col\fool::ceshi()); //打印2  
22. ?> 

4：设置命名空间的时候，要注意不要使用php的关键字，例如function、class、abstract之类的，否则会报出parse error。

5：同一个命名空间，不同文件间的使用无须带上命名空间，直接使用函数、常量、类及接口就可以了。

6：一个命名空间的类、常量、接口、函数单独引入另一个命名空间，其中函数、常量、类、接口如果发生了冲突，如果没有用限定词则优先使用单独引入类、常量、接口、函数。

实例：

indext.php

1. <?php  
2. namespace Lic;  
3.    
4. define(__NAMESPACE__.'\CON',1);  
5.    
6. function func(){  
7.  echo 1;  
8. }  
9.    
10. class foo{  
11.  static function ceshi(){  
12.   return 1;  
13.  }  
14. } 

只引入命名空间

1. <?php  
2. namespace Col;  
3. require './indext.php';  
4. use \Lic;  
5.    
6. define(__NAMESPACE__.'\CON',2); //设定命名空间的常量必须写明命名空间，否则是全局的常量  
7.    
8. function func(){  
9.  echo 2;  
10. }  
11.    
12. class foo{  
13.  static function ceshi(){  
14.   return 2;  
15.  }  
16. }  
17.    
18. var_dump(CON); //打印2  
19. var_dump(namespace\CON); //打印2  
20.    
21. func(); //打印2  
22. namespace\func(); //打印2  
23.    
24. var_dump(foo::ceshi()); //打印2  
25. var_dump(namespace\foo::ceshi()); //打印2 

如果单独引入类、接口、函数、常量的情况，名称冲突且没有用限定的话优先使用引入的：

1. <?php  
2. namespace Col;  
3. require './indext.php';  
4. use \Lic\foo;  
5. use function \Lic\func;  
6. use const \Lic\CON;  
7.    
8. define(__NAMESPACE__.'\CON',2); //设定命名空间的常量必须写明命名空间，否则是全局的常量  
9.    
10. function func(){  
11.  echo 2;  
12. }  
13.    
14. class foo{  
15.  static function ceshi(){  
16.   return 2;  
17.  }  
18. }  
19.    
20. var_dump(CON); //打印1  
21. var_dump(namespace\CON); //打印2  
22.    
23. func(); //打印1  
24. namespace\func(); //打印2  
25.    
26. var_dump(foo::ceshi()); //打印1  
27. var_dump(namespace\foo::ceshi()); //打印2 

暂时就补充到这里，以后还有后续的再添加。。。

Tags: php命名空间

分享到：