Il y a tellement de choses que nous devons apprendre et comprendre en PHP. Dans l'article d'aujourd'hui, jetons un coup d'œil aux secrets de php7.4 ! Je pense que vous gagnerez beaucoup après avoir lu cet article. Sans plus tarder, jetons-y un coup d’œil !
Dans cet article, nous discutons de certains changements et fonctionnalités qui devraient être ajoutés au langage dans la version finale de PHP 7.4 :
Disponible depuis PHP 5.6, le déballage des paramètres est la syntaxe de déballage tableaux et Traversables dans des listes de paramètres. Pour décompresser un tableau ou Traversable, il doit être préfixé par ... (3 points), comme dans l'exemple suivant :
function test(...$args) { var_dump($args); } test(1, 2, 3);
Cependant, la RFC PHP 7.4 recommande d'étendre cette fonctionnalité aux tableaux :
$arr = [...$args];
Le premier avantage de l'opérateur Spread est la performance. La documentation RPC indique : L'opérateur
Spread devrait avoir de meilleures performances que
array_merge
. Ce n'est pas seulement que l'opérateur Spread est une construction syntaxique, maisarray_merge
est une méthode. Également au moment de la compilation, les tableaux constants sont optimisés pour une efficacité élevée. Un avantage significatif de l'opérateur
Spread est qu'il prend en charge tout objet traversable, tandis que la fonction array_merge
ne prend en charge que les tableaux. Voici un exemple de paramètres dans un tableau avec l'opérateur Spread :
$parts = ['apple', 'pear']; $fruits = ['banana', 'orange', ...$parts, 'watermelon']; var_dump($fruits);
Si vous exécutez ce code en PHP 7.3 ou une version antérieure, PHP générera une erreur d'analyse :
Parse error: syntax error, unexpected '...' (T_ELLIPSIS), expecting ']' in /app/spread-operator.php on line 3
Au lieu de cela, PHP 7.4 renverra un tableau
array(5) { [0]=> string(6) "banana" [1]=> string(6) "orange" [2]=> string(5) "apple" [3]=> string(4) "pear" [4]=> string(10) "watermelon" }
RFC indique que nous pouvons étendre le même tableau plusieurs fois. De plus, nous pouvons utiliser la syntaxe Spread Operator n'importe où dans le tableau puisque des éléments réguliers peuvent être ajoutés avant ou après l'opérateur spread. Par conséquent, le code suivant fonctionnera comme prévu :
$arr1 = [1, 2, 3]; $arr2 = [4, 5, 6]; $arr3 = [...$arr1, ...$arr2]; $arr4 = [...$arr1, ...$arr3, 7, 8, 9];
Il est également possible de passer le tableau renvoyé par la fonction en paramètre et de le mettre dans un nouveau tableau :
function buildArray(){ return ['red', 'green', 'blue']; } $arr1 = [...buildArray(), 'pink', 'violet', 'yellow'];
Sorties PHP 7.4 le tableau suivant :
array(6) { [0]=> string(3) "red" [1]=> string(5) "green" [2]=> string(4) "blue" [3]=> string(4) "pink" [4]=> string(6) "violet" [5]=> string(6) "yellow" }
On peut aussi utiliser le générateur :
function generator() { for ($i = 3; $i <= 5; $i++) { yield $i; } } $arr1 = [0, 1, 2, ...generator()];
mais le passage par référence n'est pas autorisé. Prenons l'exemple suivant :
$arr1 = ['red', 'green', 'blue']; $arr2 = [...&$arr1];
Si nous essayons de passer par référence, PHP générera l'erreur d'analyse suivante :
Parse error: syntax error, unexpected '&' in /app/spread-operator.php on line 3
Si les éléments du premier tableau sont stockés par référence, alors ils le sont également stocké par référence dans le deuxième tableau. Voici un exemple :
$arr0 = 'red'; $arr1 = [&$arr0, 'green', 'blue']; $arr2 = ['white', ...$arr1, 'black'];
Voici ce que nous obtenons avec PHP 7.4 :
array(5) { [0]=> string(5) "white" [1]=> &string(3) "red" [2]=> string(5) "green" [3]=> string(4) "blue" [4]=> string(5) "black" }
En PHP En , les fonctions anonymes sont considérées comme très verbeuses et difficiles à implémenter et à maintenir, et la RFC recommande d'introduire une syntaxe de fonction de flèche (ou de fermeture courte) plus simple et plus claire afin que nous puissions écrire du code de manière concise. Avant PHP 7.4 :
function cube($n){ return ($n * $n * $n); } $a = [1, 2, 3, 4, 5]; $b = array_map('cube', $a); print_r($b);
PHP 7.4 permet une syntaxe plus concise, la fonction ci-dessus peut être réécrite comme suit :
$a = [1, 2, 3, 4, 5]; $b = array_map(fn($n) => $n * $n * $n, $a); print_r($b);
Actuellement, en raison de la structure du langage, des fonctions anonymes (fermetures) peuvent être utilisé use
Hérite des variables définies dans la portée parent, comme ceci :
$factor = 10; $calc = function($num) use($factor){ return $num * $factor; };
Mais dans PHP 7.4, la valeur de la portée parent est capturée implicitement (implicitement étendue par la liaison de valeur). Nous pouvons donc utiliser une ligne pour compléter cette fonction
$factor = 10; $calc = fn($num) => $num * $factor;
Les variables définies dans la portée parent peuvent être utilisées pour les fonctions fléchées. Cela équivaut à notre utilisation de use
et ne peut pas être modifié par le parent . La nouvelle syntaxe constitue une grande amélioration du langage, car elle nous permet de créer un code plus lisible et plus maintenable.
En raison du grand nombre de situations où les expressions ternaires et isset () sont utilisées simultanément dans l'utilisation quotidienne, nous avons ajouté l'opérateur de coalescence nul (??) à ce Sucre syntaxique. Si la variable existe et n'est pas NULL, elle renvoie sa propre valeur, sinon elle renvoie son deuxième opérande.
$username = $_GET['user'] ?? ‘nobody';
Ce que fait ce code est très simple : il récupère le paramètre de requête et définit une valeur par défaut s'il n'existe pas . Mais dans cet exemple RFC, que se passe-t-il si nous avons des noms de variables plus longs ?
$this->request->data['comments']['user_id'] = $this->request->data['comments']['user_id'] ?? 'value';
Ce code peut être difficile à maintenir à long terme. Par conséquent, dans le but d'aider les développeurs à écrire du code plus intuitif, cette RFC propose d'introduire l'opérateur égal de fusion nul (null_coalesce_equal_operator) ??=
, afin que nous puissions taper le code suivant pour remplacer le code ci-dessus :
$this->request->data['comments']['user_id'] ??= ‘value’;
Si le la valeur du paramètre gauche est null
, la valeur du paramètre droit est utilisée.
Notez que bien que l'opérateur de fusion ??
soit un opérateur de comparaison, ??=
est un opérateur d'affectation.
类型的声明,类型提示,以及指定确定类型的变量传递给函数或类的方法。其中类型提示是在 PHP5 的时候有的一个功能,PHP 7.2 的时候添加了 object
的数据类型。而 PHP7.4 更是增加了主类属性声明,看下面的例子:
class User { public int $id; public string $name; }
除了 void
和 callable
外,所有的类型都支持
public int $scalarType; protected ClassName $classType; private ?ClassName $nullableClassType;
为什么不支持 void
和 callable
?下面是 RFC 的解释
The
void
type is not supported, because it is not useful and has unclear semantics.
不支持void
类型,是因为它没用,并且语义不清晰。The
callable
type is not supported, because its behavior is context dependent.
不支持callable
类型,因为其行为取决于上下文。
因此,我们可以放心使用 bool
,int
,float
,string
,array
,object
,iterable
,self
,parent
,当然还有我们很少使用的 nullable
空允许 (?type
)
所以你可以在 PHP7.4 中这样敲代码:
// 静态属性的类型 public static iterable $staticProp; // var 中声明属性 var bool $flagl // 设置默认的值 // 注意,只有 nullable 的类型,才能设置默认值为 null public string $str = "foo"; public ?string $nullableStr = null; // 多个同类型变量的声明 public float $x, $y;
如果我们传递不符合给定类型的变量,会发生什么?
class User { public int $id; public string $name; } $user = new User; $user->id = 10; $user->name = []; // 这个会产生一个致命的错误 Fatal error: Uncaught TypeError: Typed property User::$name must be string, array used in /app/types.php:9
在这个 RFC 中,提议引入 WeakReference
这个类,弱引用允许编码时保留对对象的引用,该引用不会阻止对象被破坏;这对于实现类似于缓存的结构非常有用。
该提案的作者 Nikita Popov 给出的一个例子:
$object = new stdClass; $weakRef = WeakReference::create($object); var_dump($weakRef->get()); unset($object); var_dump($weakRef->get()); // 第一次 var_dump object(stdClass)#1 (0) {} // 第二次 var_dump,当 object 被销毁的时候,并不会抛出致命错误 NULL
协变和逆变
百度百科的解释
Invariant
的参数类型,并且大多数是 Invariant
的返回类型,这就意味着当我是 T 参数类型或者返回类型时,子类也必须是 T 的参数类型或者返回类型。但是往往会需要处理一些特殊情况,比如具体的返回类型,或者通用的输入类型。而 RFC 的这个提案就提议,PHP7.4 添加协变返回和逆变参数,以下是提案给出来的例子:协变返回:interface Factory { function make(): object; } class UserFactory implements Factory { // 将比较泛的 object 类型,具体到 User 类型 function make(): User; }
逆变参数:
interface Concatable { function concat(Iterator $input); } class Collection implements Concatable { // 将比较具体的 `Iterator`参数类型,逆变成接受所有的 `iterable`类型 function concat(iterable $input) {/* . . . */} }
这个 RFC 是由 Dmitry Stogov 提出的,预加载是在模块初始化的时候,将库和框架加载到 OPCache 中的过程,如下图所示
引用他的原话:
On server startup – before any application code is run – we may load a certain set of PHP files into memory – and make their contents “permanently available” to all subsequent requests that will be served by that server. All the functions and classes defined in these files will be available to requests out of the box, exactly like internal entities.
服务器启动时 – 在运行任何应用程序代码之前 – 我们可以将一组 PHP 文件加载到内存中 – 并使得这些预加载的内容,在后续的所有请求中 “永久可用”。这些文件中定义的所有函数和类在请求时,就可以开箱即用,与内置函数相同。
预加载由 php.ini
的 opcache.preload
进行控制。这个参数指定在服务器启动时编译和执行的 PHP 脚本。此文件可用于预加载其他文件,或通过 opcache_compile_file()
函数
这在性能上有很大的提升,但是也有一个很明显的缺点,RFC 提出来了
preloaded files remain cached in opcache memory forever. Modification of their corresponding source files won’t have any effect without another server restart.
预加载的文件会被永久缓存在 opcache 内存中。在修改相应的源文件时,如果没有重启服务,修改就不会生效。
这是尼基塔·波波夫(Nikita Popov)的另一项建议 ,得到了绝大多数票的批准。
当前,我们有两种不同的机制可以在PHP中对对象进行自定义序列化:
__sleep()
和__wakeup()
魔术方法Serializable
接口根据Nikita的说法,这两个选项都存在导致复杂且不可靠的代码的问题。 您可以在RFC中深入研究此主题。 在这里,我只提到新的序列化机制应该通过提供两个结合了两个现有机制的新魔术方法__serialize()
和__unserialize()
来防止这些问题。
该提案以20票对7票获得通过。
目前,在 PHP 中 +
, -
算术运算符和 .
字符串运算符是左关联的, 而且它们具有相同的优先级。例如:
echo "sum: " . $a + $b;
在 PHP 7.3 中,此代码生成以下警告:
Warning: A non-numeric value encountered in /app/types.php on line 4
这是因为这段代码是从左往右开始的,所以等同于:
echo ("$sum: " . $a) + $b;
针对这个问题,这个 RFC 建议更改运算符的优先级,使 .
的优先级低于 +
,-
这两个运算符,以便在字符串拼接之前始终执行加减法。所以这行代码应该等同于以下内容:
echo "$sum: " . ($a + $b);
这个提案分为两步走:
+
-
和 .
在没有指明执行优先级时,会发出一个弃用通知。$b = $a == 1 ? 'one' : $a == 2 ? 'two' : $a == 3 ? 'three' : 'other';
它会被解释为:$b = (($a == 1 ? 'one' : $a == 2) ? 'two' : $a == 3) ? 'three' : 'other';
对于这种复杂的三元表现形式,它很有可能不是我们希望的方式去工作,容易造成错误。因此,这个 RFC 提议删除并弃用三元运算符的左关联使用,强制编程人员使用括号。这个提议分为两步执行:出于对PHP 7.4的Alpha预览版性能状态的好奇,我今天针对使用Git构建的PHP 7.3.6、7.2.18、7.1.29和7.0.32运行了一些快速基准测试,并且每个发行版均以相同的方式构建。
在此阶段,PHPBench的7.4性能与PHP 7.3稳定版相当,已经比PHP 7.0快了约30%…当然,与PHP 5.5的旧时代相比,收益甚至更大。
在微基准测试中,PHP 7.4的运行速度仅比PHP 7.3快一点,而PHP-8.0的性能却差不多,至少要等到JIT代码稳定下来并默认打开为止。
在Phoronix测试套件的内部PHP自基准测试中,PHP 7.4的确确实处于PHP 7.3性能水平之上-至少在此Alpha前状态下。 自PHP 7.0起,取得了一些显着的进步,而自PHP5发行缓慢以来,也取得了许多进步。
总结:PHP7.4是一个令人期待的版本,但是PHP8才是整个PHP界最重大的事情。
推荐学习:《PHP视频教程》
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!