PHP-从入门到精通(下)

在PHP中系统提供多种定义数组的方式:
1. 使用array关键字:最常用的
$变量= (array元素1,元素2,元素3..);
2. 可以使用中括号来包裹数据:
$变量 = [元素1,元素2...];
3. 隐形定义数组:给变量增加一个中括号,系统自动变成数组
$变量[]=值1; //如果不提供下标也可以,系统自动生成(数字:从0开始)
$变量[下标]=值; //中括号里面的内容称之为下标key,该下标可以是字母(单词)或者数字,与变量命名的规则相似

<?php
    // 数值数组
    $array_num=array("php","java","python");
    $array_num1=array();
    $array_num1[0]="php";
    $array_num1[1]="java";
    $array_num1[2]="python";
    var_dump($array_num);
    echo "</br>";
    var_dump($array_num1);
    echo "</br>";
    // 关联数组
    $array_key=array("姓名"=>"张三","成绩"=>100,"班级"=>"2班");
    $array_key1=array();
    $array_key1["姓名"]="张三";
    $array_num1["成绩"]=100;
    $array_num1["班级"]="2班";
    var_dump($array_key);
    echo "</br>";
    var_dump($array_key1);

<?php
	// 多维数组
    $user = array
    (
        array("php",30,"男"),
        array("Bob",15,"女"),
        array("Tony",5,"男"),
        array("Wink",17,"女")
    );
    /*
     * 现在这个两维数组包含了四个数组,并且它有两个索引(下标):行和列.
     * 如需访问 $user 数组中的元素,我们必须使用两个索引(行和列):
    */
    echo $user[0][0].":年龄 :".$user[0][1].", 性别:".$user[0][2].".<br>";
    echo $user[1][0].":年龄 :".$user[1][1].", 性别:".$user[1][2].".<br>";
    echo $user[2][0].":年龄 :".$user[2][1].", 性别:".$user[2][2].".<br>";
    echo $user[3][0].":年龄 :".$user[3][1].", 性别:".$user[3][2].".<br>";

<?php
    $fruits = array('apple', 'banana', 'orange');
    // 添加新元素到数组开头
    array_unshift($fruits,"tomato");
    print_r($fruits);
    echo "</br>";
    // 添加新元素到数组末尾
    $fruits[]="peach";
    print_r($fruits);
    echo "</br>";
    // 合并两个数组
    $fruits2 = array('blueberry', 'grape');
    print_r(array_merge($fruits,$fruits2));
    echo "</br>";
    // 反转数组
    print_r(array_reverse($fruits));
    echo "</br>";
    // 获取数组中的所有键名或所有值
    print_r(array_keys($fruits));
    echo "</br>";
    print_r(array_values($fruits));
    echo "</br>";
    // 检查一个值是否在数组中,并返回对应的键名
    echo "根据值搜索键名:".array_search("grape",$fruits2);
    echo "</br>";
    // 修改数组元素值
    $fruits2[1]="apricot";
    print_r("修改数组元素值:".$fruits2);
    echo "</br>";
    // 检查数组中是否存在某个元素
    var_dump("检查数组中是否存在某个元素:".in_array("apple",$fruits));
    echo "</br>";
    // 获取数组的长度(元素个数)
    echo "数组长度:".count($fruits);
    echo "</br>";
    // 检查数组是否为空
    var_dump(empty($fruits));

<?php
    $arr1[false]=false;
    $arr1[true]=true;
    $arr1[null]=null;
    var_dump($arr1);

foreach($arr, as $k => $v){
    //循环体
}
# 1.foreach会重置指针:让指针指向第一个元素;
# 2.进入foreach循环:通过指针取得当前第一个元素,然后将下标取出放到对应的下标变量$k中(如果存在),将值取出来放到对应的值变量$v中;(指针下移)
# 3.进入到循环内部(循环体),开始执行;
# 4.重复2和3,直到在2的时候遇到指针取不到内容(指针指向数组最后)

<?php
/*
基本语法:
foreach(数组变量 as [$下标=>] $值){
}
通常:如果是关联数组(字母下标),就需要下标,如果是数字下标就直接访问值

在进行数据存储定义的时候,通常二维数组不会两个维度的key下标都为数字,一般是一维为数字(无意义),二维为字符串(数据库表字段),所以在进行遍历的时候,通常是只需要针对一维进行遍历,取得二维数组元素,然后二维数组元素通过下标去访问.
*/
$arr = ['a' => 'aaa', 'b' => 'bbb', 'c' => 'ccc'];
// 使用 foreach 遍历数组,并将键名赋值给 $key,键值赋值给 $value
foreach ($arr as $key => $value) {
    echo $key . '<br/>'; // 输出当前的键名
}
echo "--------";
echo "</br>";
// 使用 foreach 遍历数组,只获取键值部分,赋值给 $val
foreach ($arr as $val) {
    echo $val . '<br/>'; // 输出当前的键值
}

$arr = array(1, 2, 3, 4, 5, 6, 7, 10);
// 获取数组的长度(元素个数)
$len = count($arr);
// 使用 for 循环从数组的第一个元素开始遍历到最后一个元素
for ($i = 0; $i < $len; $i++) {
    // 输出当前的键(下标) $i,以及对应的值 $arr[$i]
    echo 'key is :', $i, ' and value is :', $arr[$i], '</br>';
}

1. 排序函数:对数组元素进行排序,都是安装ASCII码进行比较,可以进行英文比较
sort():顺序排序(下标重排)
asort():升序排序(对键排序)
rsort():逆序排序
asor():顺序排序(下标保留)
arsort():逆序排序
ksort():顺序排序:按照键名(下标)
krsort():逆序排序
shuffle():随机打乱数组元素,数组下标会重排
2. 指针函数
reset():重置指针,将数组指针回到首位
end():重置指针,将数组指针指到最后一个元素
next():指针下移,取得下一个元素的值
prev():指针上移,取得上一个元素的值
current():获取当前指针对应的元素值
key():获取当前指针对应的下标值
注意事项:next和prev会移动指针,有可能导致指针移到最前或者最后(离开数组),导致数组不能使用,不能通过next和prev不能回到正确的位置.只能通过end或者reset进行指针重置
3. 其他函数
count():统计数组中元素的数量
array_push():往数组中加入一个元素(数组后面)
array_pop():从数组中取出一个元素(数组后面)
array_shift():从数组中取出一个元素(数组前面)
array_unshift():从数组中加入一个元素(数组前面)
PHP模拟数据结构:
栈:压栈,先进去后出来(FILO)

//数据结构:栈和队列
$arr = array();
//栈:先压栈后出栈:都是从一端出来
//前面:array_shift/array_unshift
//后面:array_push/array_pop
//压栈
array_push($arr,3);
array_push($arr,2);
array_push($arr,1);
print_r($arr);
//出栈
echo array_pop($arr),array_pop($arr),array_pop($arr);
结果:
Array
(
    [0] => 3
    [1] => 2
    [2] => 1
)
123

队列:排队,先进去的先出去(FIFO)
//队列:先排队,先出来,一端进,另外一端出
//后进前出:array_push/array_shift
//前进后出:array_unshift/array_pop
$arr = array();
//入队
array_unshift($arr,3);
array_unshift($arr,2);
array_unshift($arr,1);
print_r($arr);
//出队
echo array_pop($arr),array_pop($arr),array_pop($arr);

arcray_reverse():数组元素反过来
in_array():判断一个元素在数组中是否存在
array_keys():获取一个数组的所有下标,返回一个索引数组
array_values():获取一个数组的所有值,返回一个索引数组

<?php
    $i = 1; // 初始化变量$i为1
    while ($i <= 5) { // 当$i小于等于5时执行循环
        echo "num is " . $i . "<br>"; // 输出当前的$i值
        $i++; // 增加$i的值,以便进行下一次循环
    }

<?php
    $i=1;
    do{
        $i++;
        echo "num " . $i . "<br>";
    }while ($i<=5);

<?php
    for ($i=1; $i<=5; $i++)
    {
        echo "num is " . $i . "<br>";
    }

<?php
    // continue用于跳过当前循环中剩余的代码,并继续下一次循环的执行.
	// continue的使用场景通常是在循环结构内部,用于满足某些条件时跳过当前迭代并进入下一次迭代.当程序执行到continue语句时,它会立即跳过当前循环体内后续的代码,然后返回至循环结构的开始处,检查循环条件并决定是否进入下一次循环.
    $i = 1;	// 初始化变量$i为1
    while ($i <= 100) {
        // 在 $i 小于等于 100 的条件下循环执行以下代码块
        // 判断: 是否是 5 的倍数
        if ($i % 5 != 0) {
            // 若 $i 不是 5 的倍数
            $i++; // 增加 $i 的值,继续下一次循环
            // 重新循环
            continue; // 系统重新跳到循环开始处
        }
        // 输出数值
        echo $i++, '<br/> '; // 输出当前 $i 的值,并增加 $i 的值,显示换行标签 <br/>
}

    

<?php
    // break用于中断循环结构的执行,并跳出当前循环
    // break的使用场景通常是在循环结构内部,当满足某些条件时提前结束整个循环.当程序执行到break语句时,它会立即退出当前的循环体,并继续执行循环后面的代码.
    // 需要注意的是,break语句只能中断离它最近的循环结构.也就是说,break语句只会中断包含它的最内层循环,不会影响外层的循环.
  $i = 1;
    while ($i <= 100) {
        // 判断: 是否是5的倍数
        if ($i % 5 != 0) {
            // 说明当前$i不是5的倍数
            $i++; // 输出当前的$i值,并且将$i自增1
            // 终止循环
            break;
        }
    }
    echo $i; // 为什么结果是2呢?
    /*
    Continue 2;//当前自己循环后面内部不再执行,同时外部循环如果还有循环体也不再执行,重新来过;
    Break 2;//当前自己循环结束,同时外部也结束(如果还有外部(第三层)不受影响,继续执行)
    */

<table border=1>
    <?php for($i = 1;$i < 10;$i++){?>
        <tr>
            <?php for($j = 1;$j < $i;$j++){?>
                <td>
                <?php echo $j .'*' .$i . '= ' .$i*$j;?>
                </td>
            <?php }?>
        </tr>
    <?php } ?>
</table>
// 在PHP书写到HTML中的这些大括号}非常不美观,所以PHP提供了一种替代机制,让其可以不用书写大括号:
for(;;){ => for(;;):
} =>endfor;
如下:
<table border=1>
    <?php for($i = 1;$i < 10;$i++):?>
        <tr>
            <?php for($j = 1;$j < $i;$j++):?>
                <td>
                <?php echo $j .'*' .$i . '= ' .$i*$j;?>
                </td>
            <?php endfor;?>
        </tr>
        <?php endfor; ?>
</table>

<?php
	// function  定义函数的关键字
    function functionName([参数]){  //[参数]可有可无
        //函数体
        //返回值: return结果;
    }

<?php
	function echo_test()
    {
        echo "PHP study hard !! ";
    }
    echo_test();

<?php
	function name($names)
    {
        echo $names . "<br>";
    }

    echo "My name is ".name("php");
    echo "My sister's name is ".name("Bob");
    echo "My brother's name is ".name("Tony");
    echo "-------------------</br>";
    // 指定类型的参数
    function type_name(string $type_names){
        var_dump($type_names);
        echo "</br>";
        echo $type_names. "</br>";
    }
    echo "My name is ".type_name("php");
    echo "My sister's name is ".type_name(100); // 函数会自动强制帮我们转换成string类型
    echo "My brother's name is ".type_name("Tony");

<?php
	// 参数默认值
    /*
     * PHP 中的函数参数默认值允许你在函数定义中为参数指定一个默认的数值或者字符串.
     * 这意味着如果函数在调用时没有为该参数提供值,那么将会使用默认值作为参数的值.
     * 参数默认值的设置使得函数更加灵活,因为你不需要每次都为每个参数提供值.
     * 使用参数默认值非常简单,只需要在函数定义中为参数赋予默认值即可
     * */

    /*
     * 如果你为函数的参数设置默认值,则所有没有默认值的参数必须位于有默认值的参数之前.
     * 这是由 PHP 语法规则所决定的.
     * 这个限制存在的原因是为了确保代码的可读性和可预测性.
     * 当函数的参数有默认值时,调用函数时可以省略这些参数.
     * 如果允许将拥有默认值的参数放在第一个位置,那么在省略其他参数时,很难确定哪些参数被省略了
     * 从而导致代码不易阅读和理解.
     * */
    function greet($name,$age=100) {
        echo "Hello, " . $name.",年龄:".$age;
    }

    greet("Guest"); // 输出: Hello, Guest,年龄:100
    greet("John",10); // 输出: Hello, John,年龄:10

<?php
    // 返回值只有1个

    // 定义一个名为 calculateSum 的函数,接受两个参数 $num1 和 $num2
    function calculateSum($num1, $num2) {
        return $num1 + $num2; // 返回两个参数的和
    }
    // 调用 calculateSum 函数,传入参数 5 和 3,并将结果赋值给 $result 变量
    $result = calculateSum(5, 3);
    // 输出结果: 8,并在输出后添加 HTML 换行标签
    echo $result."</br>";

    // 返回值有多个 可以将这些值封装到数组或对象中,然后将该数组或对象作为函数的返回值.
    // 定义一个名为 getPersonInfo 的函数,返回一个包含个人信息的数组
    function getPersonInfo(): array {
        $name = "John"; // 声明并赋值变量 $name,存储名字 "John"
        $age = 25; // 声明并赋值变量 $age,存储年龄 25
        $occupation = "Developer"; // 声明并赋值变量 $occupation,存储职业 "Developer"
        return array($name, $age, $occupation); // 返回一个包含个人信息的数组
    }

    $info = getPersonInfo(); // 调用 getPersonInfo 函数,并将返回的数组赋值给变量 $info

    echo $info[0]."</br>"; // 输出数组 $info 的第一个元素,即名字 "John"
    echo $info[1]."</br>"; // 输出数组 $info 的第二个元素,即年龄 25
    echo $info[2]."</br>"; // 输出数组 $info 的第三个元素,即职业 "Developer"

<?php
    /**
     * 函数 process() 接受两个参数:$data 和 $callback.
     * 它执行一些处理操作后,调用传递的回调函数 $callback 并将 $data 作为参数传递给回调函数.
     * 最后,函数 process() 返回回调函数的结果.
     */

    function process($data, $callback)
    {
        // 执行某些处理操作
        // 调用回调函数
        $result = $callback($data);
        // 继续处理其他操作
        return $result;
    }

    /**
     * 回调函数 myCallback() 接收一个参数,并将该参数乘以2后返回.
     */
    function myCallback($value)
    {
        return $value * 2;
    }

    $data = 10;
    // 调用函数 process() 并传递回调函数 myCallback()
    $result = process($data, 'myCallback');

    echo $result; // 输出:20

<?php
    /*
     * $变量='display';
     * function display(){
     * }
     * //可变函数
     * $变量()
     *  */

    // 定义一个名为 display 的函数,用于输出函数名
    function display(){
        echo __FUNCTION__."</br>"; // 输出函数的名称,并添加 HTML 换行标签
    }
    $func = "display"; // 将字符串 "display" 赋值给变量 $func
    display(); // 调用 display 函数,输出函数的名称
    $func(); // 使用变量 $func 来调用函数,输出函数的名称

<?php
    // 代码示例:
    // 将一个用户定义的函数传入给另外一个函数(函数名)去使用的过程,称之为回调过程,而被传入的函数称之为回调函数
    //定义系统函数(假设)
    function sys_function($arg1,$arg2){
        //给指定的函数(第一个参数),求对应的第二个参数值的4次方
        //对实际用户输入的数值进行处理
        $age2 = $age2 + 10;
        return $arg1($arg2);  //相当于user_function(20)
    }
    //定义一个用户函数:求一个数的四次方
    function user_function($num){
        return $num * $num * $num * $num;
    }

    //求10的4次方
    sys_function('user_function',10);

<?php
    /*
     * 匿名函数可以像普通函数一样被调用.
     * 如果要执行匿名函数,可以像调用普通函数一样使用变量名加括号的方式.
     */
    $sum = function($a, $b) {
        return $a + $b;
    };
    echo $sum(2, 3); // 调用匿名函数并传递参数

	/*
     * 匿名函数还可以作为回调函数传递给其他函数
     * 例如array_map()和usort()等PHP函数.
     * */
    $numbers = [1, 2, 3, 4, 5]; // 定义了一个数字数组 $numbers,包含了数字 1 到 5.

    // 使用匿名函数作为回调函数,对数组中的每个元素进行平方操作
    /*
     * array_map() 是一个PHP内置函数,用于将回调函数应用到给定数组中的每个元素,
     * 并返回一个新的数组,其中包含了应用回调函数后的结果.
     * 语法:
     * array_map(callback $callback, array $array1, array ...$arrays): array
     * callback:回调函数,可以是普通函数、类方法或匿名函数.
     * $array1, $arrays:要操作的数组,可以是一个或多个数组.
     * */
    /*
     *
     * 使用 array_map() 函数对数组 $numbers 中的每个元素应用回调函数来进行平方操作.
     * 匿名函数被传递给 array_map() 函数作为回调函数,它采用一个参数 $number,表示数组中的当前元素,然后返回该元素的平方值.所以,匿名函数内部使用 $number * $number 来计算平方.
     * array_map() 函数返回一个新的数组,其中包含了对原始数组 $numbers 中的每个元素进行平方操作后的结果.
     * */
    $squared = array_map(function($number) {
        return $number * $number;
    }, $numbers);

    print_r($squared); // 输出:Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 [4] => 25 )

<?php
    $sum = function($a, $b) {
        return $a + $b;
    };
    echo $sum(2, 3); // 调用匿名函数并传递参数
    echo "</br>";
    var_dump($sum); // object(Closure)#1 (1) { ["parameter"]=> array(2) { ["$a"]=> string(10) "" ["$b"]=> string(10) "" } }

$closure = function ($arg1, $arg2, ...) {
    // 函数体
};

<?php
	$result = $closure($value1, $value2);

<?php
    $message = "Hello";
    $closure = function ($name) use ($message) {
        echo $message . ", " . $name;
    };
    $closure("John"); // 输出:Hello, John

<?php
    // 闭包与普通匿名函数的区别在于,闭包可以在定义时捕获其周围作用域中的变量,并且可以在后续的调用中访问和修改这些变量的值.这使得闭包在某些情况下更为灵活和强大.
	// 示例
    function createMultiplier($factor) {
        return function ($number) use ($factor) {
            return $number * $factor;
        };
    }

    $double = createMultiplier(2);
    $result = $double(10);
    echo $result; // 输出:20
    // 我们使用闭包创建了一个乘法器函数 createMultiplier(),它接受一个因子参数并返回一个闭包.这个闭包将捕获 createMultiplier() 函数的 $factor 参数,并返回给定数值和因子的乘积.

<?php
    // 以下代码用于解释定义闭包时,外部变量的值已经发生了改变,闭包仍然可以访问到最初捕获的变量值
    $factor = 2;
    $factor2 = 10;
    $greeting = function ($number,$factor) {
        return $number * $factor;
    };

    echo $greeting($factor2,$factor); // 输出:Hello, John
    echo "</br>";
    $factor = 10;
    echo "读的是新的值:".$greeting($factor2,$factor); // 输出:Hello, John
    echo "</br>";


    $factor = 2;

    $multiplier = function ($number) use ($factor) {
        return $number * $factor;
    };

    $result = $multiplier(10);
    echo $result; // 输出:20
    echo "</br>";
    $factor = 10; // 使变量产生新的值
    $result = $multiplier(10);
    echo '读的是最初的$factor值:'.$result; // 输出:20

字符串相关函数
1. 转换函数:       implode(),explode(),st_split()
    lmplode(连接方式,数组):将数组中的元素按照某个规则连接成一个字符串,
    explode(分割字符,目标字符串):将字符串按照某个格式进行分割,变成数组
    str_split(字符串,字符长度):按照指定长度拆分字符串得到数组
2. 截取函数:       trim(),ltrim(), rtrim()
    trim(字符串,[指定字符]):本身默认是用来去除两边的空格(中间不行),但是也可以指定要去除的内容,是按照指定的内容循环去除两边有的内容:直到碰到一个不是目标字符为止.
    ltrim():去除左边的空格
    rtrim():去除右边的空格
3. 截取函数:       substr(),strstr()
    substr(字符串,起始位置从0开始[长度]):指定位置开始截取字符串,可以截取指定长度(不指定到最后)
    strstr(字符串,匹配字符):从指定位置开始,截取到最后(可以用来取文件后缀名)
4. 大小转换函数:   strtolower(),strtoupper(),ucfirst()
    strtolower:  全部小写
    strtoupper:  全部大写
    ucfirst:     首字母大写
5. 查找函数:       strpos(),strrpos()
    strpos():判断字符在目标字符串中出现的位置(首次)
    strrpos():判断字符在目标字符串中最后出现的位置
6. 替换函数:       str_replace()
    str_replace(匹配目标,替换的内容,字符串本身):将目标字符串中部分字符串进行替换,
    $str = '123a234a3b2a';
    str_replace('a','b',$str);
7. 格式化函数:     printf(),sprintf()
printf/sprintf(输出字符串有占位符,顺序占位内容):格式化输出数据
    $age = 50;
    $name = 'TOM';
    //格式化输出
    echo sprintf("你好,今年我%d岁,我叫%s",$age,$name);
8. 其他:           str_repeat(),str_shuffle()
    str_repeat():重复某个字符串N次
    str_shuffle():随机打乱字符串

<?php
    /*
     * date(format, timestamp)
     * - 返回指定格式的日期字符串.
     * - 可通过第二个参数指定时间戳.
     * */
    echo date('Y-m-d H:i:s'); // 2023-08-03 09:00:56

    /*
     * time()
     * - 返回当前的Unix时间戳
     * */
    echo "</br>";
    echo time(); // 1691024456

    /*
     * strtotime(timeString)
     * - 将人类可读的时间字符串转换为 Unix 时间戳.
     * */
    echo "</br>";
    echo strtotime('2023-08-03 09:00:56'); // 1691024456

/*
 * date_format(dateTime, format)
 * - 格式化日期和时间对象.
 * - 适用于 DateTime 对象.
 * */
echo "</br>";
// new DateTime('2023-08-03 09:00:56')表示创建了一个 DateTime 对象,表示日期和时间为 2023 年 8 月 3 日 09:00:56.
echo date_format(new DateTime('2023-08-03 09:00:56'), 'Y-m-d H:i:s'); // 输出 2023-08-03 09:00:56


/*
 * date_default_timezone_set(timezone)
 * - 设置默认时区
 * - 时区列表:https://www.php.net/manual/en/timezones.php
 * */
echo "设置默认时区:";
date_default_timezone_set('Africa/Abidjan');
echo date('Y-m-d H:i:s'); // 2023-08-03 01:09:47

<?PHP
    /*
     * strtotime(timeString, now)
     * - 将相对的或绝对的时间字符串转换为 Unix 时间戳.
     * - 可选的第二个参数指定基准时间.
     * */
    echo "</br>";
    date_default_timezone_set('Asia/Shanghai');
    echo date('Y-m-d H:i:s',strtotime('+1 day')); // 2023-08-04 09:12:41

    /*
     * date_add(dateTime, interval)
     * - 在给定的日期上添加时间间隔.
     * - 适用于 DateTime 对象.
     * */
    echo "</br>";
    // 创建一个 DateTime 对象,表示日期和时间为 2023 年 8 月 2 日 17:30:00
    $dateTime = new DateTime('2023-08-02 17:30:00');
    // 创建一个 DateInterval 对象,表示时间间隔为 1 天
    $interval = new DateInterval('P1D');
    // 在 DateTime 对象上添加时间间隔,这里是添加了 1 天
    $dateTime->add($interval);
    // 格式化 DateTime 对象并将其以指定格式输出
    echo $dateTime->format('Y-m-d H:i:s');

    /*
     *  date_diff(dateTime1, dateTime2)
     * - 计算两个日期之间的差异.
     * - 适用于 DateTime 对象.
     * */
    echo "</br>";
    // 创建一个 DateTime 对象,表示日期为 2023 年 8 月 2 日(时间默认为 00:00:00)
    $dateTime1 = new DateTime('2023-08-02');
    // 创建一个 DateTime 对象,表示日期为 2023 年 8 月 5 日(时间默认为 00:00:00)
    $dateTime2 = new DateTime('2023-08-05');
    // 计算两个日期对象之间的差异
    $interval = date_diff($dateTime1, $dateTime2);
    // 格式化并输出两个日期之间的天数差异,使用 %R 表示正负号,%a 表示天数
    echo $interval->format('%R%a days');

<?php
    echo "</br>--------解析和输出日期字符串--------</br>";
    /*
     * date_parse(dateString)
     * - 解析日期字符串并返回关联数组
     * */
    print_r(date_parse('2023-08-03 09:20:41')); // Array ( [year] => 2023 [month] => 8 [day] => 3 [hour] => 9 [minute] => 20 [second] => 41 [fraction] => 0 [warning_count] => 0 [warnings] => Array ( ) [error_count] => 0 [errors] => Array ( ) [is_localtime] => )

    /*
     * strftime(format, timestamp)
     * - 格式化日期和时间,支持本地化字符串的替换.
     * */
    echo "</br>";
    // 设置本地化的时区为中文(简体)并使用 UTF-8 编码
    setlocale(LC_TIME, 'zh_CN.utf8');
    // 使用 strftime 函数将当前时间格式化为指定的字符串格式,%Y 表示年份(四位数),%m 表示月份(两位数),%d 表示日期(两位数),%H 表示小时(24小时制),%M 表示分钟,%S 表示秒数
    echo strftime('%Y年%m月%d日 %H:%M:%S', time()); // 2023年08月03日 09:22:10

<?php
    // 15.5 实际应用示例
    echo "</br>实际应用示例</br>";
    // 生成特定格式的日期字符串
    echo $date = date('Y-m-d');

    // 计算两个日期之间的天数差异
    echo "</br>";
    // 创建一个 DateTime 对象,表示开始日期为 2023 年 7 月 1 日(时间默认为 00:00:00)
    $startDate = new DateTime('2023-07-01');
    // 创建一个 DateTime 对象,表示结束日期为 2023 年 7 月 10 日(时间默认为 00:00:00)
    $endDate = new DateTime('2023-07-10');
    // 计算两个日期对象之间的差异
    $interval = date_diff($startDate, $endDate);
    // 格式化并输出两个日期之间的天数差异,使用 %R 表示正负号,%a 表示天数
    echo $interval->format('%R%a days');

    // 解析复杂的日期字符串
    echo "</br>";
    // 定义日期字符串
    $dateString = '2023-08-02 17:30:00';
    // 使用 date_parse 函数解析日期字符串并返回日期信息数组
    $dateInfo = date_parse($dateString);
    // 输出解析后的日期信息
    echo "年份:" . $dateInfo['year'] . "<br>";
    echo "月份:" . $dateInfo['month'] . "<br>";
    echo "日期:" . $dateInfo['day'] . "<br>";
    echo "小时:" . $dateInfo['hour'] . "<br>";
    echo "分钟:" . $dateInfo['minute'] . "<br>";
    echo "秒钟:" . $dateInfo['second'] . "<br>";
    /*
     * result:
     * 年份:2023
     * 月份:8
     * 日期:2
     * 小时:17
     * 分钟:30
     * 秒钟:0
     * 

<?php
    // 包含基本语法
    include '文件名字';
    include('文件名字');   //文件名字,注意路径
	// 向上包含:先包含文件,后使用文件的内容
    include 'include1.php';
    echo $a;
    echo $b;
	// 向下包含:包含文件为了显示以上数据
    $a = 10;
    const PI = 3.14;
    include_once 'include4.php'

<?php 
$message = "php study hard!!!";

<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>SecHub</title>
</head>
<body>

<p>努力学习</p>
<?php include 'message.php';
echo $message;
?>

</body>
</html>

<?php
	include('login.php')
	echo 'include test final!';//include报错,但是会继续执行,显示:include test final!
	require('login1.php')
	echo 'require test final!';//require报错,停止代码的执行
?>

<?php
// 定义要读取和写入的文件路径
$filePath = 'D:\\Software\\phpstudy_pro\\WWW\\localhost\\example.txt';

// 打开文件进行写入
$file = fopen($filePath, 'w');

// 检查文件是否成功打开
if ($file) {
    // 要写入的内容
    $newContent = "这是新的文件内容";

    // 写入文件
    fwrite($file, $newContent);

    // 关闭文件
    fclose($file);

    echo "文件写入成功!";
} else {
    // 文件打开失败
    echo "文件打开失败!";
}

// 打开文件进行读取
$file = fopen($filePath, 'r');

// 检查文件是否成功打开
if ($file) {
    // 读取文件内容
    $content = fread($file, filesize($filePath));

    // 关闭文件
    fclose($file);

    // 输出文件内容
    echo "文件内容:";
    echo nl2br($content); // 加上 nl2br 函数将换行符转换为 <br> 标签
} else {
    // 文件打开失败
    echo "文件打开失败!";
}

<?php
// 定义要操作的目录路径
$directoryPath = 'D:\\Software\\phpstudy_pro\\WWW\\localhost\\test';

// 创建目录
if (!is_dir($directoryPath)) { // 如果指定路径不是一个目录
    mkdir($directoryPath); // 创建目录
    echo "目录创建成功!";
} else {
    echo "目录已存在!";
}

// 遍历目录并输出文件名
$dir = opendir($directoryPath); // 打开目录句柄
echo "目录中的文件列表:";
while (($file = readdir($dir)) !== false) { // 读取目录中的文件
    if ($file != "." && $file != "..") { // 排除当前目录和上级目录
        echo $file . "<br>"; // 输出文件名
    }
}
closedir($dir); // 关闭目录句柄

// 复制目录及其内容到新目录
$newDirectoryPath = 'D:\\Software\\phpstudy_pro\\WWW\\localhost\\test_copy';
if (is_dir($directoryPath) && !is_dir($newDirectoryPath)) { // 如果原目录存在且目标目录不存在
    mkdir($newDirectoryPath); // 创建目标目录
    recurse_copy($directoryPath, $newDirectoryPath); // 调用递归复制函数
    echo "目录复制成功!";
} else {
    echo "目录复制失败!";
}

// 删除目录及其内容
if (is_dir($directoryPath)) { // 如果目录存在
    delete_directory($directoryPath); // 调用递归删除函数
    echo "目录删除成功!";
} else {
    echo "目录不存在!";
}

// 递归复制目录及其内容
function recurse_copy($src, $dst) {
    $dir = opendir($src); // 打开源目录句柄
    @mkdir($dst); // 创建目标目录(@符号用于忽略警告)
    while (($file = readdir($dir)) !== false) { // 读取源目录中的文件
        if ($file != "." && $file != "..") { // 排除当前目录和上级目录
            if (is_dir($src . '/' . $file)) { // 如果是子目录
                recurse_copy($src . '/' . $file, $dst . '/' . $file); // 递归调用函数复制子目录及其内容
            } else {
                copy($src . '/' . $file, $dst . '/' . $file); // 复制文件
            }
        }
    }
    closedir($dir); // 关闭源目录句柄
}

// 递归删除目录及其内容
function delete_directory($dir) {
    if (is_dir($dir)) { // 如果目录存在
        $objects = scandir($dir); // 扫描目录,获取文件和子目录列表
        foreach ($objects as $object) {
            if ($object != "." && $object != "..") { // 排除当前目录和上级目录
                if (is_dir($dir . "/" . $object)) { // 如果是子目录
                    delete_directory($dir . "/" . $object); // 递归调用函数删除子目录及其内容
                } else {
                    unlink($dir . "/" . $object); // 删除文件
                }
            }
        }
        rmdir($dir); // 删除目录
    }
}