Aperçu des nouvelles fonctionnalités de PHP 7.1

Type Nullable

Le type Nullable est principalement utilisé pour la déclaration du type de paramètre et la déclaration de la valeur de retour de la fonction.

Les deux formes principales sont les suivantes :

<?phpfunction answer(): ?int  {   return null; //ok}function answer(): ?int  {
   return 42; // ok}function say(?string $msg) {
   if ($msg) {
       echo $msg;
   }}

Il est facile de comprendre à partir de l'exemple. Ce que cela signifie est d'utiliser la forme de ? Le paramètre ou la valeur de retour est soit un type spécifié, soit nul.

Cette méthode peut également être utilisée pour la définition de fonctions d'interface :

<?php interface Fooable {    function foo(?Fooable $f);}

Mais il y a une chose à noter : si la fonction elle-même définit le type de paramètre et n'a pas valeur par défaut, même si elle est nullable et ne peut pas être omise, sinon une erreur sera déclenchée. Comme suit :

<?php function foo_nullable(?Bar $bar) {} foo_nullable(new Bar); // 可行foo_nullable(null); // 可行foo_nullable(); // 不可行

Mais si les paramètres de la fonction ci-dessus sont définis sous la forme ?Bar $bar = null, la troisième façon d'écrire est également réalisable. Parce que = null est en fait équivalent à un sur-ensemble de ? , pour les paramètres de type nullables, null peut être défini comme valeur par défaut.

L'abréviation entre crochets de list

Nous savons qu'avant PHP5.4, les tableaux ne pouvaient être définis que via array(), qui était ajouté après la version 5.4 Ecriture simplifiée de [] (il est quand même très pratique d'omettre 5 caractères).

<?php // 5.4 之前$array = array(1, 2, 3);$array = array("a" => 1, "b" => 2, "c" => 3); // 5.4 及之后$array = [1, 2, 3];$array = ["a" => 1, "b" => 2, "c" => 3];

s'étend à une autre question. Si nous voulons attribuer la valeur du tableau à différentes variables, nous pouvons le faire via la liste :

<?php list($a, $b, $c) = $array;

Pouvons-nous également passer [] abréviation à réaliser ?

<?php [$a, $b, $c] = $array;

et la liste des clés spécifiées qui seront mentionnées dans la fonctionnalité suivante :

<?php ["a" => $a, "b" => $b, "c" => $c] = $array;

PHP7.1 implémente cette fonctionnalité. Mais il convient de noter que le [] qui apparaît dans la lvalue n'est pas l'abréviation de array, mais l'abréviation de list().

Mais ce n'est pas tout. La nouvelle implémentation de list() peut non seulement apparaître dans les lvalues, mais peut également être utilisée dans les boucles foreach :

<?php foreach ($points as ["x" => $x, "y" => $y]) {    
var_dump($x, $y);

Cependant, en raison de problèmes d'implémentation, list() et [] ne peuvent pas être utilisés imbriqués l'un dans l'autre :

<?php // 不合法
list([$a, $b], [$c, $d]) = [[1, 2], [3, 4]]; 
// 不合法
[list($a, $b), list($c, $d)] = [[1, 2], [3, 4]]; 
// 合法
[[$a, $b], [$c, $d]] = [[1, 2], [3, 4]];

Permet de spécifier la clé dans la liste

mentionnée ci-dessus, je suis venu ici, la clé peut être spécifiée dans la nouvelle implémentation de list() :

<?php $array = ["a" => 1, "b" => 2, "c" => 3];["a" => $a, "b" => $b, "c" => $c] = $array;

Cela équivaut à :

<?php $a = $array[&#39;a&#39;];$b = $array[&#39;b&#39;];$c = $array[&#39;c&#39;];

La différence avec la liste précédente() is L'implémentation équivaut au fait que la clé ne peut être que sous la forme numérique de 0, 1, 2, 3 et que l'ordre ne peut pas être ajusté. L'exécution de l'instruction suivante :

<?php list($a, $b) = [1 => &#39;1&#39;, 2 => &#39;2&#39;];

obtiendra l'erreur PHP error : Undefined offset: 0... .

La nouvelle implémentation peut ajuster l'affectation des manières suivantes :

<?php list(1 => $a, 2 => $b) = [1 => &#39;1&#39;, 2 => &#39;2&#39;];

Contrairement aux tableaux, la liste ne prend pas en charge les clés mixtes. La méthode d'écriture suivante déclenchera une erreur d'analyse :

<?php // Parse error: syntax error, ...list($unkeyed, "key" => $keyed) = $array;

Pour les situations plus complexes, la liste prend également en charge l'analyse de forme composée :

<?php $points = [    
["x" => 1, "y" => 2],    
["x" => 2, "y" => 1]]; 
list(list("x" => $x1, "y" => $y1), list("x" => $x2, "y" => $y2)) = $points; 
$points = [    
"first" => [1, 2],    
"second" => [2, 1]]; 
list("first" => list($x1, $y1), 
"second" => list($x2, $y2)) = $points;

et utilisée dans les boucles :

<?php $points = [    
["x" => 1, "y" => 2],    
["x" => 2, "y" => 1]]; 
foreach ($points as list("x" => $x, "y" => $y)) {    
echo "Point at ($x, $y)", PHP_EOL;}

void return Type

PHP7.0 a ajouté la fonctionnalité permettant de spécifier le type de retour de la fonction, mais le type de retour ne peut pas être spécifié comme void. Cette fonctionnalité de 7.1 est un supplément :

<?php function should_return_nothing(): void {    return 1; // Fatal error: A void function must not return a value}

Les deux situations suivantes s'appliquent. Peut réussir. vérification :

<?php function lacks_return(): void {    // valid} function returns_nothing(): void {    return; // valid}

Une fonction définie comme type de retour void ne peut pas avoir de valeur de retour, même si elle renvoie null :

<?php function returns_one(): void {    
return 1; // Fatal error: A void function must not return a value} 
function returns_null(): void {    
return null; // Fatal error: A void function must not return a value}

De plus, void s'applique uniquement aux types de retour, et Il ne peut pas être utilisé pour la déclaration du type de paramètre, sinon une erreur sera déclenchée :

<?php function foobar(void $foo) { // Fatal error: void cannot be used as a parameter type}

La déclaration du type de retour dans une fonction de classe ne peut pas être remplacée par une sous-classe, sinon une erreur sera déclenchée :

<?php class Foo{    
public function bar(): void {    
}
} 
class Foobar extends Foo{   
 public function bar(): array { // Fatal error: Declaration of Foobar::bar() must be compatible with Foo::bar(): void    }}

Paramétrage des attributs de constante de classe

Cette fonctionnalité est relativement simple à dire, c'est-à-dire que les constantes de la classe prennent désormais en charge les modifications publiques, privées et protégées :

<?php class Token {    
// 常量默认为 
public    const PUBLIC_CONST = 0;     
// 可以自定义常量的可见范围    
private const PRIVATE_CONST = 0;    
protected const PROTECTED_CONST = 0;    
public const PUBLIC_CONST_TWO = 0;     
// 多个常量同时声明只能有一个属性    
private const FOO = 1, BAR = 2;}

De plus, les constantes dans l'interface ne peuvent être que des attributs publics :

<?php interface ICache {    public const PUBLIC = 0;    const IMPLICIT_PUBLIC = 1;}

Afin de faire face aux changements, l'implémentation de la classe de réflexion a été enrichie en conséquence, et deux méthodes getReflectionConstant et getReflectionConstants ont été ajoutés pour obtenir des constantes. Attributs supplémentaires :

<?php class testClass  {    
const TEST_CONST = &#39;test&#39;;
} 
$obj = new ReflectionClass( "testClass" );
$const = $obj->getReflectionConstant( "TEST_CONST" );
$consts = $obj->getReflectionConstants();

Multi-condition catch

Dans l'instruction try...catch précédente, chaque catch ne peut définir qu'un seul jugement conditionnel. :

<?php try {    
// Some code...
} 
catch (ExceptionType1 $e) {    
// 处理 ExceptionType1} 
catch (ExceptionType2 $e) {    
// 处理 ExceptionType2} 
catch (Exception $e) {    // ...}

Dans la nouvelle implémentation, plusieurs conditions peuvent être définies en une seule capture, ce qui équivaut au jugement de forme de ou :

<?php try {    
// Some code...} 
catch (ExceptionType1 | ExceptionType2 $e) {    
// 对于 ExceptionType1 和 ExceptionType2 的处理} 
catch (Exception $e) {    // ...}

Ce qui précède est la liste des nouveaux fonctionnalités de PHP 7.1 Pour plus de contenu connexe, veuillez prêter attention à PHP Chinese Net (www.php.cn) !