Some introductions to the Abstract Syntax Tree (AST) in the new features of PHP7

This article shares with you some introduction to the Abstract Syntax Tree (AST) in the new features of PHP7. The content is very good. Friends in need can refer to it. I hope it can help everyone.

This article analyzes the changes brought about by the new feature of PHP7, Abstract Syntax Tree (AST). Share it with everyone for your reference, as follows:

Most of the content here is based on the RFC document of AST: https://wiki.php.net/rfc/abstractsyntaxtree, which is excerpted from the source document for ease of understanding. section is introduced.

This article will not tell you what an abstract syntax tree is. This needs to be understood by yourself. This article only describes some changes that AST brings to PHP.

New execution process

An important change in the core of PHP7 is the addition of AST. In PHP5, the execution process from php scripts to opcodes is:

1. Lexing: lexical scanning analysis, converting source files into token streams;

2. Parsing: Syntax analysis, op arrays are generated at this stage.

In PHP7, op arrays are no longer directly generated during the syntax analysis phase, but AST is generated first, so there is one more step in the process:

1. Lexing : Lexical scan analysis, convert the source file into a token stream;

2. Parsing: Syntax analysis, generate an abstract syntax tree from the token stream;

3. Compilation: Generate op arrays from abstract syntax trees.

Execution time and memory consumption

From the above steps, this is one more step than the previous process, so according to common sense, this will increase the program execution time and memory usage. But in fact, the memory usage has indeed increased, but the execution time has decreased.

The following results are obtained by testing three scripts: small (about 100 lines of code), medium (about 700 lines), and large (about 2800 lines). Test script: https://gist.github .com/nikic/289b0c7538b46c2220bc.

Execution time of compiling each file 100 times (note that the test results of the article are from 14 years, when PHP7 was still called PHP-NG):

	php-ng	php-ast	diff
SMALL	0.180s	0.160s	-12.5%
MEDIUM	1.492s	1.268s	-17.7%
LARGE	6.703s	5.736s	-16.9%

Memory peak in a single compilation:

##MEDIUM507kB643kB 26.8%LARGE1084kB1857kB 71.3%##The test results of a single compilation may not represent actual use , the following are the results of a complete project test using PhpParser:

	php-ng	php-ast	diff
SMALL	378kB	414kB	9.5 %

php-astdiffTIME25.5ms22.8ms-11.8%MEMORY2360kB2482kB 5.1%

Tests show that after using AST, the overall execution time of the program is improved by about 10% to 15%, but the memory consumption also increases. The increase is obvious in a single compilation of large files, but not during the entire project execution process. Very serious problem.

Also note that the above results are all without Opcache. When Opcache is turned on in a production environment, the increase in memory consumption is not a big problem.

Semantic changes

If it is just a time optimization, it does not seem to be a sufficient reason to use AST. In fact, the implementation of AST is not based on time optimization considerations, but to solve syntax problems. Let’s take a look at some changes in semantics.

yield does not require parentheses

In the PHP5 implementation, if yield is used in an expression context (such as on the right side of an assignment expression), you You must use parentheses on both sides of the yield declaration:

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

This behavior is only due to the implementation limitations of PHP5. In PHP7, parentheses are no longer necessary. Therefore, the following writing methods are also legal:

<?php
$result = yield;
$result = yield $v;
$result = yield $k => $v;

Of course, you must follow the application scenarios of yield.

Brackets do not affect behavior

In PHP5, ($foo)['bar'] = 'baz' and $foo['bar'] = 'baz' The two statements have different meanings. In fact, the former way of writing is illegal, and you will get the following error:

<?php
($foo)[&#39;bar&#39;] = &#39;baz&#39;;
# PHP Parse error: Syntax error, unexpected &#39;[&#39; on line 1

But in PHP7, the two ways of writing mean the same thing.

Similarly, if the parameters of the function are wrapped in parentheses, there is a problem with type checking. This problem has also been solved in PHP7:

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

The above code will not alarm in PHP5 unless # is used ##byRef(func()), but in PHP7, regardless of whether there are parentheses on both sides of func(), the following error will occur:

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

Changes in list() The behavior of the

list keyword has changed a lot. The order in which list assigns values ​​to variables (the order on the left and right of the equal sign at the same time) used to be from right to left, but now it is from left to right:

<?php
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 是没有疑问的。

The reason for the above change is precisely because in the assignment process of PHP5, 3 would be filled into the array first, 1 last, but now the order has changed.

The same changes are:

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

This is because in the previous assignment process, $b first got 2, and then the value of $a became 1, but now $a changes first It becomes 1 and is no longer an array, so $b becomes null.

list is now accessed only once per offset:

<?php
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];

Empty list members are now all prohibited, previously only under certain circumstances:

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

The order of reference assignment

The order of reference assignment is from right to left in PHP5, and now from left to right:

<?php
$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 method can be called directly

Now You can directly use

$obj->__clone() to call the __clone method. __clone is the only magic method that was previously prohibited from being called directly. Previously you would get an error like this:

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

Variable syntax consistency

AST also solves some syntax consistency issues, which were raised in another RFC: https:// wiki.php.net/rfc/uniform_variable_syntax.

In the new implementation, the meaning of some previous grammatical expressions is somewhat different from the current one. For details, please refer to the following table:

##php-ng

ExpressionPHP5PHP7##$$foo['bar']['baz']$foo->$bar['baz']$foo->$bar['baz']()##Foo::$bar['baz']()Foo::{$bar['baz']}()(Foo::$bar)['baz']() On the whole, the previous order is from right to left, now it is from left to right, and it also follows the principle that brackets do not affect behavior. These complex variable writing methods need to be paid attention to in actual development.

${$foo['bar']['baz']}	($$foo)['bar']['baz']
$foo->{$bar['baz']}	($foo->$bar)[' baz']
$foo->{$bar['baz']}( )	($foo->$bar)['baz']()

Related recommendations:

Five ways to teach you how to turn off php error echo information

FastCGI protocol in php source code Analysis

The above is the detailed content of Some introductions to the Abstract Syntax Tree (AST) in the new features of PHP7. For more information, please follow other related articles on the PHP Chinese website!