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

1. 文件加载

1.1 条件加载(include/include_once)

• 加载文件时, 若文件存在, 则加载该文件的内容; 若文件不存在, 则弹出警告, 但并不会中断程序的执行.
• include()是只要执行一次, 就会加载一次文件, 即相同文件可以多次加载.
• include_once()则对于某个文件, 只加载一次到当前文件中.

<?php
function echobr($param = '')
{
    echo $param . '<br>';
}
function dumpbr($param = '')
{
    var_dump($param);
    echo '<br>';
}
function printfpre($param = '')
{
    printf('<pre>%s</pre>', print_r($param, true));
}

/** file1.php*/
<h2>你好,这里是file1.php</h2>

/** file2.php */
<h2>你好,这里是file2.php</h2>

// test1: 文件加载的路径值支持的类型
/* 1. 字面量 */
include 'file1.php';
/* 2. 变量 */
$path = 'file1.php';
include $path;
/* 3. 带变量的双引号字符串 */
include "{$path}";
/* 4. 表达式 */
$filename = 'file1';
include $filename . '.php';
/* 5. 采用类似调用函数的形式 */
include('file1.php');
// test2: 相同文件只加载一次
/* 加载多次file2.php文件, 实际只第一次成功加载, 后面的都被忽略了 */
include_once 'file2.php';
include_once 'file2.php';
include_once 'file2.php';
// test2: 加载不存在的文件, 并不会中断程序的执行.
include 'file256.php';
echobr('<h2>没有事, 程序照常执行, 要不想显示警告信息, 加上@</h2>');

1.2 强制加载(require/require_once)

• 强制加载功能基本和条件加载一样, 唯一的不同点是, 当加载不存在的文件时, 则输出错误信息, 程序的执行被中断.

// test1:
/* 1. 字面量 */
require 'file1.php';
/* 2. 变量 */
$path = 'file1.php';
require $path;
/* 3. 带变量的双引号字符串 */
require "{$path}";
/* 4. 表达式 */
$filename = 'file1';
require $filename . '.php';
/* 5. 采用类似调用函数的形式 */
require('file1.php');
// test2: 加载相同文件一次
require_once 'file2.php';
require_once 'file2.php';
require_once 'file2.php';
// test3: 加载不存在的文件
require 'file256.php';
/* 
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
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
*/
echobr('<h2>本内容无法打印输出</h2>');

1.3 文件加载的作用域

• 只要在同一个作用域内, 文件外部变量可以在被加载的文件中使用. 即文件加载只在当前作用域有效

/** file3.php */
<?php
$filename = 'file3.php';
function fileName()
{
    return 'function ' . __FUNCTION__ . ' return : file3.php';
}

// 当前是全局作用域
require 'file3.php';
require 'file3.php';
echobr(fileName());
/* 
不能打印fineName()函数的返回值, 因为加载了两次file3.php, 相当于在全局作用域定义了两次fileName()函数.
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
*/

• 相同文件中的多个名称空间, 引入的文件中的函数和变量均可访问

// 名称空间中引入
namespace np1 {
    require '../../out.php';
    require 'file3.php';
    echobr(fileName());
    /* 
        result : function fileName return : file3.php
    */
    echobr($filename ?? 'np1_没有名字');
}
// 全局作用域引入
namespace {
    echobr(fileName());
    /* 
    result : function fileName return : file3.php
    */
    echobr($filename ?? 'global_没有名字');
}
namespace np2 {
    echobr(fileName());
    /* 
    result: function fileName return : file3.php
    */
    echobr($filename ?? 'np2_没有名字');
}

• 在函数域中引入的文件, 其中的变量仅在函数域中可以访问

require '../../out.php';
function func()
{
    require('file3.php');
    // 函数是全局的, 所以都可以访问
    echobr(fileName());
    echobr($filename ?? 'func_没有名字');
}
func();
// 函数是全局的, 所以可以访问
echobr(fileName());
// filename变量是函数域中引入的, 在函数域中才克访问
echobr($filename ?? 'global_没有名字');

2. 类和对象

2.1 类的声明和对象的创建

2.1.1 类的声明

• 使用关键字class来声明类

class Class1 {
    // todo...
}

2.1.2 类的实例化

• 使用关键字new来创建类的实例

$cls1 = new Class1;

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

• 使用instanceof判断对象是否为某个类的实例

$cls1 = new Class1;
echobr('对象$cls1' . (($cls1 instanceof Class1) ? '是' : '不是') . 'Class1类的实例');
/*
result: 对象$cls1是Class1类的实例
*/

• 使用get_class函数获取对象的类名

$cls1 = new Class1;
echobr('对象$cls1是' . get_class($cls1) . '类的实例');
/*
result: 对象$cls1是Class1类的实例
*/

2.1.4 动态类

• 类似动态函数, 也有动态类的概念

$className = 'Class1';
$cls1 = new $className;
dumpbr($cls1);
/*
result: object(Class1)#2 (0) { } 
*/

2.2 类的成员

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

2.2.1 类属性

• 类属性就是类中的变量
• 在类内部, 使用self关键字来代表类本身;用$this变量来代表当前对象.
• 使用瘦箭头->来访问类的常规属性, 访问方式:
  1. 类外部访问: 对象->属性名 仅限public的属性
  2. 类内部访问: $this->属性名 可以访问类中定义的所有属性
• 使用::来访问类的静态属性/常量, 访问方式:
  1. 类外部访问: 类名::静态属性; 类名::常量
  2. 类内部访问: self::静态变量; self::常量

/** 声明类属性、类外部访问类属性demo */
<?php
require('../../out.php');
class Employee
{
    // 1. 常规属性
    /* 字符串 */
    public $name = '张三';
    /* 数字 */
    public $age = 25;
    /* 布尔 */
    public $marriage = false;
    /* 字面量数组 */
    public $like = ['编程', '游泳', '旅游', '日漫'];
    /* 长文本1 */
    public $introduce = <<< EOP
        介绍, 长文本
        介绍, 长文本
        介绍, 长文本
        介绍, 长文本
        ...
    EOP;
    /* 长文本2 */
    public $education = <<< 'EOP'
        教育经历, 长文本
        教育经历, 长文本
        教育经历, 长文本
        教育经历, 长文本
        ...
    EOP;
    /* 2. 常量 */
    const HELLO = 'Hello';
    /* 3. 静态属性 */
    public static $empoyeeTotal = 200;
    /* 4. 抽象属性 */
    public $fireDate;
    /* 不能用[变量/类属性/表达式/函数]作为类属性赋默认值 */
}
// 访问类属性
$emp = new Employee;
// 访问常规属性
echobr("员工姓名: {$emp->name}, 年龄: {$emp->age}岁, 婚否: " . ($emp->marriage ? '已婚' : '未婚') . ", 爱好: " . join('/', $emp->like));
echobr("自我介绍: {$emp->introduce}");
echobr("教育经历: {$emp->education}");
echobr('------');
// 访问常量/静态属性
echobr("打招呼: " . Employee::HELLO);
echobr("员工总数: " . Employee::$empoyeeTotal);
// 抽象属性的默认值是null
dumpbr($emp->fireDate);
/*
result:
员工姓名: 张三, 年龄: 25岁, 婚否: 未婚, 爱好: 编程/游泳/旅游/日漫
自我介绍: 介绍, 长文本 介绍, 长文本 介绍, 长文本 介绍, 长文本 ...
教育经历: 教育经历, 长文本 教育经历, 长文本 教育经历, 长文本 教育经历, 长文本 ...
------
打招呼: Hello
员工总数: 200
NULL
*/

学习心得

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::常量