search

博客列表 >【PHP 面向对象】面向对象(OOP)编程之解读命名空间使用知识点归纳总结（四）

【PHP 面向对象】面向对象(OOP)编程之解读命名空间使用知识点归纳总结（四）

　一纸荒凉* Armani
　一纸荒凉* Armani原创
2021年05月11日 14:30:09950浏览

PHP namespace：命名空间

什么是命名空间？从广义上来说，命名空间是一种封装事物的方法，在很多地方都可以见到这种抽象概念。例如，在操作系统中目录用来将相关文件分组，对于目录中的文件来说，它就扮演了命名空间的角色。

举个简单的例子，文件foo.txt可以同时在目录 /home/greg和/home/other 中存在，但在同一个目录中不能存在两个 foo.txt文件。另外，在目录 /home/greg外访问foo.txt文件时，我们必须将目录名以及目录分隔符放在文件名之前，例如 /home/greg/foo.txt。这个原理应用到程序设计领域就是命名空间的概念。

PHP 命名空间可以解决以下两类问题：

  • 用户编写的代码与 PHP 内部的类/函数/常量或第三方类/函数/常量之间的命名冲突；
  • 为很长的标识符名称（通常是为了缓解第一类问题而定义的）创建一个别名（或简短）的名称，以提高源代码的可读性。
  • PSR-4规范 https://www.cnblogs.com/q1104460935/p/8084396.html

定义命名空间

定义命名空间使用namespace关键字

namespace命名空间名称解析规则

1.非限定名称：名称中不包含命名空间分割符，如：myself

2.限定名称：名称中含有命名空间分割符，如：admin\myself

3.完全限定名称：名称中包含分割符，并以命名空间分割符开始，如：\admin\myself （即绝对路径的概念）

虽然任意合法的 PHP 代码都可以包含在命名空间中，但只有类（包括抽象类和 traits）、接口、函数和常量等类型的代码受命名空间的影响。

  1. <?php
  2.     /**
  3.  * 命名空间:namespace
  4.  * 全局成员: 常量,函数,类(接口),默认声明在全局空间中的
  5.  * 优点:全局调用
  6.  * 缺点:不能重复命名
  7.  * 
  8.  * 
  9.  * php5.3以后引入C# Java中应用成熟的命名空间
  10.  */
  12. // 在声明命名空间之前除了用于定义源文件编码方式的 declare 语句外，所有非 PHP 代码（包括空白符）都不能出现在命名空间声明之前
  13.     namespace MyProject;
  14.     const CONNECT_OK = 1;
  16.     interface Itest
  17.     {
  18.         public function getSite();
  19.     }
  21.     class className implements Itest {
  22.         public function getSite()
  23.         {
  24.             return __METHOD__." 命名空间<br>";
  25.         }
  26.     }
  28.     namespace OtherProject;
  29.     const CONNECT_OK = 1;
  30.     interface Itest
  31.     {
  32.         public function getSite();
  33.     }
  35.     class className implements Itest {
  36.         public function getSite()
  37.         {
  38.             return __METHOD__." 命名空间<br>";
  39.         }
  40.     }
  42.     // 也可以使用大括号进行包裹
  43.     namespace AnotherProject;
  44.         const CONNECT_OK = 1;
  45.         class className {
  46.             /* ... */
  47.         }
  49.         //在AnotherProject空间中访问MyProject空间里的类, 应该使用"\"表示root空间(全局空间)
  50.         echo (new \MyProject\className)->getSite();//绝对路径 类的完全限定名称\MyProject\className
  51.         echo (new \OtherProject\className)->getSite();
  52.         /*
  53.         MyProject\className::getSite 命名空间
  54.         OtherProject\className::getSite 命名空间
  55.          */
  56. ?>

注意：在实际的编程实践中，并不提倡在同一个文件中定义多个命名空间。定义多个命名空间主要用于将多个 PHP 脚本合并在同一个文件中。在定义多个命名空间时建议使用大括号形式的语法。

将全局的非命名空间中的代码与命名空间中的代码组合在一起，只能使用大括号形式的语法，同时全局代码必须用一个不带名称的 namespace 语句加上大括号括起来

  1. <?php
  2.     namespace MyProject{        // 命名空间中的代码
  3.         const CONNECT_OK = 1;
  4.         class className {
  5.             /* ... */
  6.         }
  7.     }
  8.     namespace AnotherProject{
  9.         const CONNECT_OK = 1;
  10.         class className {
  11.             /* ... */
  12.         }
  13.     }
  14.     namespace { // 命名空间外的全局代码 全局空间  匿名空间   公共空间
  15.         $obj = new MyProject\className;
  16.     }
  17. ?>

定义子命名空间

与目录和文件的关系很象，PHP 中的命名空间也允许指定层次化的命名空间名称。因此，命名空间的名字可以使用分层次的方式定义：

namespace App\Model;
namespace App\Controller\Home;

  1. <?php
  2.     namespace Controller\Home\MyProject{  
  3.         const CONNECT_OK = 1;
  4.         class className {
  5.             public function getInfo(){
  6.                 echo __METHOD__." hello world<br>";
  7.             }
  8.         }
  9.     }
  10.     namespace Controller\Home{
  11.         const CONNECT_OK = 1;
  12.         class className {
  13.             public function getInfo(){
  14.                 echo __METHOD__." hello world<br>";
  15.             }
  16.         }
  18.         // 查看类的完全限定名称
  19.         echo className::class."<br>";
  20.         // Controller\Home\className
  21.         (new MyProject\className)->getInfo(); 
  22.         // Controller\Home\MyProject\className::getInfo hello world 
  23.     }
  25.     // 命名空间外的全局代码 全局空间  匿名空间   公共空间
  26.     namespace {  
  27.         class className {
  28.             public function getInfo(){
  29.                 echo __METHOD__." hello world<br>";
  30.             }
  31.         }  
  32.         (new className)->getInfo();
  33.          (new Controller\Home\className)->getInfo();  
  34.         $obj = new Controller\Home\MyProject\className();
  35.         $obj->getInfo();
  36.         /*
  37.         className::getInfo hello world
  38.         Controller\Home\className::getInfo hello world
  39.         Controller\Home\MyProject\className::getInfo hello world
  40.          */
  41.     }
  42. ?>

使用命名空间

在文件系统中访问一个文件有三种方式：

  • 相对文件名形式如 foo.txt。它会被解析为 currentdirectory/foo.txt，其中 currentdirectory 表示当前目录。因此如果当前目录是 /home/foo，则该文件名被解析为 /home/foo/foo.txt；
  • 相对路径名形式如 subdirectory/foo.txt。它会被解析为 currentdirectory/subdirectory/foo.txt；
  • 绝对路径名形式如 /main/foo.txt。它会被解析为 /main/foo.txt。

PHP 命名空间中的类名可以通过三种方式引用：

  1. 非限定名称，或不包含前缀的类名称

  2. 限定名称,或包含前缀的名称

  3. 完全限定名称，或包含了全局前缀操作符的名称

file1.php

  1. <?php
  2.     function getInfo(){
  3.             return '我是全局空间下的函数';
  4.     }
  5.     function foo() {
  6.         echo __METHOD__."<br>";
  7.     }
  8. ?>

file2.php

  1. <?php
  2. namespace Foo\Bar\subnamespace; 
  4. const FOO = 1;
  5. function foo() {
  6.     echo __METHOD__."<br>";
  7. }
  8. class foo
  9. {
  10.     static function staticmethod() {
  11.         echo __METHOD__."<br>";
  12.     }
  13. }
  15. namespace Foo\Bar;
  16. include 'file1.php';
  18. const FOO = 2;
  19. function foo() {
  20.     echo __METHOD__."<br>";
  21. }
  22. class foo
  23. {
  24.     static function staticmethod() {
  25.         echo __METHOD__."<br>";
  26.     }
  27. }
  29. /* 非限定名称 */
  30. foo(); // Foo\Bar\foo
  31. foo::staticmethod(); // Foo\Bar\foo::staticmethod
  32. echo FOO; // 解析为常量 Foo\Bar\FOO  2
  33. echo getInfo(); // 我是全局空间下的函数
  34. // 如果命名空间中的函数或常量未定义，则该非限定的函数名称或常量名称会被解析为全局函数名称或常量名称
  36. /* 限定名称 */
  37. subnamespace\foo(); // Foo\Bar\subnamespace\foo
  38. subnamespace\foo::staticmethod(); // Foo\Bar\subnamespace\foo::staticmethod
  39. echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO 1
  41. /* 完全限定名称 */
  42. \Foo\Bar\foo(); // Foo\Bar\foo
  43. \Foo\Bar\foo::staticmethod(); // Foo\Bar\foo::staticmethod
  44. echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO 2
  45. ?>

file3.php

  1. <?php
  2. namespace Foo;
  4. function strlen($str) {
  5.     return "Foo空间的strlen";
  6. }
  7. const INI_ALL = 3;
  8. class Exception {}
  9. class Test {
  10.     const APP_NAME = '我是Foo空间中类常量 hello world';
  11. }
  13. echo strlen('hi'); // Foo空间的strlen
  14. echo INI_ALL; // 当前空间下的常量 3
  15. var_dump(new Exception); // object(Foo\Exception)#1 (0) { }
  16. echo Test::APP_NAME; // 我是Foo空间中类常量 hello world
  17. // 如果调用的函数与系统函数重名,或者与定义在全局空间中的自定义函数同名,优先调用的是当前空间中的函数, 找不到时,才会去全局空间查找
  19. echo "<pre>";
  20. echo \strlen('hi')."<br>" ; // 调用全局函数strlen
  21. echo \INI_ALL."<br>"; // 访问全局常量 INI_ALL
  22. var_dump(new \Exception('error')); // 实例化全局类 Exception
  23. echo \Test::APP_NAME; // hello world
  26. namespace {
  27.     class Test
  28.     {
  29.         const APP_NAME = ' hello world';
  30.     }
  31. }
  32. ?>

注意：访问任意全局类、函数或常量，都可以使用完全限定名称，例如 \strlen() 或 \Exception 等。

命名空间导入

PHP 允许通过别名引用或导入的方式来使用外部的命名空间，这是命名空间的一个重要特征。

使用 use 关键字可以实现命名空间的导入，从 PHP5.6 开始允许导入函数和常量，并为它们设置别名。语法格式如下：

use namespace;

在 PHP 中，别名是通过操作符 use 与 as 来实现的，语法格式如下：

use 命名空间 as 别名;

示例：使用 use 操作符导入和使用别名

  1. <?php
  2. /**
  3.  * use 在命名空间中的作用
  4.  * 1. 引入别的命名空间到当前空间 为命名空间起别名
  5.  * 2. 引入别的命名空间中的类到当前空间使用, 为别的命名空间中的类起别名
  6.  */
  8. namespace app\admin\controller;
  10. //控制器类index
  11. class Index
  12. {
  13.     public function index()
  14.     {
  15.         return __METHOD__;
  16.     }
  17. }
  18. const CONSTANT = "zhang";
  19. function getName($name){
  20.     return $name;
  21. }
  25. namespace extend\lib;
  26. // 在当前空间下访问app\admin\controller中的Index类
  27. echo ( new \app\admin\controller\Index )->index(),'<hr>';
  29. //1. use 导入命名空间
  30. use app\admin\controller;
  32. // 成功导入命名空间以后 就可以不使用类的完全限定名称调用类元素 
  33. echo (new controller\Index)->index(),'<hr>';
  35. //2.为空间起别名
  36. use app\admin\controller as app;
  37. echo (new app\Index)->index(),'<hr>';
  39. // use 直接引入外部空间类-------------
  41. //1. 使用use 引入一个外部类到当前空间
  42. use app\admin\controller\Index;
  44. //导入类以后就可以使用非限定名称度调用类元素
  45. echo (new Index)->index(),'<hr>';
  47. //2.为引入的外部空间该类起别名
  48. use app\admin\controller\Index as in;
  49. echo (new in)->index(),'<hr>';
  52. // use 还可以导入一个常量和函数----------
  54.     // 导入一个函数
  55.     use function app\admin\controller\getName;
  56.     echo getName("zhang "); // zhang
  57.     // 导入一个函数并定义别名
  58.     use function app\admin\controller\getName as func;
  59.     echo func("shuai"); // shuai
  60.     // 导入一个常量
  61.     use const app\admin\controller\CONSTANT;
  62.     echo "<br>".CONSTANT;

命名空间类的自动加载

在早期 PHP 开发中，开发者最烦的就是一堆 include 函数包含了一大堆文件，而且早期时候 PHP 面向对象的概念确实太差了，因为 PHP 作为一种脚本语言，不存在程序入口，所以脚本顺序化执行的诱惑力实在是很大，即使面向对象开发，但是缺少极佳的模块划分导入机制，代码可以说很难有美感。

  1. /**
  2.  * 类的加载
  3.  */
  5.  //应用入门文件
  6. namespace app;
  8. //传统引入加载方式
  9. //  require 'app/models/StaffsModel.php';
  10. //  require 'app/models/UserModel.php';
  11. //  require 'app/controller/User.php';
  14. //类的自动加载
  15. require 'app/autoload.php';
  18. use app\models\StaffsModel;
  19. use app\models\UserModel;
  20. use app\controller\User;
  21. use app\controller\Login;
  23.  $staffs = new StaffsModel;
  24.  $user = new UserModel;
  25.  $userController = new User;
  26.  $loginController = new Login;
  27. /*
  28. 类名:app\models\StaffsModel
  29. 类名:app\models\UserModel
  30. 类名:app\controller\User
  31. 类名:app\controller\Login
  32. */

autoload() 是系统函数，名称是固定的，而且该函数没有方法体，需要我们自定义方法体。另外，该函数是自动调用的，当我们 new 一个类时，如果当前源文件中找不到这个类，PHP 则会自动调用 autoload() 函数，并将类名传递给 __autoload() 函数。

  1. spl_autoload_register(function($className)
  2. {
  3.     //先查看要加载的类
  4.     printf('类名:%s<br>',$className);
  5.     //将类命名空间与类文件所在的路径进行一一映射, linux /    windows \
  6.     // app\controller\User <=> app/controller/User.php
  7.     //解决在linux系统中命名空间失效  class not found 
  9.     $file = str_replace('\\',DIRECTORY_SEPARATOR,$className).'.php';
  11.     if( !(is_file($file) && file_exists($file)) )
  12.     throw new \Exception('文件名不合法或者文件不存在');
  13.     require $file;   
  14. });

【PHP 面向对象】面向对象(OOP)编程之魔术方法实现重载知识点归纳总结（三）
【PHP 面向对象】面向对象(OOP)编程知识点归纳总结（二）
【PHP 面向对象】面向对象(OOP)编程知识点归纳总结（一）

上一条：210428 PHP 函数 返回值 参数 闭包/匿名函数下一条：4-30用户注册界面
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多