Un aperçu de toutes les nouvelles fonctionnalités de PHP 8 et des exemples de code

Aperçu de toutes les nouvelles fonctionnalités et exemples de code de PHP 8

La version officielle de PHP 8 sera bientôt publiée : RC3 sortira le 29 octobre, RC4 sortira le Le 12 novembre, et RC4 sortira le 26 novembre. La version officielle sera publiée le même jour (vous pouvez cliquer sur Calendrier de sortie de PHP 8 pour voir).

Il est donc temps de jeter un œil aux nouvelles fonctionnalités à venir dans PHP 8. Dans cet article nous allons vous montrer toutes les nouveautés de PHP 8 et les exemples de code correspondants.

Compiler et installer PHP 8

Afin d'exécuter facilement l'exemple de code, avant de commencer, nous pouvons compiler et installer la version PHP 8 RC2 localement :

// 0、下载解压源码
wget https://downloads.php.net/~pollita/php-8.0.0RC2.tar.gz
tar zxvf php-8.0.0RC2.tar.gz
cd php-8.0.0RC2

// 1、生成 configure 文件
./buildconf --force

// 2、配置构建流程（最小化安装）
./configure --prefix=/usr/local/php8 \
--with-config-file-path=/usr/local/php8 \
--enable-cli \
--without-iconv

// 3、构建 && 安装
make && sudo make install

// 4、拷贝配置文件
sudo cp php.ini-development /usr/local/php8/php.ini

Installer Une fois terminé, assurez-vous que PHP 8 a été installé avec succès en vérifiant la version :

Le système d'exploitation local est Mac. veuillez vous référer à ce tutoriel qui a déjà présenté JIT : Compilez et installez PHP 8 basé sur la machine virtuelle WSL.

Afin d'appeler facilement l'interpréteur PHP 8 CLI, j'ai configuré un alias pour celui-ci dans le fichier de configuration ZSH ~/.zshrc :

alias php8="/usr/local/php8/bin/php"

Puis exécutez source ~/.zshrc pour créer le L'alias ci-dessus prend effet. À l'avenir, vous pourrez appeler directement l'interpréteur PHP 8 CLI via php8 :

Créer un nouvel exemple de projet

Ensuite, nous créons un nouveau projet php8-demo dans PhpStorm pour stocker l'exemple de code de ce tutoriel, et ajustons le niveau de langage PHP et l'interpréteur de ligne de commande à PHP 8.0 afin que PhpStorm prenne en charge la dernière version de PHP (donc Vous ne savez pas comment le configurer ? Vous pouvez aller sur PhpStormLire le tutoriel) :

Ensuite, nous pourrons commencer notre voyage d'exploration des nouvelles fonctionnalités de PHP8.

Ajout de la prise en charge des types d'union

Les types d'union permettent à une variable d'avoir des valeurs de plusieurs types au lieu d'un (reportez-vous aux types d'union en langage C pour une bonne compréhension ).

Nous écrivons un exemple de code comme suit :

<?php declare(strict_types=1);

/**
 * 定义一个支持联合类型的 Number 类
 */ 
class Number {
    private int|float $number;
 
    public function setNumber(int|float $number): void {
        $this->number = $number;
    }
 
    public function getNumber(): int|float {
        return $this->number;
    }
}

/**
 * 我们可以传递浮点型和整型值到 Number 对象
 */
$number = new Number();

$number->setNumber(5);

var_dump($number->getNumber());

$number->setNumber(11.54);

var_dump($number->getNumber());

exit;

Le code ci-dessus fonctionne comme suit :

Nouvelle fonctionnalité WeakMap

WeakMap vous permet de créer un mappage d'objets avec des valeurs arbitraires (similaire à SplObjectStorage) sans empêcher les objets utilisés comme clés d'être récupérés. Si une clé d'objet est récupérée, la paire clé-valeur correspondante sera supprimée de la collection.

Cette nouvelle fonctionnalité est très utile car les développeurs n’ont pas à se soucier des fuites de mémoire dans leur code. La plupart des développeurs PHP ne s'en soucient probablement pas, mais vous devez faire attention à ce problème lorsque vous écrivez des processus de longue durée, comme lorsque vous utilisez ReactPHP pour une programmation pilotée par événements : avec WeakMap, l'objet référencé expirera automatiquement à son expiration. . J'ai ramassé les ordures.

Si vous faites la même chose dans un tableau, vous conserverez toujours une référence à l'objet, provoquant une fuite de mémoire.

Nous écrivons un exemple de code comme suit :

<?php declare(strict_types=1);


class FooBar {
    public WeakMap $cache;

    public function __construct() {
        $this->cache = new WeakMap();
    }

    public function getSomethingWithCaching(object $obj) {
        return $this->cache[$obj] ??= $this->computeSomethingExpensive($obj);
    }

    public function computeSomethingExpensive(object $obj) {
        var_dump("I got called");
        return rand(1, 100);
    }
}

$cacheObject = new stdClass;

$obj = new FooBar;
// "I got called" 只会打印一次
$obj->getSomethingWithCaching($cacheObject);
$obj->getSomethingWithCaching($cacheObject);

var_dump(count($obj->cache));

// 删除该对象后 WeakMap 会释放相应内存
unset($cacheObject);

var_dump(count($obj->cache));

exit;

Les résultats d'exécution correspondants sont les suivants :

Nouvelle exception ValueError

PHP 8 a introduit une nouvelle classe d'exception intégrée nommée ValueError, qui hérite de la classe de base Exception. Cette exception sera levée chaque fois que vous passerez une valeur à une fonction d'un type non valide. Avant PHP 8, une telle opération entraînerait un avertissement.

Ce qui suit est un exemple de code :

<?php declare(strict_types=1);

/**
 * 传递数组到 array_rand，类型正确，但是 array_rand 期望传入的是非空数组
 * 所以会抛出 ValueError 异常
 */
array_rand([], 0);

/**
 * json_decode 的深度参数必须是有效的正整型值，
 * 所以这里也会抛出 ValueError 异常
 */
json_decode(&#39;{}&#39;, true, -1);

Les résultats d'exécution sont les suivants :

Autoriser les paramètres variables lors du remplacement méthodes

Lorsque nous remplaçons une méthode de classe parent dans une sous-classe, n'importe quel nombre de paramètres peut désormais être remplacé par des paramètres variables, tant que les types de paramètres correspondants sont compatibles :

<?php declare(strict_types=1);

class A {
    public function method(int $many, string $parameters, $here) {

    }
}
class B extends A {
    public function method(...$everything) {
        var_dump($everything);
    }
}

$b = new B();
$b->method('i can be overwritten!');
exit;

Les résultats d'exécution sont les suivants :

Type de retour statique

En PHP 8, vous pouvez utiliser le mot-clé static pour identifier une méthode qui renvoie la classe à laquelle appartient actuellement la méthode, même si elle est héritée (liaison statique tardive) :

<?php declare(strict_types=1);

class Test {
    public function doWhatever(): static {
        // Do whatever.
        return $this;
    }
}

exit;

Le nom de classe littéral de l'objet

Disponible en PHP 8$object::class Obtenez le nom de classe de l'objet, et le résultat renvoyé est le même que get_class($object) :

<?php declare(strict_types=1);

class Test {

}

$test = new Test();

var_dump($test::class);
var_dump(get_class($test));
exit;

Le résultat en cours d'exécution est le suivant :

Ajustement de la syntaxe variable

new 和 instanceof 关键字现在可以被用于任意表达式：

<?php declare(strict_types=1);

class Foo {}
class Bar {}

$names = [&#39;Foo&#39;, &#39;Bar&#39;];
$class = new ($names[array_rand($names)]);

var_dump($class);

exit;

运行结果如下：

Stringable 接口

PHP 8 引入了新的 Stringable 接口，只要某个类实现了 __toString 方法，即被视作自动实现了 Stringable 接口（咋和 Go 接口实现有点像），而不必显式声明实现该接口：

<?php declare(strict_types=1);

class Foo {
    public function __toString() {
        return &#39;I am a class&#39;;
    }
}

$obj = new Foo;
var_dump($obj instanceof Stringable);

exit;

运行结果如下：

Trait 现在可以定义抽象私有方法

<?php declare(strict_types=1);


trait MyTrait {
    abstract private function neededByTheTrait(): string;

    public function doSomething() {
        return strlen($this->neededByTheTrait());
    }
}

class TraitUser {
    use MyTrait;

    // 支持该语法
    private function neededByTheTrait(): string { }

    // 不支持该语法 (错误的返回类型)
    // private function neededByTheTrait(): stdClass { }

    // 支持该语法 (非静态方法变成了静态方法)
    // private static function neededByTheTrait(): string { }
}

exit;

throw 现在可以被用作表达式

throw 语句现在可以用在只允许表达式出现的地方，例如箭头函数、合并运算符和三元运算符等：

<?php declare(strict_types=1);

$callable = fn() => throw new Exception();

$nullableValue = null;

// $value 是非空的
$value = $nullableValue ?? throw new \InvalidArgumentException();


exit;

参数列表中允许出现可选的尾部逗号

和数组中的尾部逗号类似，现在也可以在参数列表中定义一个尾部逗号：

<?php declare(strict_types=1);

function method_with_many_arguments(
    $a,
    $b,
    $c,
    $d,
) {
    var_dump("this is valid syntax");
}

method_with_many_arguments(
    1,
    2,
    3,
    4,
);

exit;

上述代码运行结果是正常的：

捕获异常而不存储到变量

现在可以编写 catch (Exception) 代码来捕获异常而不必将其存储到一个变量中：

<?php declare(strict_types=1);

$nullableValue = null;

try {
    $value = $nullableValue ?? throw new \InvalidArgumentException();
} catch (\InvalidArgumentException) {
    var_dump("Something went wrong");
}

exit;

上述代码运行结果如下：

新增对 mixed 类型的支持

PHP 8 引入了新的名为 mixed 的类型，该类型等价于 array|bool|callable|int|float|null|object|resource|string：

<?php declare(strict_types=1);

function debug_function(mixed ...$data)
{
    var_dump($data);
}

debug_function(1, &#39;string&#39;, []);

exit;

上述代码运行结果如下：

新增对注解的支持

PHP 8 的注解实际上包含了多个 RFC：

• https://wiki.php.net/rfc/attributes_v2
• https://wiki.php.net/rfc/attribute_amendments
• https://wiki.php.net/rfc/shorter_attribute_syntax
• https://wiki.php.net/rfc/shorter_attribute_syntax_change

注解绝对是 PHP 8 引入的最大新特性之一，一开始理解起来可能有点困难（不过有 Java 基础的话会很简单）。简而言之，注解允许你添加元数据到 PHP 函数、参数、类等，这些元数据随后可以通过可编程方式获取，在 PHP 7 或者更低版本中实现类似功能需要解析代码注释块，而通过注解可以直接访问深度集成到 PHP 自身的这些信息。

我们来编写一段示例代码方便你理解，假设你想要允许开发者添加中间件到控制器类/方法，使用注解可以这么做：

<?php declare(strict_types=1);

// 首先，我们需要定义注解，注解本身只是一个原生的 PHP 类，并且自身被打上了注解的注释

#[Attribute]
class ApplyMiddleware
{
    public array $middlware = [];

    public function __construct(...$middleware)
    {
        $this->middleware = $middleware;
    }
}

// 下面的语法会添加上述注解到 MyController 类，并且传入 auth 作为参数

#[ApplyMiddleware('auth')]
class MyController
{
    public function index()
    {
    }
}

// 然后我们就可以在类中使用反射获取所有的 ApplyMiddleware 注解并读取给定的中间件参数

$reflectionClass = new ReflectionClass(MyController::class);

$attributes = $reflectionClass->getAttributes(ApplyMiddleware::class);

foreach ($attributes as $attribute) {
    $middlewareAttribute = $attribute->newInstance();
    var_dump($middlewareAttribute->middleware);
}

exit;

运行上述代码，打印结果如下：

新增构造函数属性提示支持

这个新特性只是一个语法简写而言，可以将属性声明和构造函数属性初始化合并到一起：

<?php declare(strict_types=1);

class User {
    public function __construct(
        public int $id,
        public string $name,
    ) {}
}

$user = new User(1, &#39;Marcel&#39;);

var_dump($user->id);
var_dump($user->name);

exit;

上述代码运行结果如下：

新增 match 表达式支持

match 表达式和 switch 分支语句类型，但是语义上更加安全并且可以直接返回值：

<?php declare(strict_types=1);

echo match (1) {
    0 => 'Foo',
    1 => 'Bar',
    2 => 'Baz',
};

exit;

上述代码运行结果如下：

新增对空安全运算符 ?-> 的支持

当该运算符的左侧评估为 null 时，整个代码链路的执行将会被终止并整体评估为 null。如果不为 null 的话，则和普通的 -> 运算符功能一致：

<?php declare(strict_types=1);

class User {
    public function getAddress() {}
}

$user = new User();

$country = $user?->getAddress()?->country?->iso_code;

var_dump($country);

exit;

上述代码运行结果如下：

新增对命名参数的支持

命名参数允许基于参数名称传递参数到函数，而不是参数所在的位置，这样一来，函数参数就可以自解释并且与顺序无关，并且允许跳过默认值：

<?php declare(strict_types=1);

array_fill(start_index: 0, num: 100, value: 50);

exit;

注：PHP 8 还有另一个重要的新特性 —— 引入对 JIT 的支持，不过对于上层业务代码而言是无感的，只是底层优化而已，想要了解 JIT 对 PHP 应用性能的影响，请参考之前发布的这篇文章：https://xueyuanjun.com/post/21702。本篇教程所有示例代码整理自 PHP 8 - try out all new features，原文基于 Laravel 框架进行测试，这里将其转化为了通用的 PHP 代码