PHP程序运行流程：语法分析（Parse）与抽象语法树（AST），PHP-Parser

最新推荐文章于 2024-05-31 09:52:42 发布

raoxiaoya

最新推荐文章于 2024-05-31 09:52:42 发布

阅读量1.8k

点赞数

分类专栏： PHP

本文链接：https://blog.csdn.net/raoxiaoya/article/details/112471271

版权

PHP 专栏收录该内容

240 篇文章 5 订阅

订阅专栏

什么是抽象语法树？

在 PHP5中，从 php 脚本到 Opcodes 的执行的过程是：

Lexing：词法扫描分析，将源文件转换成 Token 流；
Parsing：语法分析，在此阶段生成 Opcodes。

PHP7 中在语法分析阶段不再直接生成 opcodes，而是先生成 AST，所以过程多了一步：

Lexing：词法扫描分析，将源文件转换成 Token 流；
Parsing：语法分析，从 Token 流生成抽象语法树 AST (Abstract Syntax Tree)；
Compilation：从抽象语法树生成 Opcodes。

经过了词法分析得到 Tokens 数组后，就需要进行语法分析了，也就是 Parse 的过程，它会将词法分析出来的数组转换成树形的形式，同时，验证语法。语法如果有错的话，抛出语法错误。

之所以说是抽象的，是因为抽象语法树并不会表示出真实语法出现的每一个细节，不是 100% 与源码匹配的，比如说，嵌套括号被隐含在树的结构中，并没有以节点的形式呈现，与之相对的是，解析器100%覆盖所有代码结构生成树叫做 CST（具体语法树）。抽象语法树并不依赖于源语言的语法，也就是说语法分析阶段所采用的上下文无文法【文法是用于描述语言的语法结构的形式规则。任何一种语言都有它自己的文法,不管它是机器语言还是自然语言。】，因为在写文法时，经常会对文法进行等价的转换（消除左递归，回溯，二义性等），这样会给文法分析引入一些多余的成分，对后续阶段造成不利影响，甚至会使合个阶段变得混乱。因些，很多编译器经常要独立地构造语法分析树，为前端，后端建立一个清晰的接口。

实际上在PHP7之前，没有 AST 的过程，是直接将 Tokens 做 Parse 处理生成 Opcodes，那么为什么要引入 AST 呢。因为 AST 是编程语言的基础设施，绝大部分语言都有，并且引入 AST 可以统一规范语法，扩展性和可优化性更强。

执行时间和内存消耗

从以上的步骤来看，这比之前的过程还多了一步，所以按常理来说这反而会增加程序的执行时间和内存的使用。但事实上内存的使用确实增加了，但是执行时间上却有所降低。

以下结果是使用小（代码大约 100 行）、中（大约 700 行）、大（大约 2800 行）三个脚本分别进行测试得到的

每个文件编译 100 次的执行时间（注意文章的测试结果时间是 14 年，PHP7 还叫 PHP-NG 的时候）：

单次编译中的内存峰值：

单次编译的测试结果可能并不能代表实际使用的情况，以下是使用 PhpParser 进行完整项目测试得到的结果：

测试表明，使用 AST 之后程序的执行时间整体上大概有 10% 到 15% 的提升，但是内存消耗也有增加，在大文件单次编译中增加明显，但是在整个项目执行过程中并不是很严重的问题。

还有注意的是以上的结果都是在没有 Opcache 的情况下，生产环境中打开 Opcache 的情况下，内存的消耗增加也不是很大的问题。

语义上的改变

如果仅仅是时间上的优化，似乎也不是使用 AST 的充足理由。其实实现 AST 并不是基于时间优化上的考虑，而是为了解决语法上的问题。下面来看一下语义上的一些变化。

yield 不需要括号

在 PHP5 的实现中，如果在一个表达式上下文（例如在一个赋值表达式的右侧）中使用 yield，你必须在 yield 申明两边使用括号：

$result = yield fn();   // 不合法的
$result = (yield fn()); // 合法的

这种行为仅仅是因为 PHP5 的实现方式的限制，在 PHP7 中，括号不再是必须的了。所以下面这些写法也都是合法的：

$result = yield;
$result = yield $v;
$result = yield $k => $v;

当然了，还得遵循 yield 的应用场景才行。

括号不影响行为

在 PHP5 中，

($foo)['bar'] = 'baz';
# PHP Parse error: Syntax error, unexpected '[' on line 1

但是在 PHP7 中，两种写法表示同样的意思。

同样，如果函数的参数被括号包裹，类型检查存在问题，在 PHP7 中这个问题也得到了解决：

function func() {
    return [];
}
 
function byRef(array &$a) {
}

byRef((func()));

以上代码在 PHP5 中不会告警，除非使用 byRef(func()) 的方式调用，但是在 PHP7 中，不管 func() 两边有没有括号都会产生以下错误：

PHP Strict standards:  Only variables should be passed by reference ...

list() 的变化

list 关键字的行为改变了很多。list 给变量赋值的顺序（等号左右同时的顺序）以前是从右至左，现在是从左到右：

list($array[], $array[], $array[]) = [1, 2, 3];
var_dump($array);
// PHP5: $array = [3, 2, 1]
// PHP7: $array = [1, 2, 3]
# 注意这里的左右的顺序指的是等号左右同时的顺序，
# list($a, $b) = [1, 2] 这种使用中 $a == 1, $b == 2 是没有疑问的。

产生上面变化的原因正是因为在 PHP5 的赋值过程中，3 会最先被填入数组，1 最后，但是现在顺序改变了。

同样的变化还有：

$a = [1, 2];
list($a, $b) = $a;
// PHP5: $a = 1, $b = 2
// PHP7: $a = 1, $b = null + "Undefined index 1"

这是因为在以前的赋值过程中 $b 先得到 2，然后 $a 的值才变成1，但是现在 $a 先变成了 1，不再是数组，所以 $b 就成了null。

list 现在只会访问每个偏移量一次

list(list($a, $b)) = $array;
// PHP5:
$b = $array[0][1];
$a = $array[0][0];
// PHP7:
// 会产生一个中间变量，得到 $array[0] 的值
$_tmp = $array[0];
$a = $_tmp[0];
$b = $_tmp[1];

空的 list 成员现在是全部禁止的，以前只是在某些情况下：

list() = $a;           // 不合法
list($b, list()) = $a; // 不合法
foreach ($a as list()) // 不合法 (PHP5 中也不合法)

引用赋值的顺序

引用赋值的顺序在 PHP5 中是从右到左的，现在时从左到右：

$obj = new stdClass;
$obj->a = &$obj->b;
$obj->b = 1;
var_dump($obj);
// PHP5:
object(stdClass)#1 (2) {
 ["b"] => &int(1)
 ["a"] => &int(1)
}

// PHP7:
object(stdClass)#1 (2) {
 ["a"] => &int(1)
 ["b"] => &int(1)
}

__clone 方法可以直接调用

现在可以直接使用 $obj->__clone() 的写法去调用 __clone 方法。 __clone 是之前唯一一个被禁止直接调用的魔术方法，之前你会得到一个这样的错误：

Fatal error:Cannot call __clone() method on objects -use 'clone $obj' instead in...

变量语法一致性

AST 也解决了一些语法一致性的问题，这些问题是在另外一个 RFC 中被提出的：https://wiki.php.net/rfc/uniform_variable_syntax.

在新的实现上，以前的一些语法表达的含义和现在有些不同，具体的可以参照下面的表格：

整体上还是以前的顺序是从右到左，现在从左到右，同时也遵循括号不影响行为的原则。这些复杂的变量写法是在实际开发中需要注意的。

PHP-Parser

PHP-Parser的项目主页是 https://github.com/nikic/PHP-Parser。可以对多版本的PHP进行完美解析，生成一颗抽象语法树。

我们先来看看 PHP AST 是什么样的。

composer require nikic/php-parser

code.php

<?php

test();

function test() {
    $tt = 0;
    $temp = funa($tt);
    $res = fun1($temp);
    var_dump($res);
}

function funa(int $a): int {
    $a++;
    return funb($a);
}
function funb(int $a): int {
    $a++;
    return func($a);
}
function func(int $a): int {
    $a++;
    return $a;
}

function fun1($x): int {
    return $x * $x;
}

test-parser.php

<?php

require './vendor/autoload.php';

use PhpParser\Error;
use PhpParser\NodeDumper;
use PhpParser\ParserFactory;

$code = file_get_contents('./code.php');

/*
	ParserFactory::PREFER_PHP7：优先解析PHP7，如果PHP7解析失败则将脚本解析成PHP5
	ParserFactory::PREFER_PHP5：优先解析PHP5，如果PHP5解析失败则将脚本解析成PHP7
	ParserFactory::ONLY_PHP7：只解析成PHP7
	ParserFactory::ONLY_PHP5：只解析成PHP5
*/
$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
try {
    $ast = $parser->parse($code);
} catch (Error $error) {
    echo "Parse error: {$error->getMessage()}\n";
    return;
}

$dumper = new NodeDumper;
echo $dumper->dump($ast) . "\n";

运行示例

$ php test-parser.php

array(
    0: Stmt_Expression(
        expr: Expr_FuncCall(
            name: Name(
                parts: array(
                    0: test
                )
            )
            args: array(
            )
        )
    )
    1: Stmt_Function(
        attrGroups: array(
        )
        byRef: false
        name: Identifier(
            name: test
        )
        params: array(
        )
        returnType: null
        stmts: array(
            0: Stmt_Expression(
                expr: Expr_Assign(
                    var: Expr_Variable(
                        name: tt
                    )
                    expr: Scalar_LNumber(
                        value: 0
                    )
                )
            )
            1: Stmt_Expression(
                expr: Expr_Assign(
                    var: Expr_Variable(
                        name: temp
                    )
                    expr: Expr_FuncCall(
                        name: Name(
                            parts: array(
                                0: funa
                            )
                        )
                        args: array(
                            0: Arg(
                                name: null
                                value: Expr_Variable(
                                    name: tt
                                )
                                byRef: false
                                unpack: false
                            )
                        )
                    )
                )
            )
            2: Stmt_Expression(
                expr: Expr_Assign(
                    var: Expr_Variable(
                        name: res
                    )
                    expr: Expr_FuncCall(
                        name: Name(
                            parts: array(
                                0: fun1
                            )
                        )
                        args: array(
                            0: Arg(
                                name: null
                                value: Expr_Variable(
                                    name: temp
                                )
                                byRef: false
                                unpack: false
                            )
                        )
                    )
                )
            )
            3: Stmt_Expression(
                expr: Expr_FuncCall(
                    name: Name(
                        parts: array(
                            0: var_dump
                        )
                    )
                    args: array(
                        0: Arg(
                            name: null
                            value: Expr_Variable(
                                name: res
                            )
                            byRef: false
                            unpack: false
                        )
                    )
                )
            )
        )
    )
    2: Stmt_Function(
        attrGroups: array(
        )
        byRef: false
        name: Identifier(
            name: funa
        )
        params: array(
            0: Param(
                attrGroups: array(
                )
                flags: 0
                type: Identifier(
                    name: int
                )
                byRef: false
                variadic: false
                var: Expr_Variable(
                    name: a
                )
                default: null
            )
        )
        returnType: Identifier(
            name: int
        )
        stmts: array(
            0: Stmt_Expression(
                expr: Expr_PostInc(
                    var: Expr_Variable(
                        name: a
                    )
                )
            )
            1: Stmt_Return(
                expr: Expr_FuncCall(
                    name: Name(
                        parts: array(
                            0: funb
                        )
                    )
                    args: array(
                        0: Arg(
                            name: null
                            value: Expr_Variable(
                                name: a
                            )
                            byRef: false
                            unpack: false
                        )
                    )
                )
            )
        )
    )
    3: Stmt_Function(
        attrGroups: array(
        )
        byRef: false
        name: Identifier(
            name: funb
        )
        params: array(
            0: Param(
                attrGroups: array(
                )
                flags: 0
                type: Identifier(
                    name: int
                )
                byRef: false
                variadic: false
                var: Expr_Variable(
                    name: a
                )
                default: null
            )
        )
        returnType: Identifier(
            name: int
        )
        stmts: array(
            0: Stmt_Expression(
                expr: Expr_PostInc(
                    var: Expr_Variable(
                        name: a
                    )
                )
            )
            1: Stmt_Return(
                expr: Expr_FuncCall(
                    name: Name(
                        parts: array(
                            0: func
                        )
                    )
                    args: array(
                        0: Arg(
                            name: null
                            value: Expr_Variable(
                                name: a
                            )
                            byRef: false
                            unpack: false
                        )
                    )
                )
            )
        )
    )
    4: Stmt_Function(
        attrGroups: array(
        )
        byRef: false
        name: Identifier(
            name: func
        )
        params: array(
            0: Param(
                attrGroups: array(
                )
                flags: 0
                type: Identifier(
                    name: int
                )
                byRef: false
                variadic: false
                var: Expr_Variable(
                    name: a
                )
                default: null
            )
        )
        returnType: Identifier(
            name: int
        )
        stmts: array(
            0: Stmt_Expression(
                expr: Expr_PostInc(
                    var: Expr_Variable(
                        name: a
                    )
                )
            )
            1: Stmt_Return(
                expr: Expr_Variable(
                    name: a
                )
            )
        )
    )
    5: Stmt_Function(
        attrGroups: array(
        )
        byRef: false
        name: Identifier(
            name: fun1
        )
        params: array(
            0: Param(
                attrGroups: array(
                )
                flags: 0
                type: null
                byRef: false
                variadic: false
                var: Expr_Variable(
                    name: x
                )
                default: null
            )
        )
        returnType: Identifier(
            name: int
        )
        stmts: array(
            0: Stmt_Return(
                expr: Expr_BinaryOp_Mul(
                    left: Expr_Variable(
                        name: x
                    )
                    right: Expr_Variable(
                        name: x
                    )
                )
            )
        )
    )
)

或者使用 vendor/bin/php-parse cocde.php 也是一样的。

同时，我们还可以将 AST 转换回 PHP Code：

<?php

require './vendor/autoload.php';

use PhpParser\Error;
use PhpParser\NodeDumper;
use PhpParser\ParserFactory;

$code = file_get_contents('./code.php');

$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
try {
    $ast = $parser->parse($code);
} catch (Error $error) {
    echo "Parse error: {$error->getMessage()}\n";
    return;
}

// $dumper = new NodeDumper;
// echo $dumper->dump($ast) . "\n";

$prettyPrinter = new PhpParser\PrettyPrinter\Standard;
$newCode = $prettyPrinter->prettyPrintFile($ast);
echo $newCode,PHP_EOL;

打印：

$ php test-parser.php
<?php

test();
function test()
{
    $tt = 0;
    $temp = funa($tt);
    $res = fun1($temp);
    var_dump($res);
}
function funa(int $a) : int
{
    $a++;
    return funb($a);
}
function funb(int $a) : int
{
    $a++;
    return func($a);
}
function func(int $a) : int
{
    $a++;
    return $a;
}
function fun1($x) : int
{
    return $x * $x;
}

并且你可以使用 builders 来编辑 AST 就像 PS 一样，然后输出的 PHP 代码就回被改变，的确很不错。

如果想持久化保存 AST 可以使用 json encode 或者 serialize 。

PHP Paser 是比反射更强大的工具，在工程上，普遍使用它生成模板代码，代码混淆 / 解密，代码格式化，AOP，生成的抽象语法树进行静态分析等。

使用参考：

PHP-Parser 主页。
代码混淆 https://xz.aliyun.com/t/8165
AOP编程 https://www.cnblogs.com/cshaptx4869/p/10654624.html

对于任何语言来说 AST 都是一个很好的工具，可以理解为它连接表现层和底层，比如对于PHP来说，PHP代码是表现层，Opcodes 是底层，如果你想发明一种语法，a ??? b 表示交换 a, b 的值，你可以在生成 AST 的时候实现。再比如 vue 是在 javascript 的基础上构建出来的语法，使用 vue-cli 来解释 vue 代码生成符合 javascript 规范的 AST ，之后调用 javascript 解析器便可以运行了。

其他阅读：

https://blog.csdn.net/cmdssd1/article/details/45716679
https://blog.csdn.net/huangpb123/article/details/84799198

raoxiaoya

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
PHP程序运行流程：语法分析（Parse）与抽象语法树（AST），PHP-Parser

什么是抽象语法树？在 PHP5中，从 php 脚本到 Opcodes 的执行的过程是：Lexing：词法扫描分析，将源文件转换成 Token 流；Parsing：语法分析，在此阶段生成 Opcodes。PHP7 中在语法分析阶段不再直接生成 opcodes，而是先生成 AST，所以过程多了一步：Lexing：词法扫描分析，将源文件转换成 Token 流；Parsing：语法分析，从 Token 流生成抽象语法树 AST (Abstract Syntax Tree)；Compilation
复制链接

扫一扫