硬核项目经理

硬核项目经理 查看完整档案

填写现居城市  |  填写毕业院校  |  填写所在公司/组织填写个人主网站
编辑
_ | |__ _ _ __ _ | '_ \| | | |/ _` | | |_) | |_| | (_| | |_.__/ \__,_|\__, | |___/ 个人简介什么都没有

个人动态

硬核项目经理 发布了文章 · 4月16日

PHP垃圾回收机制的一些浅薄理解

相信只要入门学习过一点开发的同学都知道,不管任何编程语言,一个变量都会保存在内存中。其实,我们这些开发者就是在来回不停地操纵内存,相应地,我们如果一直增加新的变量,内存就会一直增加,如果没有一个好的机制,那么内存就会无限制地增加最终撑满所有的内存。这就造成了内存泄露。但在日常开发中,除非一次加载一个很大的文件,我们几乎见不到内存超限的错误,这就是垃圾回收机制的作用。

垃圾回收是什么东西?

在使用 C 语言的时候,我们都要手动使用 free 来释放内存,在 C 之后的大部分编程语言都会自带一个垃圾回收之类的处理能力,也就是我们今天要说的垃圾回收机制,也称为 GC 。在有 GC 能力的开发语言中,我们不需要去关心什么时候释放内存,甚至我们完全不需要去了解这一块的内容,因为这些语言在底层已经帮我们处理好了关于内存释放的问题。

当然这方面的内容最出名的就是 Java 中的垃圾回收机制,其实 PHP 也有相应的处理机制,当然,很多 PHPer 可能从来没接触过,今天我们就来探讨一下这方面的内容。

PHP 的垃圾回收算法

在之前的文章中,我们有介绍过引用计数的概念 []() 。在 PHP5.3 之前,PHP 的垃圾回收机制非常简单,就是把 refcount 为0的全部清理回收掉,在底层也就是 free 掉了。但是这种方式会带来一个问题,也就是我们在引用计数这篇文章中说过的循环引用,这种引用问题通过普通的判断 refcount 的方式是无法回收的。所以在 PHP5.3 之前,循环引用是会造成内存泄露的。

之所以强调版本,那是因为在 5.3 之后,PHP 改进了垃圾回收的算法,使这种循环引用得到了解决。(当然,我们在日常开发中尽量要避免这种循环引用的问题)。具体算法我们引用官方的图片:

/img/bVcRi1j

在官方文档中有详尽的解释,不过还是会看得很懵逼。我们就用简单的语言(说人话)来描述这个过程。

首先,我们有个根缓冲区的概念,就是图中的 root 。在底层通过一系列看不懂搞不明白的算法我们能找到每个变量的一个可能根。PHP 会将变量的可能根放入根缓冲区。

当根缓冲区满了的时候,一般这个默认值是10000,需要修改源码重新编译才能修改这个值。PHP 就会启动垃圾回收机制,从根缓冲区中按照深度遍历的算法来查找所有的和这个可能根相关的变量,并将某一个可能根找到的变量的 refcount 减1,并做一个标记当前这个“已减”。

然后再次深度遍历,如果 refcount 不是0的,就加1,如果是0的就保持不变。

接着清除根缓冲区中的所有可能根,清除而不是删除。然后清理释放所有的 refcount 为0的变量内容。

是不是已经懵逼了?其实我也很懵逼,都不知道这段是怎么写下来的....

记住几个要点就可以对付面试并秒杀大部分人了。

  • PHP5.3 后并不是直接看每个变量的 refcount 是否为0了
  • 使用的算法是深度遍历,有个根缓冲区,根据它来清理,具体算法需要比较扎实的 C 和算法基础,学源码的时候再好好研究吧
  • 5.3 之后和算法解决了循环引用的问题
  • 内存泄露值会保持在某一个范围,不会出现立即大范围崩溃的情况

垃圾回收对性能的影响

前文说过,垃圾回收在根缓冲区满了之后会马上执行。其中也会进行两次的深度遍历,这就不可避免的带来了性能的消耗。毕竟算法的执行都是需要耗时的。不过相对于内存溢出这种毁灭性的错误来说,垃圾回收带来的性能损耗基本上是可以忽略不计的。

总结

垃圾回收的内容其实我们只需要记住几个关键点就可以了,具体的核心算法和内容是需要在更深入的研究源码后才能完全了解的,当然,这也是我们学习的目标,之后也一定会涉猎源码底层的相关内容,就让我们拭目以待吧!

参考文档:

https://www.php.net/manual/zh/features.gc.collecting-cycles.php

https://www.php.net/manual/zh/features.gc.performance-considerations.php

https://www.cnblogs.com/lishanlei/p/9852274.html

https://www.cnblogs.com/lovehappying/p/3679356.html

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 4月15日

PHP多文件上传格式化

文件上传是所有web应用中最常见的功能,而PHP实现这一功能也非常的简单,只需要前端设置表单的 enctype 值为 multipart/form-data 之后,我们就可以通过 $_FILES 获得表单中的 file 控件中的内容。

同时,我们还可以将 file 控件的名称写成带 [] 的数组形式,这样我们就可以接收到多个上传的文件。比如下面这个测试用的表单:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <form action="" enctype="multipart/form-data" method="post">

    myfile1:<input type="file" name="myfile[]"/><br/>
    myfile2:<input type="file" name="myfile[a][]"/><br/>
    myfile3:<input type="file" name="myfile[a][b][]"/><br/>
    myfile4:<input type="file" name="myfile[c][]"/><br/>
    myfile5:<input type="file" name="myfile[]"/><br/>
    myfile6:<input type="file" name="myfile[][]"/><br/>
    <br/>
    newfile1:<input type="file" name="newfile[][]"/><br/>
    newfile2:<input type="file" name="newfile[s]"/><br/>

    singlefile: <input type="file" name="singlefile"/><br/>
        <input type="submit" value="submit"/>
    </form>
</body>
</html>

一共有9个 file 控件,其中 myfile 和 newfile 都是数组类型的表单名,而 singlefile 则是一个单独的。先简单的看一下 $_FILES 所获得的内容。


print_r($_FILES);

Array
(
    [myfile] => Array
        (
            [name] => Array
                (
                    [0] => 2591d8b3eee018a0a84f671933ab6c74.png
                    [a] => Array
                        (
                            [0] => 12711584942474_.pic_hd 1.jpg
                            [b] => Array
                                (
                                    [0] => 12721584942474_.pic_hd 1.jpg
                                )

                        )

                    [c] => Array
                        (
                            [0] => 12731584942474_.pic_hd.jpg
                        )

                    [1] => background1.jpg
                    [2] => Array
                        (
                            [0] => adliu_pip_data.xlsx
                        )

                )

            [type] => Array
                (
                    [0] => image/png
                    [a] => Array
                        (
                            [0] => image/jpeg
                            [b] => Array
                                (
                                    [0] => image/jpeg
                                )

                        )

                    [c] => Array
                        (
                            [0] => image/jpeg
                        )

                    [1] => image/jpeg
                    [2] => Array
                        (
                            [0] => application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
                        )

                )

            [tmp_name] => Array
                (
                    [0] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phphD88ZY
                    [a] => Array
                        (
                            [0] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpNY8MzY
                            [b] => Array
                                (
                                    [0] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/php3MX5tk
                                )

                        )

                    [c] => Array
                        (
                            [0] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpjgrHMj
                        )

                    [1] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phppXRtnc
                    [2] => Array
                        (
                            [0] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpekSY1M
                        )

                )

            [error] => Array
                (
                    [0] => 0
                    [a] => Array
                        (
                            [0] => 0
                            [b] => Array
                                (
                                    [0] => 0
                                )

                        )

                    [c] => Array
                        (
                            [0] => 0
                        )

                    [1] => 0
                    [2] => Array
                        (
                            [0] => 0
                        )

                )

            [size] => Array
                (
                    [0] => 4973
                    [a] => Array
                        (
                            [0] => 3007
                            [b] => Array
                                (
                                    [0] => 1156
                                )

                        )

                    [c] => Array
                        (
                            [0] => 6068
                        )

                    [1] => 393194
                    [2] => Array
                        (
                            [0] => 36714
                        )

                )

        )

    [newfile] => Array
        (
            [name] => Array
                (
                    [0] => Array
                        (
                            [0] => 数据列表 (2).xlsx
                        )

                    [s] => background1.jpg
                )

            [type] => Array
                (
                    [0] => Array
                        (
                            [0] => application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
                        )

                    [s] => image/jpeg
                )

            [tmp_name] => Array
                (
                    [0] => Array
                        (
                            [0] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phplSsRfM
                        )

                    [s] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpuQAvRb
                )

            [error] => Array
                (
                    [0] => Array
                        (
                            [0] => 0
                        )

                    [s] => 0
                )

            [size] => Array
                (
                    [0] => Array
                        (
                            [0] => 77032
                        )

                    [s] => 393194
                )

        )

    [singlefile] => Array
        (
            [name] => timg (8).jpeg
            [type] => image/jpeg
            [tmp_name] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpxtSQ4J
            [error] => 0
            [size] => 10273
        )

)

看出有什么问题了吗?

$_FILE['singlefile']['name'];
$_FILE['singlefile']['type'];
$_FILE['singlefile']['tmp_name'];
$_FILE['singlefile']['error'];
$_FILE['singlefile']['error'];

$_FILE['myfile']['name']['a']['b'][0];
$_FILE['myfile']['type']['a']['b'][0];
$_FILE['myfile']['tmp_name']['a']['b'][0];
$_FILE['myfile']['error']['a']['b'][0];
$_FILE['myfile']['error']['a']['b'][0];

单个表单是一个 singlefile 为键名的数组,里面是对应的 name 、 type 等属性。这个非常简单也清晰明了,但是数组形式上传的内容就比较坑了,每一个属性下面都有多个值,而且这些值还有可能是嵌套的数组。就比如说我们要获得 myfilea[] 的上传文件内容,我们就要通过 \$_FILE'myfile''a'[0] 、 $_FILE['myfile']['type']['a']['b'][0] 这样的形式获得相关的内容。这个可真的不是很友好,那么我们今天的主题就来了,我们把这种内容进行一下格式化,让他变成和 singlefile 类似的结构,也就是一个文件的相关内容都在一个键名结构下,比如 myfile[a][b][] 的内容就全部都在 $_FILE'myfile'b下面。

$files = [];
// 开始数据格式化
foreach ($_FILES as $uploadKey => $uploadFiles) {
    // 需要将 $_FILES 中的五个字段都拿出来
    $files[$uploadKey] = formatUploadFiles($uploadFiles['name'], $uploadFiles['type'], $uploadFiles['tmp_name'], $uploadFiles['error'], $uploadFiles['size']);
}

// 格式化上传文件数组
function formatUploadFiles($fileNamesArray, $type, $tmp_name, $error, $size)
{
    $tmpFiles = [];
    // 文件名是否是数组,如果不是数组,就是单个文件上传
    if (is_array($fileNamesArray)) {
        // 数组形式上传
        foreach ($fileNamesArray as $idx => $fileName) {
            // 如果还是嵌套的数组,递归遍历接下来的内容
            if (is_array($fileName)) {
                $tmpFiles[$idx] = formatUploadFiles($fileName, $type[$idx] ?? [], $tmp_name[$idx] ?? [], $error[$idx] ?? [], $size[$idx] ?? []);
            } else {
                // 组合多维的格式化内容
                $tmpFiles[$idx] = [
                    'name' => $fileName,
                    'type' => $type[$idx] ?? '',
                    'tmp_name' => $tmp_name[$idx] ?? '',
                    'error' => $error[$idx] ?? '',
                    'size' => $size[$idx] ?? '',
                ];
            }
        }
    } else {
        // 组合单个的内容
        $tmpFiles = [
            'name' => $fileName,
            'type' => $type ?? '',
            'tmp_name' => $tmp_name ?? '',
            'error' => $error ?? '',
            'size' => $size ?? '',
        ];
    }

    return $tmpFiles;
}

print_r($files);

代码还是非常好理解的,就是通过一段递归来遍历整个 $_FILES 目录树,相当于一个深度遍历。当然,这样也会带来性能的下降,毕竟是需要进行循环+递归的遍历。不过好在大部分情况下我们上传的文件并不会那么的多。不过反过来说,如果不事先进行格式化,当你想获得所有的上传内容时,一样还是需要进行多层或者递归遍历的。

接下来我们看看格式化之后的输出:

Array
(
    [myfile] => Array
        (
            [0] => Array
                (
                    [name] => 2591d8b3eee018a0a84f671933ab6c74.png
                    [type] => image/png
                    [tmp_name] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpV7A2yC
                    [error] => 0
                    [size] => 4973
                )

            [a] => Array
                (
                    [0] => Array
                        (
                            [name] => 12711584942474_.pic_hd 1.jpg
                            [type] => image/jpeg
                            [tmp_name] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/php5q2d1Z
                            [error] => 0
                            [size] => 3007
                        )

                    [b] => Array
                        (
                            [0] => Array
                                (
                                    [name] => 12721584942474_.pic_hd 1.jpg
                                    [type] => image/jpeg
                                    [tmp_name] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpdvv8No
                                    [error] => 0
                                    [size] => 1156
                                )

                        )

                )

            [c] => Array
                (
                    [0] => Array
                        (
                            [name] => 12731584942474_.pic_hd.jpg
                            [type] => image/jpeg
                            [tmp_name] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/php9tfGmp
                            [error] => 0
                            [size] => 6068
                        )

                )

            [1] => Array
                (
                    [name] => background1.jpg
                    [type] => image/jpeg
                    [tmp_name] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phplUVpzA
                    [error] => 0
                    [size] => 393194
                )

            [2] => Array
                (
                    [0] => Array
                        (
                            [name] => adliu_pip_data.xlsx
                            [type] => application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
                            [tmp_name] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpNRtiaC
                            [error] => 0
                            [size] => 36714
                        )

                )

        )

    [newfile] => Array
        (
            [0] => Array
                (
                    [0] => Array
                        (
                            [name] => 数据列表 (2).xlsx
                            [type] => application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
                            [tmp_name] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpBLG7aG
                            [error] => 0
                            [size] => 77032
                        )

                )

            [s] => Array
                (
                    [name] => background1.jpg
                    [type] => image/jpeg
                    [tmp_name] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpjyqCFY
                    [error] => 0
                    [size] => 393194
                )

        )

    [singlefile] => Array
        (
            [name] =>
            [type] => image/jpeg
            [tmp_name] => /private/var/folders/wj/t2z1cfhs0m9gq48krm8nc0vm0000gn/T/phpuYJXiE
            [error] => 0
            [size] => 10273
        )

)

和上面原始的 $_FILES 相比是不是清晰明了的很多?这回我们如果需要 myfilea[] 里面全部的内容时,就可以使用下面的方式方便的获取了:

$files['myfile']['a']['b'][0]['name'];
$files['myfile']['a']['b'][0]['type'];
$files['myfile']['a']['b'][0]['tmp_name'];
$files['myfile']['a']['b'][0]['error'];
$files['myfile']['a']['b'][0]['size'];

当然,这种需求在我们的日常工作中并不多见,这里也只是提供一个思路,将数据提前转化成我们需要的格式是一种非常好的习惯,能够让我们的后续操作变得非常简单。

测试代码:

https://github.com/zhangyue0503/dev-blog/blob/master/php/202004/source/PHP%E5%A4%9A%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0%E6%A0%BC%E5%BC%8F%E5%8C%96.php

参考文档:

https://www.php.net/manual/zh/features.file-upload.php

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 4月14日

PHP的CLI命令行运行模式浅析

在做开发的时候,我们不仅仅只是做各种网站或者接口,也经常需要写一些命令行脚本用来处理一些后端的事务。比如对数据进行处理统计等。当然也是为了效率着想,当一个事务有可能会有较长的耗时时,往往会交由服务器的定时器来固定时间调用脚本进行处理,从而让客户端能够有更好的用户体验。我们今天就来了解下 PHP 的命令行运行模式,也就是 PHP CLI 。

CLI 与 CGI

首先来看一下 CLI 和 CGI 的区别。我们都知道,Nginx 使用的是 FastCgi 来调用 PHP 的服务。 CGI 是通用编程接口,也就是给调用者提供的一种使用本程序的接口。 Nginx 这种类型的服务器并不是直接运行 PHP 程序的,而是通过 FastCgi 来执行 PHP 程序并获得返回结果。

CLI 则是 Command Line Interface,即命令行接口。主要用作 PHP 的开发外壳应用。也就是用 PHP 来进行 shell 脚本的开发。相比 linux 原生的 shell 来说,当然是方便了许多。在命令行状态下,直接使用 php 命令就可以运行某段 PHP 代码或某个 PHP 文件了。

另外,我们在命令行也可以直接使用 phpcgi 来运行一段 PHP 代码或者某个 PHP 文件,它和直接使用 php 命令来运行有什么区别呢?

  • CLI 的输出没有任何头信息
  • CLI 在运行时,不会把工作目录改为脚本的当前目录
  • CLI 出错时输出纯文本的错误信息(非 HTML 格式)
  • 强制覆盖了 php.ini 中的某些设置,因为这些设置在外壳环境下是没有意义的
// PHP的CLI命令行运行模式浅析.php
echo getcwd();

//  php-cgi dev-blog/php/202004/source/PHP的CLI命令行运行模式浅析.php
// ...../MyDoc/博客文章/dev-blog/php/202004/source

// php dev-blog/php/202004/source/PHP的CLI命令行运行模式浅析.php
// ...../MyDoc/博客文章

我们选取最典型的一个例子,我们运行的这个文件中,使用 getcwd() 输出当前脚本运行的目录,可以看出两种运行方式输出的结果明显不同。php-cgi 是以文件所在目录为基准输出,而 php 则是以当前运行这个命令的目录为基准输出。

直接运行 PHP 代码

在做一些简单的调试的时候,我们可以直接通过 CLI 来运行一段代码。

// php -r "echo 121;"
// 121

也就是简单的加个 -r 参数,后面跟上一段代码,这段代码必须用引号括起来。而且这个引号更推荐使用单引号,后面的例子会展示为什么用单引号更好。

CLI 获取参数

命令行模式下也是可以给脚本传递参数的。

// PHP的CLI命令行运行模式浅析.php
print_r($argv);
// php-cgi dev-blog/php/202004/source/PHP的CLI命令行运行模式浅析.php 1 2 3
// X-Powered-By: PHP/7.3.0
// Content-type: text/html; charset=UTF-8

// php dev-blog/php/202004/source/PHP的CLI命令行运行模式浅析.php 1 2 3
// Array
// (
//     [0] => dev-blog/php/202004/source/PHP的CLI命令行运行模式浅析.php
//     [1] => 1
//     [2] => 2
//     [3] => 3
// )

在测试文件中,我们打印了 \$argv 变量。PHP 脚本运行的时候,会将命令行的所有参数保存在 $argv 变量中,并且还有一个 $argc 变量会保存参数的个数。

我们依然是使用 php-cgi 和 php ,两种模式来测试,从这里我们能发现 php-cgi 模式中 $argv 打印的内容竟然是头信息,而不是具体的参数信息。这也没错,毕竟 CGI 模式本来就是为 Web 服务器提供的接口,所以它接收的是 post 、 get 这类的参数而不是命令行的参数。

CLI 模式下我们正常获得了参数内容,并且 $argv[0] 始终保存的是当前运行文件及路径。

CLI 命令行实用选项

最后,我们再介绍一些命令行中常用的选项。

-r 直接运行代码时的参数传递

// php -r "var_dump($argv);" app 
// Warning: var_dump() expects at least 1 parameter, 0 given in Command line code on line 1
// 双引号 ",sh/bash 实行了参数替换

// php -r 'var_dump($argv);' app
// array(2) {
//     [0]=>string(19) "Standard input code"
//     [1]=>string(3) "app"
// }

// php -r 'var_dump($argv);' -- -h
// array(2) {
//     [0]=>string(19) "Standard input code"
//     [1]=>string(2) "-h"
// }

第一段代码在对双引号运行的 CLI 代码进行参数传递的时候,会直接报警告。其实很好理解,双引号里面的$会让系统的 sh/bash 以为这是个变量从而进行变量参数替换。所以更推荐使用单引号进行日常的简单测试。

第二段代码能够正常打印传递进来的参数内容。第三行代码则是需要传递带 - 符号的内容时,需要先给一个 -- 参数列表分隔符。这是因为 -xxx 的内容会让 php 命令认为这是一个命令选项而不是参数,所以我们添加一个分隔符就可以让分隔符之后的参数内容原样传递进代码中。

交互式地运行 PHP

// php -a
// php > $a = 1;
// php > echo $a;
// php > 1

添加一个 -a 选项,PHP 就会以交互式地形式运行,我们可以直接在交互状态下写代码或运行任何内容。

查看 phpinfo() 及已经安装的模块

这两个应该是大家经常会使用的两个选项。

// 输出 phpinfo()
// php -i

// 输出 PHP 中加载的模块
// php -m

// 查看模块详细信息
// php --ri swoole 

另外我们还可以通过 --ri 模块名 这个命令来查看具体某个扩展模块的详细信息。比如这里我们可以查看到 swoole 扩展的版本及相关的配置信息。

查看某个文件

// 显示去除了注释和多余空白的源代码
// php -w dev-blog/php/202004/source/PHP的CLI命令行运行模式浅析.php
// <?php
//  echo getcwd(); print_r($argv);

// 通过 linux 管道读取输入
// cat dev-blog/php/202004/source/PHP的CLI命令行运行模式浅析.php | php -r "print file_get_contents('php://stdin');"
// ......这个文件里面所有的内容

最后两个小技巧,一个是通过 -w 选项,我们可以打印这个 php 文件中所有非注释和换行的内容。可以看成是像前端的代码压缩一样的能力。我们这个测试文件中有非常多的注释,通过这个命令后我们打印出来的内容是去除掉所有注释和空白行的结果。

另一个是我们可以用 linux 管道的方式向 PHP CLI 发送数据。这里我们通过 cat 查看我们的测试文件然后通过管道发送给 PHP CLI,在脚本中使用 STDIN 来读取管道发送过来的内容完成了整个文件内容的打印。这里我们没进行任何过滤,所以打印的是整个文件里面的内容,大家可以运行这个命令来测试。

总结

其实命令行模式运行的时候还有很多的选项,这里我们只是选取了一部分非常有用的内容进行展示。当然,大部分框架都提供了用于命令行的脚本框架,比如 laravel 中可以通过 php artisan make:command 来创建命令行脚本,然后使用 php artisan 来运行框架中的脚本。这些内容将来我们在学习框架方面知识的内容将会进行详细的讲解。

命令行 CLI 模式的应用非常广泛,几乎任何项目中都会使用到,所以,深入的学习掌握它将会使我们大受裨益。

测试代码:

https://github.com/zhangyue0503/dev-blog/blob/master/php/202004/source/PHP%E7%9A%84CLI%E5%91%BD%E4%BB%A4%E8%A1%8C%E8%BF%90%E8%A1%8C%E6%A8%A1%E5%BC%8F%E6%B5%85%E6%9E%90.php

参考文档:

https://www.php.net/manual/zh/features.commandline.php

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 4月12日

PHP的引用计数是什么意思?

什么是引用计数

在PHP的数据结构中,引用计数就是指每一个变量,除了保存了它们的类型和值之外,还额外保存了两个内容,一个是当前这个变量是否被引用,另一个是引用的次数。为什么要多保存这样两个内容呢?当然是为了垃圾回收(GC)。也就是说,当引用次数为0的时候,这个变量就没有再被使用了,就可以通过 GC 来进行回收,释放占用的内存资源。任何程序都不能无限制的一直占用着内存资源,过大的内存占用往往会带来一个严重的问题,那就是内存泄露,而 GC 就是PHP底层自动帮我们完成了内存的销毁,而不用像 C 一样必须去手动地 free 。

怎么查看引用计数?

我们需要安装 xdebug 扩展,然后使用 xdebug_debug_zval() 函数就可以看到指定内存的详细信息了,比如:

$a = "I am a String";
xdebug_debug_zval('a');
// a: (refcount=1, is_ref=0)='I am a String'

从上述内容中可以看出,这个 $a 变量的内容是 I am a String 这样一个字符串。而括号中的 refcount 就是引用次数,is_ref 则是说明这个变量是否被引用。我们通过变量赋值来看看这个两个参数是如何变化的。

$b = $a;
xdebug_debug_zval('a');
// a: (refcount=1, is_ref=0)='I am a String'

$b = &$a;
xdebug_debug_zval('a');
// a: (refcount=2, is_ref=1)='I am a String'

当我们进行普通赋值后,refcount 和 is_ref 没有任何变化,但当我们进行引用赋值后,可以看到 refcount 变成了2,is_ref 变成了1。这也就是说明当前的 \$a 变量被引用赋值了,它的内存符号表服务于 $a 和 $b 两个变量。

$c = &$a;
xdebug_debug_zval('a');
// a: (refcount=3, is_ref=1)='I am a String'

unset($c, $b);
xdebug_debug_zval('a');
// a: (refcount=1, is_ref=1)='I am a String'

$b = &$a;
$c = &$a;
$b = "I am a String new";
xdebug_debug_zval('a');
// a: (refcount=3, is_ref=1)='I am a String new'

unset($a);
xdebug_debug_zval('a');
// a: no such symbol

继续增加一个 $c 的引用赋值,可以看到 refcount 会继续增加。然后 unset 掉 $b 和 $c 之后,refcount 恢复到了1,不过这时需要注意的是,is_ref 依然还是1,也就是说,这个变量被引用过,这个 is_ref 就会变成1,即使引用的变量都已经 unset 掉了这个值依然不变。

最后我们 unset 掉 $a ,显示的就是 no such symbol 了。当前变量已经被销毁不是一个可以用的符号引用了。(注意,PHP中的变量对应的是内存的符号表,并不是真正的内存地址)

对象的引用计数

和普通类型的变量一样,对象变量也是使用同样的计数规则。

// 对象引用计数
class A{

}
$objA = new A();
xdebug_debug_zval('objA');
// objA: (refcount=1, is_ref=0)=class A {  }

$objB = $objA;
xdebug_debug_zval('objA');
// objA: (refcount=2, is_ref=0)=class A {  }

$objC = $objA;
xdebug_debug_zval('objA');
// objA: (refcount=3, is_ref=0)=class A {  }

unset($objB);
class C{

}
$objC = new C;
xdebug_debug_zval('objA');
// objA: (refcount=1, is_ref=0)=class A {  }

不过这里需要注意的是,对象的符号表是建立的连接,也就是说,对 $objC 进行重新实例化或者修改为 NULL ,并不会影响 $objA 的内容,这方面的知识我们在之前的 对象赋值在PHP中到底是不是引用? 文章中已经有过说明。对象进行普通赋值操作也是引用类型的符号表赋值,所以我们不需要加 & 符号。

数组的引用计数

// 数组引用计数
$arrA = [
    'a'=>1,
    'b'=>2,
];
xdebug_debug_zval('arrA');
// arrA: (refcount=2, is_ref=0)=array (
//     'a' => (refcount=0, is_ref=0)=1, 
//     'b' => (refcount=0, is_ref=0)=2
// )

$arrB = $arrA;
$arrC = $arrA;
xdebug_debug_zval('arrA');
// arrA: (refcount=4, is_ref=0)=array (
//     'a' => (refcount=0, is_ref=0)=1, 
//     'b' => (refcount=0, is_ref=0)=2
// )

unset($arrB);
$arrC = ['c'=>3];
xdebug_debug_zval('arrA');
// arrA: (refcount=2, is_ref=0)=array (
//     'a' => (refcount=0, is_ref=0)=1, 
//     'b' => (refcount=0, is_ref=0)=2
// )

// 添加一个已经存在的元素
$arrA['c'] = &$arrA['a'];
xdebug_debug_zval('arrA');
// arrA: (refcount=1, is_ref=0)=array (
//     'a' => (refcount=2, is_ref=1)=1, 
//     'b' => (refcount=0, is_ref=0)=2, 
//     'c' => (refcount=2, is_ref=1)=1
// )

调试数组的时候,我们会发现两个比较有意思的事情。

一是数组内部的每个元素又有单独的自己的引用计数。这也比较好理解,每一个数组元素都可以看做是一个单独的变量,但数组就是这堆变量的一个哈希集合。如果在对象中有成员变量的话,也是一样的效果。当数组中的某一个元素被 & 引用赋值给其他变量之后,这个元素的 refcount 会增加,不会影响整个数组的 refcount 。

二是数组默认上来的 refcount 是2。其实这是 PHP7 之后的一种新的特性,当数组定义并初始化后,会将这个数组转变成一个不可变数组(immutable array)。为了和普通数组区分开,这种数组的 refcount 是从2开始起步的。当我们修改一下这个数组中的任何元素后,这个数组就会变回普通数组,也就是 refcount 会变回1。这个大家可以自己尝试下,关于为什么要这样做的问题,官方的解释是为了效率,具体的原理可能还是需要深挖 PHP7 的源码才能知晓。

关于内存泄露需要注意的地方

其实 PHP 在底层已经帮我们做好了 GC 机制就不需要太关心变量的销毁释放问题,但是,千万要注意的是对象或数组中的元素是可以赋值为自身的,也就是说,给某个元素赋值一个自身的引用就变成了循环引用。那么这个对象就基本不太可能会被 GC 自动销毁了。

// 对象循环引用
class D{
    public $d;
}
$d = new D;
$d->d = $d;
xdebug_debug_zval('d');
// d: (refcount=2, is_ref=0)=class D { 
//     public $d = (refcount=2, is_ref=0)=... 
// }

// 数组循环引用
$arrA['arrA'] = &$arrA;
xdebug_debug_zval('arrA');
// arrA: (refcount=2, is_ref=1)=array (
//     'a' => (refcount=0, is_ref=0)=1, 
//     'b' => (refcount=0, is_ref=0)=2, 
//     'arrA' => (refcount=2, is_ref=1)=...
// )

不管是对象还是数组,在打印调试时出现了 ... 这样的省略号,那么你的程序中就出现了循环引用。在之前的文章 关于PHP中对象复制的那点事儿 中我们也讲过这个循环引用的问题,所以这个问题应该是我们在日常开发中应该时刻关注的问题。

总结

引用计数是了解垃圾回收机制的前提条件,而且正是因为现代语言中都有一套类似的垃圾回收机制才让我们的编程变得更加容易且安全。那么有人说了,日常开发根本用不到这些呀?用不到不代表不应该去学习,就像循环引用这个问题一样,当代码中充斥着大量的类似代码时,系统崩溃只是迟早的事情,所以,这些知识是我们向更高级的程序进阶所不可或缺的内容。

测试代码:
https://github.com/zhangyue0503/dev-blog/blob/master/php/202004/source/PHP%E7%9A%84%E5%BC%95%E7%94%A8%E8%AE%A1%E6%95%B0%E6%98%AF%E4%BB%80%E4%B9%88%E6%84%8F%E6%80%9D%EF%BC%9F.php

参考文档:
https://www.php.net/manual/zh/features.gc.refcounting-basics.php
https://ask.csdn.net/questions/706390

https://www.jianshu.com/p/52450a61354d

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 4月9日

PHP的内置WEB服务器

在很多时候,我们需要简单的运行一个小 demo 来验证一些代码或者轮子是否可用,是否可以运行起来,但是去配 nginx 或者 apache 都很麻烦,其实,PHP CLI 已经提供了一个简单的测试服务器,我们直接就可以运行起来进行简单的一些测试工作。

直接启动一个内置服务器

php -S localhost:8081

直接使用 -S 命令选项,然后指定地址及端口号,我们就可以运行起来一个 PHP 内置的简易WEB服务器。默认情况下,这个地址会找当前目录下的 index.php 或 index.html 文件。当我们在浏览器输入指定的文件时,就是访问指定的文件,如果都没有找到会正常的返回404错误。

而控制台会输出当前服务器的访问情况,如下图所示:

/img/bVcQ899

这个内置服务器和用 nginx 等服务器搭起来的应用服务器本质上没有太大的区别,包括 $_SERVER 之类的内容都可以正常获取到,也可以正常使用 include 等功能加载其他文件,也就是说这个内置WEB服务器运行一些框架也是没有问题的。它是可以完全满足我们的测试要求的。但是需要注意的是,这个内置WEB服务器不能用于生产环境。毕竟它的功能还是太简单,不是一个生产配备的高规格服务器应用。

指定内置服务器的运行目录

我们也可以在任何目录去运行指定目录的php代码,只需要再增加一个 -t 选项来指明要运行起服务器的根目录即可。

php -S localhost:8081 -t dev-blog/php/202004/source

这样我们就可以运行起来一个以 dev-blog/php/202004/source 目录为根目录的测试环境服务器。

使用路由脚本

php -S localhost:8081 PHP的内置WEB服务器.php

如果我们给当前服务器直接指定了一个PHP文件,那么直接打开链接就会访问的是这个文件的内容,而不是去找 index.php 之类的文件。即使我们继续给 URL 后台增加其他路径或者其他文件名,它依然会打开的是这个文件,也就是说,我们启动了一个单文件入口的应用服务器程序。就像各种框架的 index.php 文件一样,比如我们利用这个文件做一个简单的路由分发测试:

$routePages = [
    '/testRoute2.php',
    '/route/testRoute1.php'
];

if(in_array($_SERVER['REQUEST_URI'], $routePages)){
    include __DIR__ . $_SERVER['REQUEST_URI'];
}else{
    print_r($_SERVER);
}
// route/testRoute1.php
echo "Hello Route1!";

// testRoute2.php
echo "Hello Route2!";

两个测试文件只是简单的输出了一段文字用于区别分别加载了两个文件。上述代码的意思是我们访问定义好的两个路由路径时,就会加载对应的文件,访问其他路径则会打印当前服务器的 $_SERVER 信息。

测试代码:
https://github.com/zhangyue0503/dev-blog/blob/master/php/202004/source/PHP%E7%9A%84%E5%86%85%E7%BD%AEWEB%E6%9C%8D%E5%8A%A1%E5%99%A8.php

参考文档:
https://www.php.net/manual/zh/features.commandline.webserver.php

===========

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 1 收藏 1 评论 0

硬核项目经理 发布了文章 · 4月8日

PHP打印跟踪调试信息

对于大部分编译型语言来说,比如 C 、 Java 、 C# ,我们都能很方便地进行断点调试,但是 PHP 则必须安装 XDebug 并且在编辑器中进行复杂的配置才能实现断点调试的能力。不过,如果只是简单的调试并且查看堆栈回溯的话,其实 PHP 已经为我们准备好了两个函数,能够让我们非常方便的看到程序运行时的调用情况。

debug_backtrace()

从这个方法的字面意思上就可以看出,它的意思就是调试回溯,返回的也正是一段回溯信息的数组。

function a_test($str)
{
    echo "Hi: $str", PHP_EOL;
    var_dump(debug_backtrace());
}

var_dump(debug_backtrace());

a_test("A");

// Hi: A/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:7:
// array(1) {
//   [0] =>
//   array(4) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(12)
//     'function' =>
//     string(6) "a_test"
//     'args' =>
//     array(1) {
//       [0] =>
//       string(1) "A"
//     }
//   }
// }

这个方法必须在函数中调用,在函数方法外部使用是不会有内容的。从内容中看,它输出了关于这个函数的 \_\_FILE__ 、 \_\_LINE__ 、 \_\_FUNCTION__ 、$argv 等信息。其实就是关于当前打印这行所在函数的相关内容。

我们当然也可以多嵌套几层函数来看一下打印出的内容是什么。

function b_test(){
    c_test();
}

function c_test(){
    a_test("b -> c -> a");
}

b_test();

// Hi: b -> c -> a
// /Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:7:
// array(3) {
//   [0] =>
//   array(4) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(37)
//     'function' =>
//     string(6) "a_test"
//     'args' =>
//     array(1) {
//       [0] =>
//       string(11) "b -> c -> a"
//     }
//   }
//   [1] =>
//   array(4) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(33)
//     'function' =>
//     string(6) "c_test"
//     'args' =>
//     array(0) {
//     }
//   }
//   [2] =>
//   array(4) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(40)
//     'function' =>
//     string(6) "b_test"
//     'args' =>
//     array(0) {
//     }
//   }
// }

没错,数组的输出顺序就是一个栈的执行顺序,b_test() 最先调用,所以它在栈底,对应的输出也就是数组中的最后一个元素。

在类中也是类似的使用方法。

class A{
    function test_a(){
        $this->test_b();
    }
    function test_b(){
        var_dump(debug_backtrace());
    }
}

$a = new A();
$a->test_a();

// /Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:90:
// array(2) {
//   [0] =>
//   array(7) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(87)
//     'function' =>
//     string(6) "test_b"
//     'class' =>
//     string(1) "A"
//     'object' =>
//     class A#1 (0) {
//     }
//     'type' =>
//     string(2) "->"
//     'args' =>
//     array(0) {
//     }
//   }
//   [1] =>
//   array(7) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(95)
//     'function' =>
//     string(6) "test_a"
//     'class' =>
//     string(1) "A"
//     'object' =>
//     class A#1 (0) {
//     }
//     'type' =>
//     string(2) "->"
//     'args' =>
//     array(0) {
//     }
//   }
// }

在类中使用的时候,在数组项中会多出一个 object 字段,显示的是这个方法所在类的信息。

debug_backtrace() 的函数声明是:

debug_backtrace ([ int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT [, int $limit = 0 ]] ) : array

其中 \$options 是有两个常量可以定义,DEBUG_BACKTRACE_PROVIDE_OBJECT 表明是否填充 "object" 的索引;DEBUG_BACKTRACE_IGNORE_ARGS 是否忽略 "args" 的索引,包括所有的 function/method 的参数,能够节省内存开销。 $limits 可用于限制返回堆栈帧的数量,默认为0返回所有的堆栈。

debug_backtrace() 以及下面要介绍的 debug_print_backtrace() 方法都是支持 require/include 文件以及 eval() 中的代码的,在嵌入文件时,会输出嵌入文件的路径,这个大家可以自行尝试。

debug_print_backtrace()

这个方法从名称也可以看出,它会直接打印回溯内容,它的函数声明和 debug_backtrace() 是一样的,不过 $options 默认是 DEBUG_BACKTRACE_IGNORE_ARGS ,也就是说,它只打印调用所在文件及行数。

function a() {
    b();
}

function b() {
    c();
}

function c(){
    debug_print_backtrace();
}

a();

#0  c() called at [/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:144]
#1  b() called at [/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:140]
#2  a() called at [/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:151]

另外就是这个函数不需要使用 var_dump() 或 print_r() 进行输出,直接使用这个函数就会进行输出。能够非常快捷方便的让我们进行调试,比如在 laravel 这类大型框架中,我们在控制器需要查看堆栈信息时,就可以使用 debug_print_backtrace() 快速地查看当前的堆栈调用情况。而 debug_backtrace() 如果没有指定 $options 的话,则会占用非常大的内存容量或者无法完整显示。

总结

今天介绍的这两个函数能够灵活地帮助我们调试代码或者了解一个框架的调用情况。当然,在正式的情况下还是推荐使用 Xdebug 加上编辑器的支持来进行断点调试,因为使用 debug_backtrace() 这两个方法我们无法看到变量的变化情况。

测试代码:

https://github.com/zhangyue0503/dev-blog/blob/master/php/202004/source/PHP%E6%89%93%E5%8D%B0%E8%B7%9F%E8%B8%AA%E8%B0%83%E8%AF%95%E4%BF%A1%E6%81%AF.php

参考文档:
https://www.php.net/manual/zh/function.debug-backtrace.php

https://www.php.net/manual/zh/function.debug-print-backtrace.php

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 4月7日

一些简单的错误处理函数(二)

接下来,我们继续学习 PHP 中的错误处理函数。上次学习过的函数是错误信息的获取、设置、发送等功能,今天学习的内容主要是关于错误的捕获相关的函数。

set_error_handler()

首先是大家可能会接触过的一个函数,它可以用来捕获一些错误的信息。如果我们需要统一处理一些错误,比如规定日志格式或者将错误信息发送到邮件中,一般会在入口文件的开头在全局范围内定义一个这个函数进行统一的处理。

echo $a; // Notice: Undefined variable: a ...
//  E_ERROR、 E_PARSE、 E_CORE_ERROR、 E_CORE_WARNING、 E_COMPILE_ERROR、 E_COMPILE_WARNING 不能处理
set_error_handler(function($errno, $errstr, $errfile, $errline){
    echo "Has Error:", $errno, ',', $errstr, ',', $errfile, ',', $errline, PHP_EOL; 
}, E_ALL | E_STRICT);

echo $a; // Has Error:8,Undefined variable: a ...

set_error_handler() 函数接收一个回调函数和一个错误接收的类型,它的函数签名是:

set_error_handler ( callable $error_handler [, int $error_types = E_ALL | E_STRICT ] ) : mixed

$error_handler是一个回调(匿名)函数,这个函数内部可以获取到错误的等级、信息、文件、行数等

handler ( int $errno , string $errstr [, string $errfile [, int $errline [, array $errcontext ]]] ) : bool

其中,$errcontext 已经在 PHP7.2 之后取消了。

$error_types,用于错误接收的类型,就像 error_reporting() 函数定义的错误类型一样,它用于控制 $error_handler 回调函数所能接收的错误的类型。

需要注意的是,这个函数无法处理 E_ERROR、 E_PARSE、 E_CORE_ERROR、 E_CORE_WARNING、 E_COMPILE_ERROR、 E_COMPILE_WARNING 这些类型的错误,也就是说,能够中断程序执行的错误它都无法捕获处理。

另外,在函数调用之前的错误是无法捕获到的,只有在函数调用之后的错误才能通过这个函数进行捕获处理。

restore_error_handler()

这个函数是用于还原之前的错误处理函数。比如我们在上面代码下添加这个函数,然后再次触发错误,错误将会使用回 PHP 的标准处理程序。

restore_error_handler();

echo $a; // Notice: Undefined variable: a ...

set_exception_handler()

学习了上面错误处理的函数后,从名称就可以看出,这个函数是用来处理异常的,它可以在全局范围内捕获异常。

set_exception_handler(function($ex){
    echo "Has Exception: " , $ex->getMessage(), PHP_EOL;
});

throw new Exception('Init Error');

它的函数签名是:

set_exception_handler ( callable $exception_handler ) : callable

只接收一个回调函数,回调函数中只有一个参数,是一个 Exception 类型的参数内容,就和 try...catch 中的 catch 块的参数一样。在 PHP7 以后接收到的是一个 Throwable 类型的参数。也就是说,它可以捕获到所有的错误和异常。

不过需要注意的是,在 PHP 中,所有的异常如果不进行处理,都会以中止脚本的错误形式返回报错信息。所以,在 set_exception_handler() 内处理完之后,脚本会中止运行。即使后面还有代码。所以,这个函数一般会用于全局捕获一些异常、错误后进行日志记录,它不具有 try...catch 的能力,让异常处理完成后还能继续进行其他操作。

restore_exception_handler()

同样的,异常捕获也是可以进行回退的。

set_exception_handler(function($ex){
    echo "Has Exception First: " , $ex->getMessage(), PHP_EOL;
});
set_exception_handler(function($ex){
    echo "Has Exception Second: " , $ex->getMessage(), PHP_EOL;
});

restore_exception_handler();

throw new Exception('Init Error Next'); // Has Exception First: Init Error Next

我们定义了两个 set_exception_handler() 函数,当使用 restore_exception_handler() 后,抛出的异常将会进入到第一个 set_exception_handler() 函数中进行处理。同理,restore_error_handler() 函数如果定义了多个错误处理,使用 restore_error_handler() 后也会一级一级回退,直到最终使用 PHP 的错误处理流程进行处理。

trigger_error()

最后,我们来看看如何手动抛出一个错误。就像上面例子中的 throw new Exception() 一样,PHP 也提供了一个用户自定义手动抛出错误的函数。

trigger_error("I'm Error One!"); // Notice: I'm Error One! 

它的函数签名是:

trigger_error ( string $error_msg [, int $error_type = E_USER_NOTICE ] ) : bool

$error_msg,也就是这个错误的具体信息,长度限制为 1024 个字节,如果超过了这个长度就会被截断。另外,如果这个信息中包含 HTML 实体标签的话,也不会直接转义,在网页显示时需要使用 htmlentities() 来进行处理。

$error_type参数则是指定报错的级别,默认是 E_USER_NOTICE ,而且它只支持 E_USER... 相关的错误信息。也就是说,它的参数只能填三个 E_USER_NOTICE 、 E_USER_WARNING 、 E_USER_ERROR 。

当然,我们手动抛出的错误信息也是可以通过 set_error_handler() 进行捕获的。

set_error_handler(function($errno, $errstr, $errfile, $errline){
    echo "Has Error:", $errno, ',', $errstr, ',', $errfile, ',', $errline, PHP_EOL; 
}, E_ALL | E_STRICT);
trigger_error("I'm Error One!"); // Has Error:1024,I'm Error One!,...
trigger_error("I'm Error Two!", E_USER_WARNING); // Has 512,I'm Error One!,...
trigger_error("I'm Error Three!", E_USER_ERROR); // Has 256,I'm Error One!,...

trigger_error("I'm Error Four!", E_WARNING); // Has Error:2,Invalid error type specified,...

最后一个 trigger_error() 我们使用了 E_WARNING 类型,可以看出直接返回的内容是 指定的错误类型无效 ,而不是我们定义的内容。也就是说,这里是这个函数的参数类型错误的报错,不是我们手动想抛出的错误了。

总结

其实 PHP 的错误处理函数也就这些了,在 PHP7 下面,大部分错误都可以通过异常捕获了,也就是说,PHP 越向后发展越会通过面向对象的方式来处理这些错误信息。不过,我们依然还是要对他们有全面的了解,毕竟在 PHP 的版本更新中,短时间还不会完全的摒弃错误处理的场景,在之后我们学习详细的异常处理相关的知识时,说不定还会再次见到它们的身影。

测试代码:

https://github.com/zhangyue0503/dev-blog/blob/master/php/202004/source/%E4%B8%80%E4%BA%9B%E7%AE%80%E5%8D%95%E7%9A%84%E9%94%99%E8%AF%AF%E5%A4%84%E7%90%86%E5%87%BD%E6%95%B0%EF%BC%88%E4%BA%8C%EF%BC%89.php

参考文档:

https://www.php.net/manual/zh/function.set-error-handler.php
https://www.php.net/manual/zh/function.set-exception-handler.php
https://www.php.net/manual/zh/function.restore-error-handler.php

https://www.php.net/manual/zh/function.restore-exception-handler.php

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 4月6日

一些简单的错误处理函数(一)

在之前的文章中,我们了解过了 PHP 中的异常和错误的区别,也简单地介绍了一些 PHP 中的错误处理函数。这次,我们再开两篇文章,详细的介绍一些 PHP 中错误处理相关的函数。想了解错误和异常相关内容的,请移步:

error_reporting()

这个函数相必大家多少都会接触过,就是定义 PHP 在运行时的错误处理机制。就像我们在进行调试时,往往需要设置一个 E_ALL 来显示全部的错误信息。

error_reporting(E_ALL);

这个函数只能定义为 PHP 内部提供的那些错误处理的常量,包括:

  • Fatal Error:致命错误(脚本终止运行)

    • E_ERROR // 致命的运行错误,错误无法恢复,暂停执行脚本
    • E_CORE_ERROR // PHP启动时初始化过程中的致命错误
    • E_COMPILE_ERROR // 编译时致命性错,就像由Zend脚本引擎生成了一个E_ERROR
    • E_USER_ERROR // 自定义错误消息。像用PHP函数trigger_error(错误类型设置为:E_USER_ERROR)
  • Parse Error:编译时解析错误,语法错误(脚本终止运行)

    • E_PARSE //编译时的语法解析错误
  • Warning Error:警告错误(仅给出提示信息,脚本不终止运行)

    • E_WARNING // 运行时警告 (非致命错误)。
    • E_CORE_WARNING // PHP初始化启动过程中发生的警告 (非致命错误) 。
    • E_COMPILE_WARNING // 编译警告
    • E_USER_WARNING // 用户产生的警告信息
  • Notice Error:通知错误(仅给出通知信息,脚本不终止运行)

    • E_NOTICE // 运行时通知。表示脚本遇到可能会表现为错误的情况.
    • E_USER_NOTICE // 用户产生的通知信息。

当然,这个函数也是可以通过 php.ini 文件进行全局配置的,具体的配置方式这里不再赘述。包括 php.ini 文件的注释中也会有详细的说明。

error_get_last()

error_get_last() 函数则是指的返回我们最后一次的错误信息。它返回的是一个数组,里面会包含错误信息的"type"、"message"、"file"、"line"信息,方便我们查看错误的具体发生位置及内容。

echo $a; // Notice: Undefined variable: a
print_r(error_get_last());
// Array
// (
//     [type] => 8
//     [message] => Undefined variable: a
//     [file] => /Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/一些简单的错误处理函数(一).php
//     [line] => 5
// )
echo $b;
print_r(error_get_last()); // 不会打印$a的问题
// Array
// (
//     [type] => 8
//     [message] => Undefined variable: b
//     [file] => /Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/一些简单的错误处理函数(一).php
//     [line] => 17
// )

echo $a;
echo $b;
print_r(error_get_last()); // 同样只会打印$b的问题

需要注意的是,它只返回最后一个错误的信息。比如上面示例中最后一段中的 echo $a; 和 echo $b; 都会产生错误,但最终打印出来的只是 echo $b; 所产生的错误信息。

error_clear_last

从名字就可以看出,这个函数的作用是清除最后一次的错误信息。也就是说,如果在发生错误的代码之后调用了这个函数, error_get_last() 就不会打印任何内容了。

echo $a; // Notice: Undefined variable: a
error_clear_last();
print_r(error_get_last()); // 不会输出

error_log

最后我们来看看错误日志记录的一个函数。它不仅可以将日志记录到日志文件中,还可以直接发邮件。

error_log("Test Error One!");
// php.ini 中定义的 error_log 文件
// [22-Apr-2020 09:04:34 Asia/Shanghai] Test Error One!

error_log("Test Error One!", 1, "423257356@qq.com");

echo $a;
error_log(base64_encode(json_encode(error_get_last())), 1, "423257356@qq.com");

第一段我们只有一个参数,所以错误信息将直接记录到 php.ini 文件中所定义的错误日志中。而后面两段则是将内容发送到一个邮箱中。

这个函数的声明形式是:

error_log ( string $message [, int $message_type = 0 [, string $destination [, string $extra_headers ]]] ) : bool
  • $message,错误信息内容,文本形式
  • $message_type,错误发送到何处,默认0系统日志文件,1为发送到 $destination 定义的邮件地址,3发送到 $destination 定义的邮件地址并且 $message 不会被当作新的一行,4发送到SAPI的日志处理程序中
  • $destination,一般为邮件地址
  • $extra_headers,额外的邮件头,在 $message_type 为1时有用

这个函数需要注意的一点是, $message 内容不能有 null 或者其他可能截断字符的符号。所以我们的测试代码中,发送 error_get_last() 内容时我们不仅给他转成了 json ,而且还加了一层 base64 编码,这样才能保证内容的正常发送。

总结

这篇文章主要就是介绍了这几个针对错误情况发生时的处理函数。比较有惊喜的是 error_log() 这个函数,它不需要过多的配置,直接就可能通过 PHP 自带的 mail 进行邮件发送。或许在我们的生产环境中可以尝试用来来进行一些错误的监听跟踪哦!!

测试代码:

https://github.com/zhangyue0503/dev-blog/blob/master/php/202004/source/%E4%B8%80%E4%BA%9B%E7%AE%80%E5%8D%95%E7%9A%84%E9%94%99%E8%AF%AF%E5%A4%84%E7%90%86%E5%87%BD%E6%95%B0%EF%BC%88%E4%B8%80%EF%BC%89.php

参考文档:

https://www.php.net/manual/zh/function.error-reporting.php
https://www.php.net/manual/zh/function.error-get-last.php
https://www.php.net/manual/zh/function.error-clear-last.php
https://www.php.net/manual/zh/function.error-log.php

===========

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 4月2日

我们也有自带的缓存系统:PHP的APCu扩展

想必大家都使用过 memcached 或者 redis 这类的缓存系统来做日常的缓存,或者用来抗流量,或者用来保存一些常用的热点数据,其实在小项目中,PHP 也已经为我们准备好了一套简单的缓存系统,完全能够应付我们日常普通规模站点的开发。这一套扩展就是 APCu 扩展。

APCu 扩展

APCu 扩展是 APC 扩展的升级,APC 扩展已经不维护了。这两套扩展其实都是基于 opcode caching 。也就是 PHP 自身的 opcode 来实现的缓存能力。

APCu 的安装就和普通的 PHP 扩展一样,非常简单,最主要的是这个扩展还非常的小。不管下载还是安装都是秒级可以完成的。所以说能够非常方便的应用于小规模的项目,而且是 PHP 原生支持的,不需要额外的端口之类的配置。

方法说明

缓存系统一般都会有的增加、删除、查询、自增等功能都在 APCu 扩展中有对应的实现。

  • apcu_add — 创建一个新的缓存
  • apcu_cache_info — 查看 APCu 的全部缓存信息
  • apcu_cas — 更新一个缓存的值为新值
  • apcu_clear_cache — 清除全部的缓存
  • apcu_dec — 自减缓存值
  • apcu_delete — 删除一个缓存的内容
  • apcu_enabled — 当前环境下是否启用 APCu 缓存
  • apcu_entry — 原子地生成一个缓存实体
  • apcu_exists — 检查缓存是否存在
  • apcu_fetch — 查询缓存
  • apcu_inc — 自增缓存值
  • apcu_sma_info — 查询缓存的共享内存信息
  • apcu_store — 保存一个缓存

使用演示

apcu_add("int", 1);
apcu_add("string", "I'm String");
apcu_add("arr", [1,2,3]);

class A{
    private $apc = 1;
    function test(){
        echo "s";
    }
}

apcu_add("obj", new A);

var_dump(apcu_fetch("int"));
var_dump(apcu_fetch("string"));
var_dump(apcu_fetch("arr"));
var_dump(apcu_fetch("obj"));

正常的使用都是比较简单的,我们添加各种类型的数据都可以正常存入缓存。不过需要注意的是,我们可以直接保存对象进入 APCu 缓存中,不需要将它序列化或者JSON成字符串,系统会自动帮我们序列化。

apcu_add(string \$key , mixed $var [, int $ttl = 0 ]) 方法就是普通的添加一个缓存,$ttl 可以设置过期时间,也是以秒为单位,如果不设置就是长期有效的。注意,APCu 的缓存时限在一次 CLI 中有效,再调用一次 CLI 取不到上次 CLI 中设置的缓存内容。而在 PHP-FPM 中,重启 PHP-FPM 或 FastCGI 之后缓存会失效。

接下来我们重点测试一下几个不太常见的方法。

apcu_cas("int", 1, 2);
var_dump(apcu_fetch("int"));

// Warning  apcu_cas() expects parameter 2 to be int
apcu_cas("string", "I'm String", "I'm  New String");

apcu_cas(string $key , int $old , int $new) 是将一个 $old 值修改为 $new 值,它只能修改数字类型的内容,如果是字符串的修改会报错。这个函数有什么优势呢?它最大的优势是原子性的,也就是不受高并发的影响。与之类似的是 apcu_store(string $key , mixed $var [, int $ttl = 0 ]) 方法,不过这个方法只是简单的修改一个缓存的内容,如果这个缓存的键不存在的话,就新建一个,它不受类型的限制,当然也不具有原子性。

apcu_entry("entry", function($key){
    return "This is " . $key;
});
var_dump(apcu_fetch("entry"));

apcu_entry(string $key , callable $generator [, int $ttl = 0 ]) 这个函数的作用是如果 $key 这个缓存不存在,则执行 $generator 这个匿名函数,并将 $key 做为键值传递进去,然后生成也就是 return 一个内容做为这个缓存的值。

var_dump(apcu_cache_info());

最后,如果我们想查看当前系统中的所有 APCu 缓存信息的时候,直接用这个 apcu_cache_info() 函数即可。

总结

当缓存中的数据非常多时,它还提供了一个 APCUIterator 迭代器方便我们进行缓存信息的循环查询及相关统计。总之,这一套系统是非常方便的一套小规模的缓存系统,在日常开发中完全可以尝试用到一些小功能上。

测试代码:

https://github.com/zhangyue0503/dev-blog/blob/master/php/202004/source/%E6%88%91%E4%BB%AC%E4%B9%9F%E6%9C%89%E8%87%AA%E5%B8%A6%E7%9A%84%E7%BC%93%E5%AD%98%E7%B3%BB%E7%BB%9F%EF%BC%9APHP%E7%9A%84APCu%E6%89%A9%E5%B1%95.php

参考文档:

https://www.php.net/manual/zh/function.apcu-entry.php

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 1

硬核项目经理 发布了文章 · 4月1日

让PHP能够调用C的函数-FFI扩展

在大型公司中,一般会有很我编程语言的配合。比如说让 Java 来做微服务层,用 C++ 来进行底层运算,用 PHP 来做中间层,最后使用 JS 展现效果。这些语言间的配合大部分都是通过 RPC 来完成,或者直接将数据入库再使用不同的语言来取用。那么,我们 PHP 的代码能否直接调用这些语言呢?其实,PHP 还真为我们准备了一个可以直接调用 C 语言的扩展库,并且这个扩展库还是已经默认内置在 PHP 中了,它就是 FFI 扩展。

什么是 FFI

FFI , Foreign Function Interface,外部函数接口。这个扩展允许我们加载一些公共库(.dll、.so),其实也就是可以调用一些 C 的数据结构及函数。它已经是随 PHP 源码发布的一个扩展了,在编译的时候可以加上 --with-ffi 来直接编译到 PHP 程序中。

我们这里已经是编译好的 PHP ,所以我们直接找到这个扩展,进行简单的扩展安装步骤就可以安装完成。

cd php-7.4.4/ext/ffi/
phpize
./configure
make && make install

安装完成后记得在 php.ini 文件中打开扩展。关于这个扩展需要注意的一点是,它有一个配置项为 ffi.enable ,默认情况下这个配置项的值是 "preload" ,仅在 CLI SAPI 环境下启用 FFI 的能力。当然,我们也可以修改为 "true" 或 "false" 来开启和关闭它。设定为 "true" 将使得这个扩展在任何环境下都启用。

使用 FFI 调用 C 的函数

接下来,简单地看一下它是如何调用 C 的函数的。

// 创建一个 FFI 对象,加载 libc 并且导入 printf 函数
$ffi_printf = FFI::cdef(
    "int printf(const char *format, ...);", // C 的定义规则
    "libc.so.6"); // 指定 libc 库
// 调用 C 的 printf 函数
$ffi_printf->printf("Hello %s!\n", "world"); // Hello World

// 加载 math 并且导入 pow 函数
$ffi_pow = FFI::cdef(
    "double pow(double x, double y);", 
    "libboost_math_c99.so.1.66.0");
// 这里调用的是 C 的 pow 函数,不是 PHP 自己的
echo $ffi_pow->pow(2,3), PHP_EOL; // 8

我们创建了两个对象,分别调用了 C 的 printf() 和 pow() 函数。FFI::cdef() 是用于创建一个 FFI 对象,它接收两个参数,一个是包含常规C语言(类型、结构、函数、变量等)声明序列的字符串。实际上,这个字符串可以从C头文件复制粘贴。而另一个参数则是要加载并定义链接的共享库文件的名称。也就是我们需要的 .dll 或 .so 文件,它与我们声明字符串是对应的,比如在 libc.so.6 中并没有 pow() 这类的计算函数,所以我们就要找到 math 相关的 C 语言计算函数库。

定义变量和数组

当然,FFI 也是可以定义变量和数组的。

// 创建一个 int 变量
$x = FFI::new("int");
var_dump($x->cdata); // int(0)

// 为变量赋值
$x->cdata = 5;
var_dump($x->cdata); // int(5)

// 计算变量
$x->cdata += 2;
var_dump($x->cdata); // int(7)


// 结合上面的两个 FFI 对象操作

echo "pow value:", $ffi_pow->pow($x->cdata, 3), PHP_EOL;
// pow value:343
$ffi_printf->printf("Int Pow value is : %f\n", $ffi_pow->pow($x->cdata, 3));
// Int Pow value is : 343.000000


// 创建一个数组
$a = FFI::new("long[1024]");
// 为数组赋值
for ($i = 0; $i < count($a); $i++) {
    $a[$i] = $i;
}
var_dump($a[25]); // int(25)

$sum = 0;
foreach ($a as $n) {
    $sum += $n;
}
var_dump($sum); // int(523776)

var_dump(count($a)); // int(1024) 数组长度
var_dump(FFI::sizeof($a)); // int(8192),内存大小

使用 FFI::new() 函数来创建一个 C 的数据结构,也就是变量声明,这些变量的内容将保存在 cdata 属性中。而数组则直接就可以操作这个函数的返回值。当然,当我们要结束使用的时候,还是需要使用 FFI::free() 来释放变量的,就和 C 语言的开发一样。

总结

是不是感觉很高大上?但是请注意哦,FFI 调用的 C 函数并没有 PHP 本身去调用的效率高。比如这种 pow() 函数,使用 PHP 自身的效率更好。而且,FFI 扩展虽说已经是跟随 PHP 同步发布的扩展,但它还是处于实验性质的。也就是说,这个扩展是为未来可能用到的其它功能准备的,而且还有很多不确定性。所以在生产环境中如果需要合适类似的功能的话,那么还是要做更多的深入调研哦。

测试代码:
https://github.com/zhangyue0503/dev-blog/blob/master/php/202004/source/%E8%AE%A9PHP%E8%83%BD%E5%A4%9F%E8%B0%83%E7%94%A8C%E7%9A%84%E5%87%BD%E6%95%B0-FFI%E6%89%A9%E5%B1%95.php

参考文档:
https://www.php.net/manual/zh/intro.ffi.php
https://www.php.net/manual/zh/ffi.examples-basic.php

===========

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

认证与成就

  • 获得 7 次点赞
  • 获得 0 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 0 枚铜徽章

擅长技能
编辑

(゚∀゚ )
暂时没有

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2019-09-21
个人主页被 2.1k 人浏览