登录  /  注册
首页 > 博客列表 > 0210作业-命名空间-php培训十期线上班
博主信息
博文 22
粉丝 1
评论 0
访问量 19483
专题推荐
更多>
相关推荐
热门教程
更多>
相关教程
热门推荐
最新课程
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
0210作业-命名空间-php培训十期线上班
Dseven
原创
819人浏览过

0210作业-命名空间-php培训十期线上班

一. 编程题:

1. 实例演示完全限定名称访问四类全局成员的方式

1.1 基本知识点

  • 全局成员: 类, 接口, 函数, 常量
  • 全局空间: 用反斜线来表示 \, 根目录
  • 完全限定名称: 从全局空间开始查找成员, 类似绝对路径
  • 限定名称: 从当前空间开始查找成员, 类似相对路径
  • 非限定名称: 仅在当前空间中查找成员, 类似当前路径
  • 四类全局成员：接口、类、函数、常量
  • define()定义的常量是全局的，不受命名空间影响

1.2 实例展示完全限定名称访问四类全局成员

  • 访问接口
    1. namespace part1;
    2.   {
    3.       //定义一个接口
    4.       interface iTest{
    5.           public function info();
    6.       }
    7.   }
    8. namespace part2;
    9. {
    10.   //用完全限定名称来访问part1中定义的接口
    11.   class cTest1 implements \part1\iTest{
    12.       public function info(){
    13.           return '实现接口的类';
    14.       }
    15.   }
    16.   $obj1 = new cTest1();
    17.   echo $obj1->info();
    18.   echo '<hr>';
    19. }
  • 访问类
    1. namespace part1\lib;
    2.   {
    3.   //实现接口的类
    4.   class cTest implements \part1\iTest {
    5.       public function info(){
    6.           return [
    7.               'namespace'=>__NAMESPACE__,
    8.               'classname'=>__CLASS__,
    9.               'classname1'=>self ::class,
    10.               'methode'=>__METHOD__,
    11.           ];
    12.       }
    13.   }
    14. }
    15. namespace part2;
    16. {
    17.   //演示用完全限定名称访问part1中的类
    18.   $obj = new \part1\lib\cTest();
    19.   $arr = $obj->info();
    20.   echo '<pre>'.print_r($arr,true).'</pre>';
    21.   echo '<hr>';
    22. }

  • 访问函数

    1. namespace part1\common;
    2.   {
    3.       //定义一个函数
    4.       function ftest(){
    5.           return '函数已运行';
    6.       }
    7.   }
    8. namespace part2;
    9. {
    10.   //演示用完全限定名称访问part1中的函数
    11.   $result = call_user_func('\part1\common\ftest');
    12.   echo '用完全限定名称访问函数：'.$result;
    13.   echo '<hr>';
    14. }

  • 访问常量

    1. //注意此处命名空间的写法，这里没有用{}将内容包含住，一旦放入{}中const定义的常量会报错
    2. namespace part1\param;
    3.       //定义一个常量
    4.       define('URL','www.php.cn');
    5.       const SITE_NAME = 'php中文网';
    6. namespace part2;
    7. {
    8. //演示用完全限定名称访问part1中的常量
    9. //因为URL是用define（）定义的，因此不受命名空间影响，应该用全局空间
    10.   $url1 = URL;
    11.   $url2 = \URL;
    12.   $name = \part1\param\SITE_NAME;
    13.   echo '无完全限定名称的前缀\'\\\'访问define()定义的常量URL：'.$url1;
    14.   echo '<hr>';
    15.   echo '只有完全限定名称的前缀\'\\\'访问define()定义的常量URL：'.$url2;
    16.   echo '<hr>';
    17.   echo '需用整个完全限定名称访问const定义的常量URL：'.$name;
    18.   }

2. 实例演示导入四类全局全局成员的方式

  • 导入接口
    1. namespace part1;
    2.   {
    3.       //定义一个接口
    4.       interface iTest{
    5.           public function info();
    6.       }
    7.   }
    8. namespace part2;
    9.   //用use导入part1中定义的接口
    10.   use \part1\iTest;
    11.   class cTest1 implements iTest{
    12.       public function info(){
    13.           return '实现接口的类';
    14.       }
    15.   }
    16.   $obj1 = new cTest1();
    17.   echo $obj1->info();
    18.   echo '<hr>';
  • 导入类
    1. namespace part1\lib;
    2.   {
    3.   //实现接口的类
    4.   class cTest implements \part1\iTest {
    5.       public function info(){
    6.           return [
    7.               'namespace'=>__NAMESPACE__,
    8.               'classname'=>__CLASS__,
    9.               'classname1'=>self ::class,
    10.               'methode'=>__METHOD__,
    11.           ];
    12.       }
    13.   }
    14. }
    15. namespace part2;
    16.   //用use导入part1中的类
    17.   use \part1\lib\cTest;
    18.   $obj = new cTest();
    19.   $arr = $obj->info();
    20.   echo '<pre>'.print_r($arr,true).'</pre>';
    21.   echo '<hr>';
  • 导入函数
    1. namespace part1\common;
    2.   {
    3.       //定义一个函数
    4.       function ftest(){
    5.           return __FUNCTION__;
    6.       }
    7.   }
    8. namespace part2;
    9.   //用use function导入part1中的函数
    10.   use function \part1\common\ftest;
    11.   $result = ftest();
    12.   // echo $n =call_user_func('ftest');
    13.   echo '<hr>';
    14.   echo $m =call_user_func('\part1\common\ftest');
    15.   echo '<hr>';
    16.   echo '通过use function导入，来访问函数：'.$result;
    17.   echo '<hr>';
  • 导入常量
    1. namespace part1\param;
    2.       //定义一个常量
    3.       define('URL','www.php.cn');
    4.       const SITE_NAME = 'php中文网';
    5. namespace part2;
    6. //用use const导入part1中的常量
    7. //因为URL是用define（）定义的，因此不受命名空间影响，应该用全局空间
    8.   use const URL,SITE_NAME;
    9.   $url1 = URL;
    10.   $url2 = \URL;
    11.   $name = \part1\param\SITE_NAME;
    12.   echo '通过use const导入，来访问define()定义的常量URL：'.$url1;
    13.   echo '<hr>';
    14.   echo '通过use const导入，来访问define()定义的常量URL：'.$url2;
    15.   echo '<hr>';
    16.   echo '通过use const导入，来访问const定义的常量URL：'.$name;

    3. 实例演示全局成员中的别名引用方式

  • 接口的别名引用方式
    1. namespace part1;
    2.   {
    3.       //定义一个接口
    4.       interface iTest{
    5.           public function info();
    6.       }
    7.   }
    8. namespace part2;
    9.   //用use导入part1中定义的接口
    10.   use \part1\iTest as iT;
    11.   class cTest1 implements iT{
    12.       public function info(){
    13.           return '实现接口的类';
    14.       }
    15.   }
    16.   $obj1 = new cTest1();
    17.   echo $obj1->info();
    18.   echo '<hr>';
  • 类的别名引用方式
    1. namespace part1\lib;
    2.   {
    3.   //实现接口的类
    4.   class cTest implements \part1\iTest {
    5.       public function info(){
    6.           return [
    7.               'namespace'=>__NAMESPACE__,
    8.               'classname'=>__CLASS__,
    9.               'classname1'=>self ::class,
    10.               'methode'=>__METHOD__,
    11.           ];
    12.       }
    13.   }
    14. }
    15. namespace part2;
    16.   //用use导入part1中的类
    17.   use \part1\lib\cTest as cT;
    18.   $obj = new cT();
    19.   $arr = $obj->info();
    20.   echo '<pre>'.print_r($arr,true).'</pre>';
    21.   echo '<hr>';
  • 函数的别名引用方式
    1. namespace part1\common;
    2.   {
    3.       //定义一个函数
    4.       function ftest(){
    5.           return __FUNCTION__;
    6.       }
    7.   }
    8. namespace part2;
    9.   //用use function导入part1中的函数
    10.   use function \part1\common\ftest as ft;
    11.   $result = ft();
    12.   // echo $n =call_user_func('ftest');
    13.   echo '<hr>';
    14.   echo $m =call_user_func('\part1\common\ftest');
    15.   echo '<hr>';
    16.   echo '通过use function导入，来访问函数：'.$result;
    17.   echo '<hr>';
  • 常量的别名引用方式
    1. //注意此处命名空间的写法，这里没有用{}将内容包含住，一旦放入{}中const定义的常量会报错
    2. namespace part1\param;
    3.       //定义一个常量
    4.       define('URL','www.php.cn');
    5.       const SITE_NAME = 'php中文网';
    6. namespace part2;
    7. //用use const导入part1中的常量
    8. //因为URL是用define（）定义的，因此不受命名空间影响，应该用全局空间
    9.   use const URL as UL;
    10.   // use const SITE_NAME as SN;  //这样导入使用别名不成功
    11.   $url1 = UL;
    12.   // $name = SN;
    13.   echo '通过use const导入，来访问define()定义的常量URL：'.$url1;
    14.   echo '<hr>';

    二. 问答题:

    1. 完全限定名称, 限定名称与非限定名称

  • 我理解的的完全限定名称，限定名称和非限定名称，就类似于windows系统中的文件夹，这样虽然两个文件会同名，但是只要不在一个文件夹中，就没有关系，只是、只是、只是这里是类比，具体的定义命名空间的php文件怎么存放和命名空间中定义的子集是不相关的，那个只涉及到require和include具体文件。
    • 完全限定名称，就像是绝对路径，必须以’\’开头（use导入时是默认的可以省略），其前缀’\’就类似于是电脑系统中的盘符C:或者D:之类的。这个符号的意义在于，电脑解析你的命名空间时，看见了它就不会在前面去添加其他的东西了，也就是告诉电脑这是根目录了。
    • 限定名称，就像是相对路径，其特征是最开始没有前缀’\’，如果你想调用子目录命名空间的全局成员时，可以选择这种方式。其原理就是电脑在解析限定名称时会将当前代码的命名空间加在前面。
      例如：
      1. namespace part1\lib;
      2. {
      3. //实现接口的类
      4. class cTest implements \part1\iTest {
      5.     public function info(){
      6.         return [
      7.             'namespace'=>__NAMESPACE__,
      8.             'classname'=>__CLASS__,
      9.             'classname1'=>self ::class,
      10.             'methode'=>__METHOD__,
      11.         ];
      12.     }
      13. }
      14. }
      15. namespace part1;
      16. $obj5 = new lib\cTest();//这里会被解析成为part1\lib\cTst
      17. $arr = $obj5->info();
      18. print_r($arr);
    • 非限定名称，代表着当前代码的命名空间，只能在自己的命名空间中使用，是不能跨不同的命名空间使用的。

2. 完成限定名称与限定名称, 非限定名称之间的转换方式

  • 我理解的转换，是通过use导入达成的。在use导入时不将命名空间的路径写全，只写了上面几层目录，这样就实现了在代码中用限定名称来使用。如果在use导入时将命名空间的路径写全，那么就实现了非限定名称来使用。

3. use 解决了什么什么?

  • use解决了完全限定名称、限定名称和非限定名称之间的转换，简化了在代码编写中反复写完全限定名称或限定名称的工作。

4. ::class操作符为什么比NAMESPACE好用? 具体应用场景有哪些?

  • ::class操作符代表的是完全限定名称，__NAMESPACE__常量代表的是非限定名称，::class可以在别的命名空间中使用，而__NAMESPACE__不行。
  • 类名::class，这样就可以得到一个带完全限定名称的类名了，然后再怎么用不是很清楚。
批改老师：天蓬老师天蓬老师

批改状态：合格

老师批语：__NAMESPACE__返回的只是普通字符串, ::class返回的可是一个真正的类, 可以直接 new
本博文版权归博主所有，转载请注明地址！如有侵权、违法，请联系admin@php.cn举报处理！
全部评论 文明上网理性发言，请遵守新闻评论服务协议
0条评论
作者最新博文
关于我们 免责申明 意见反馈 讲师合作 广告合作 最新更新
php中文网：公益在线php培训，帮助PHP学习者快速成长！
关注服务号 技术交流群
app下载
PHP中文网订阅号
每天精选资源文章推送
PHP中文网APP
随时随地碎片化学习
PHP中文网抖音号
发现有趣的

Copyright 2014-2024 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号

  • 精品班

  • 技术支持

  • 技术咨询

  • 学习群

  • 会员优惠

  • 返回顶部
    • 登录PHP中文网，和优秀的人一起学习！
    全站2000+教程免费学
    微信扫码登录