search

博客列表 >PHP基础-文件加载/类和对象

PHP基础-文件加载/类和对象

岂几岂几
岂几岂几原创
2020年04月30日 10:51:34715浏览

1. 文件加载

1.1 条件加载(include/include_once)

  • 加载文件时, 若文件存在, 则加载该文件的内容; 若文件不存在, 则弹出警告, 但并不会中断程序的执行.
  • include()是只要执行一次, 就会加载一次文件, 即相同文件可以多次加载.
  • include_once()则对于某个文件, 只加载一次到当前文件中.
  1. <?php
  2. function echobr($param = '')
  3. {
  4.     echo $param . '<br>';
  5. }
  7. function dumpbr($param = '')
  8. {
  9.     var_dump($param);
  10.     echo '<br>';
  11. }
  12. function printfpre($param = '')
  13. {
  14.     printf('<pre>%s</pre>', print_r($param, true));
  15. }
  1. /** file1.php*/
  2. <h2>你好,这里是file1.php</h2>
  1. /** file2.php */
  2. <h2>你好,这里是file2.php</h2>
  1. // test1: 文件加载的路径值支持的类型
  2. /* 1. 字面量 */
  3. include 'file1.php';
  4. /* 2. 变量 */
  5. $path = 'file1.php';
  6. include $path;
  7. /* 3. 带变量的双引号字符串 */
  8. include "{$path}";
  9. /* 4. 表达式 */
  10. $filename = 'file1';
  11. include $filename . '.php';
  12. /* 5. 采用类似调用函数的形式 */
  13. include('file1.php');
  15. // test2: 相同文件只加载一次
  16. /* 加载多次file2.php文件, 实际只第一次成功加载, 后面的都被忽略了 */
  17. include_once 'file2.php';
  18. include_once 'file2.php';
  19. include_once 'file2.php';
  21. // test2: 加载不存在的文件, 并不会中断程序的执行.
  22. include 'file256.php';
  23. echobr('<h2>没有事, 程序照常执行, 要不想显示警告信息, 加上@</h2>');

1.2 强制加载(require/require_once)

  • 强制加载功能基本和条件加载一样, 唯一的不同点是, 当加载不存在的文件时, 则输出错误信息, 程序的执行被中断.
  1. // test1:
  2. /* 1. 字面量 */
  3. require 'file1.php';
  4. /* 2. 变量 */
  5. $path = 'file1.php';
  6. require $path;
  7. /* 3. 带变量的双引号字符串 */
  8. require "{$path}";
  9. /* 4. 表达式 */
  10. $filename = 'file1';
  11. require $filename . '.php';
  12. /* 5. 采用类似调用函数的形式 */
  13. require('file1.php');
  15. // test2: 加载相同文件一次
  16. require_once 'file2.php';
  17. require_once 'file2.php';
  18. require_once 'file2.php';
  20. // test3: 加载不存在的文件
  21. require 'file256.php';
  22. /* 
  23. Warning: require(file256.php): failed to open stream: No such file or directory in D:\phpstudy_pro\WWW\php11\PHP\0427\homework\homework.php on line 61
  25. Fatal error: require(): Failed opening required 'file256.php' (include_path='.;C:\php\pear') in D:\phpstudy_pro\WWW\php11\PHP\0427\homework\homework.php on line 61
  26. */
  27. echobr('<h2>本内容无法打印输出</h2>');

1.3 文件加载的作用域

  • 只要在同一个作用域内, 文件外部变量可以在被加载的文件中使用. 即文件加载只在当前作用域有效
  1. /** file3.php */
  2. <?php
  3. $filename = 'file3.php';
  5. function fileName()
  6. {
  7.     return 'function ' . __FUNCTION__ . ' return : file3.php';
  8. }
  1. // 当前是全局作用域
  2. require 'file3.php';
  3. require 'file3.php';
  5. echobr(fileName());
  6. /* 
  7. 不能打印fineName()函数的返回值, 因为加载了两次file3.php, 相当于在全局作用域定义了两次fileName()函数.
  8. result: Fatal error: Cannot redeclare fileName() (previously declared in D:\phpstudy_pro\WWW\php11\PHP\0427\homework\file3.php:6) in D:\phpstudy_pro\WWW\php11\PHP\0427\homework\file3.php on line 7
  9. */
  • 相同文件中的多个名称空间, 引入的文件中的函数和变量均可访问
  1. // 名称空间中引入
  2. namespace np1 {
  3.     require '../../out.php';
  4.     require 'file3.php';
  5.     echobr(fileName());
  6.     /* 
  7.         result : function fileName return : file3.php
  8.     */
  9.     echobr($filename ?? 'np1_没有名字');
  10. }
  11. // 全局作用域引入
  12. namespace {
  13.     echobr(fileName());
  14.     /* 
  15.     result : function fileName return : file3.php
  16.     */
  17.     echobr($filename ?? 'global_没有名字');
  18. }
  20. namespace np2 {
  21.     echobr(fileName());
  22.     /* 
  23.     result: function fileName return : file3.php
  24.     */
  25.     echobr($filename ?? 'np2_没有名字');
  26. }
  • 在函数域中引入的文件, 其中的变量仅在函数域中可以访问
  1. require '../../out.php';
  2. function func()
  3. {
  4.     require('file3.php');
  5.     // 函数是全局的, 所以都可以访问
  6.     echobr(fileName());
  7.     echobr($filename ?? 'func_没有名字');
  8. }
  9. func();
  11. // 函数是全局的, 所以可以访问
  12. echobr(fileName());
  13. // filename变量是函数域中引入的, 在函数域中才克访问
  14. echobr($filename ?? 'global_没有名字');

2. 类和对象

2.1 类的声明和对象的创建

2.1.1 类的声明

  • 使用关键字class来声明类
  1. class Class1 {
  2.     // todo...
  3. }

2.1.2 类的实例化

  • 使用关键字new来创建类的实例
  1. $cls1 = new Class1;

2.1.3 判断对象所属类的两种方法

  • 使用instanceof判断对象是否为某个类的实例
  1. $cls1 = new Class1;
  2. echobr('对象$cls1' . (($cls1 instanceof Class1) ? '是' : '不是') . 'Class1类的实例');
  3. /*
  4. result: 对象$cls1是Class1类的实例
  5. */
  • 使用get_class函数获取对象的类名
  1. $cls1 = new Class1;
  2. echobr('对象$cls1是' . get_class($cls1) . '类的实例');
  3. /*
  4. result: 对象$cls1是Class1类的实例
  5. */

2.1.4 动态类

  • 类似动态函数, 也有动态类的概念
  1. $className = 'Class1';
  2. $cls1 = new $className;
  3. dumpbr($cls1);
  4. /*
  5. result: object(Class1)#2 (0) { } 
  6. */

2.2 类的成员

类的成员包括: 类属性, 类方法, 类常量

2.2.1 类属性

  • 类属性就是类中的变量
  • 在类内部, 使用self关键字来代表类本身;用$this变量来代表当前对象.
  • 使用瘦箭头->来访问类的常规属性, 访问方式:
    1. 类外部访问: 对象->属性名 仅限public的属性
    2. 类内部访问: $this->属性名 可以访问类中定义的所有属性
  • 使用::来访问类的静态属性/常量, 访问方式:
    1. 类外部访问: 类名::静态属性; 类名::常量
    2. 类内部访问: self::静态变量; self::常量
  1. /** 声明类属性、类外部访问类属性demo */
  2. <?php
  3. require('../../out.php');
  4. class Employee
  5. {
  6.     // 1. 常规属性
  7.     /* 字符串 */
  8.     public $name = '张三';
  9.     /* 数字 */
  10.     public $age = 25;
  11.     /* 布尔 */
  12.     public $marriage = false;
  13.     /* 字面量数组 */
  14.     public $like = ['编程', '游泳', '旅游', '日漫'];
  15.     /* 长文本1 */
  16.     public $introduce = <<< EOP
  17.         介绍, 长文本
  18.         介绍, 长文本
  19.         介绍, 长文本
  20.         介绍, 长文本
  21.         ...
  22.     EOP;
  23.     /* 长文本2 */
  24.     public $education = <<< 'EOP'
  25.         教育经历, 长文本
  26.         教育经历, 长文本
  27.         教育经历, 长文本
  28.         教育经历, 长文本
  29.         ...
  30.     EOP;
  32.     /* 2. 常量 */
  33.     const HELLO = 'Hello';
  35.     /* 3. 静态属性 */
  36.     public static $empoyeeTotal = 200;
  38.     /* 4. 抽象属性 */
  39.     public $fireDate;
  41.     /* 不能用[变量/类属性/表达式/函数]作为类属性赋默认值 */
  42. }
  44. // 访问类属性
  45. $emp = new Employee;
  46. // 访问常规属性
  47. echobr("员工姓名: {$emp->name}, 年龄: {$emp->age}岁, 婚否: " . ($emp->marriage ? '已婚' : '未婚') . ", 爱好: " . join('/', $emp->like));
  48. echobr("自我介绍: {$emp->introduce}");
  49. echobr("教育经历: {$emp->education}");
  50. echobr('------');
  51. // 访问常量/静态属性
  52. echobr("打招呼: " . Employee::HELLO);
  53. echobr("员工总数: " . Employee::$empoyeeTotal);
  54. // 抽象属性的默认值是null
  55. dumpbr($emp->fireDate);
  57. /*
  58. result:
  59. 员工姓名: 张三, 年龄: 25岁, 婚否: 未婚, 爱好: 编程/游泳/旅游/日漫
  60. 自我介绍: 介绍, 长文本 介绍, 长文本 介绍, 长文本 介绍, 长文本 ...
  61. 教育经历: 教育经历, 长文本 教育经历, 长文本 教育经历, 长文本 教育经历, 长文本 ...
  62. ------
  63. 打招呼: Hello
  64. 员工总数: 200
  65. NULL
  66. */

学习心得

1. 文件加载

  • 文件加载，可以实现代码的复用。
  • 从实现加载文件的角度来说，include/require和 include_once/require_once完成的功能基本一样。前一组可以多次加载同一个文件，适合加载在相同页面多次用到代码文件，如HTML组件等。后一组同一个文件只加载一次，适合加载各种脚本文件，如js脚本文件，PHP脚本文件等。
  • 从对加载的目标文件的重要性来说，include/include_once和require/require_once是有区别的。前一组加载不到目标文件时，并不会导致致命错误，不影响程序的正常执行。使用@可忽略其输出的警告。适合用来加载非不可或缺的文件。后一组加载不到目标文件时，会导致知名错误，程序会停止往下执行。适合用来加载不可或缺的文件。
  • 如果在同一个文件中存在多个名称空间，那么是否需要在每个名称空间都加载文件？我的测试结果是只在其中一个名称空间中加载一次，所有名称空间都可以使用这个文件中的变量和表达式。是否如此，希望老师能帮忙解惑。

    2. 类和对象

    2.1 类和对象，类属性的理解

    • 很多书籍都把类定义为现实中某一类具体事物的抽象。个人理解，类是规定了一类事物的组成部分的文件，而对象是按照文件规定生成的实际案例。如，高考结果规定了要有语文成绩，数学成绩，外语成绩，理综成绩，文综成绩。这段描述就是一个“类”；张三的高考成绩单就是高考成绩这个“类”的一个“对象”；李四的高考成绩单就是高考成绩的另一个“对象”……
    • 类中的属性，就是类中规定的各个“组成部分”，如上面例子中的“语文成绩”，“数学成绩”等。这部分属性，不同的对象会有不同的值，如张三的语文成绩就跟李四的不同的，就是常规属性。而有部分属性，不属于某个具体的对象，而是描述类级别信息的，就是静态属性，如：高考成绩的“份数”。某些属性，其值是固定不可更改的，这些属性就是常量属性，如：高考成绩中的“卷面总分”就是固定的值。
    • 在充分理解类和对象的关系后，可以不必纠结他们之间的区别，可以在一定使用场景上把类认为就是对象，把对象认为是类。

      2.2 类属性的调用

    • 使用瘦箭头->来访问类的常规属性, 访问方式:
      1. 类外部访问: 对象->属性名 仅限public的属性
      2. 类内部访问: $this->属性名 可以访问类中定义的所有属性
    • 使用::来访问类的静态属性/常量, 访问方式:
      1. 类外部访问: 类名::静态属性; 类名::常量
      2. 类内部访问: self::静态变量; self::常量
上一条：php文件加载方式、类与对象基础下一条：继承、抽象类和接口
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多