Introducing the new features and performance optimization of php7 and PHP5 comparison

New features and performance optimizations compared between php7 and PHP5

1. Abstract syntax tree (AST) )

AST plays the role of a middleware in the PHP compilation process, replacing the original method of spitting out opcode directly from the interpreter, decoupling the interpreter (parser) and the compiler (compliler), which can reduce Some Hack code, at the same time, makes the implementation easier to understand and maintain

Recommended (free):PHP7

2. Natice TLS:

Thread data sharing security, open a global thread to use as data shared memory space

3. Specify parameter return value type

4. Changes in zval structure

5. Exception handling

PHP 5’s try...catch...finally cannot handle traditional Errors, you would usually consider hacking them with set_error_handler() if necessary. However, there are still many error types that cannot be caught by set_error_handler()

PHP 7 introduced the Throwable interface. Both errors and exceptions implement Throwable. Throwable cannot be implemented directly, but the \Exception and \Error classes can be extended. You can use Throwable to catch exceptions and errors. \Exception is the base class for all PHP and user exceptions; \Error is the base class for all internal PHP errors.

6. New parameter parsing method

7. Hashtable changes

buckets and Zvals no longer allocate memory separately. Eliminated a lot of useless redundancy.

8. Null Coalesce Operator

Directly to the example:

$name = $name ?? "NoName";  // 如果$name有值就取其值，否则设$name成"NoName"

9. Spaceship Operator Operator) (combined comparison operator)

Form: (expr) <=> (expr)

If the left operand is smaller, then - 1; if the left and right operands are equal, 0 is returned; if the left operand is larger, 1 is returned.

$name = ["Simen", "Suzy", "Cook", "Stella"];
usort($name, function ($left, $right) {
    return $left <=> $right;
});
print_r($name);

10. Constant Array

PHP 7 previously only allowed the use of constant arrays in classes/interfaces, but now PHP 7 also supports non-classes/interfaces An array of ordinary constants.

define("USER", [
  "name"  => "Simen",
  "sex"   => "Male",
  "age"   => "38",
  "skill" => ["PHP", "MySQL", "C"]
]);
// USER["skill"][2] = "C/C++";  // PHP Fatal error:  Cannot use temporary expression in write context in...

11. Unified variable syntax

$goo = [
    "bar" => [
        "baz" => 100,
        "cug" => 900
    ]
];

$foo = "goo";

$$foo["bar"]["baz"];  // 实际为：($$foo)['bar']['baz']; PHP 5 中为：${$foo['bar']['baz']};
                      // PHP 7 中一个笼统的判定规则是，由左向右结合。

12. Throwable interface

This is a worthwhile addition introduced by PHP 7 The anticipated new features will greatly enhance PHP's error handling capabilities. PHP 5's try ... catch ... finally can't handle traditional errors, so you'll usually consider hacking it with set_error_handler() if necessary. But there are still many error types that set_error_handler() cannot catch. PHP 7 introduces the Throwable interface. Errors and exceptions implement Throwable. Throwable cannot be implemented directly, but the \Exception and \Error classes can be extended. You can use Throwable to catch exceptions and errors. \Exception is the base class for all PHP and user exceptions; \Error is the base class for all internal PHP errors.

$name = "Tony";
try {
    $name = $name->method();
} catch (\Error $e) {
    echo "出错消息 --- ", $e->getMessage(), PHP_EOL;
}

try {
    $name = $name->method();
} catch (\Throwable $e) {
    echo "出错消息 --- ", $e->getMessage(), PHP_EOL;
}

try {
    intp(5, 0);
} catch (\pisionByZeroError $e) {
    echo "出错消息 --- ", $e->getMessage(), PHP_EOL;
}

13. Use combination statement

use combination statement can reduce the input redundancy of use.

use PHPGoodTaste\Utils\{
    Util,
    Form,
    Form\Validation,
    Form\Binding
};

14. Capture multiple types of exceptions/errors at one time

PHP 7.1 has added a new syntax for capturing multiple types of exceptions/errors - through vertical bars" |" to achieve.

try {
      throw new LengthException("LengthException");
    //   throw new pisionByZeroError("pisionByZeroError");
    //   throw new Exception("Exception");
} catch (\pisionByZeroError | \LengthException $e) {
    echo "出错消息 --- ", $e->getMessage(), PHP_EOL;
} catch (\Exception $e) {
    echo "出错消息 --- ", $e->getMessage(), PHP_EOL;
} finally {
    // ...
}

15. Changes in visibility modifiers

Class constants before PHP 7.1 are not allowed to add visibility modifiers. At this time, the visibility of class constants is equivalent To the public. PHP 7.1 adds visibility modifier support for class constants. In general, the usage range of visibility modifiers is as follows:

• Function/method: public, private, protected, abstract, final
• Class: abstract, final
• Properties/variables: public, private, protected
• Class constants: public, private, protected

class YourClass 
{
    const THE_OLD_STYLE_CONST = "One";

    public const THE_PUBLIC_CONST = "Two";
    private const THE_PRIVATE_CONST = "Three";
    protected const THE_PROTECTED_CONST = "Four";
}

iterable pseudo-type

PHP 7.1 introduced the iterable pseudo-type. The iterable type applies to arrays, generators, and objects that implement Traversable, which is a reserved class name in PHP.

$fn = function (iterable $it) : iterable {
    $result = [];
    foreach ($it as $value) {
        $result[] = $value + 1000;
    }
    return $result;
};

$fn([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

Nullable Type

PHP 7.1 introduces nullable types. Look at one of the gimmick features of the emerging Kotlin programming language is nullable types. PHP is becoming more and more like a "strongly typed language". For mandatory requirements of the same type, you can set whether it is nullable.

$fn = function (?int $in) {
    return $in ?? "NULL";
};

$fn(null);
$fn(5);
$fn();  // TypeError: Too few arguments to function {closure}(), 0 passed in ...

Void return type

PHP 7.1 introduced the Void return type.

function first(): void {
    // ...
}

function second(): void {
    // ...
    return;
}

The above is the detailed content of Introducing the new features and performance optimization of php7 and PHP5 comparison. For more information, please follow other related articles on the PHP Chinese website!