Maison >développement back-end >tutoriel php >PHP5.5 ~ PHP7.2 nouvelles fonctionnalités organisées

PHP5.5 ~ PHP7.2 nouvelles fonctionnalités organisées

不言
不言original
2018-05-05 15:08:472637parcourir

Cet article présente les nouvelles fonctionnalités de PHP5.5 ~ PHP7.2. Les amis dans le besoin peuvent s'y référer

Portage de PHP 5.5.x vers PHP 5.6.x

Nouvelles fonctionnalités.

Utiliser des expressions pour définir des constantes

  • Dans les versions précédentes de PHP, vous deviez utiliser des valeurs statiques pour définir des constantes, déclarer des propriétés et spécifier des valeurs par défaut pour paramètres de fonction. Vous pouvez désormais utiliser des expressions numériques, notamment des nombres, des chaînes littérales et d'autres constantes, pour définir des constantes, déclarer des propriétés et définir des valeurs par défaut pour les paramètres de fonction.

<?php
const ONE = 1;
const TWO = ONE * 2;

class C {
    const THREE = TWO + 1;
    const ONE_THIRD = ONE / self::THREE;
    const SENTENCE = &#39;The value of THREE is &#39;.self::THREE;
}
  • Les constantes de type tableau peuvent désormais être définies via le mot-clé const.

<?php
const ARR = [&#39;a&#39;, &#39;b&#39;];

echo ARR[0];

Utilisez l'opérateur ... pour définir une fonction de paramètre de longueur variable

  • Vous pouvez maintenant utiliser... l'opérateur pour implémenter des fonctions de paramètres de longueur variable.

<?php
function f($req, $opt = null, ...$params) {
    // $params 是一个包含了剩余参数的数组
    printf(&#39;$req: %d; $opt: %d; number of params: %d&#39;."\n",
           $req, $opt, count($params));
}

f(1);
f(1, 2);
f(1, 2, 3);
f(1, 2, 3, 4);
?>

La routine ci-dessus affichera :

$req: 1; $opt: 0; number of params: 0
$req: 1; $opt: 2; number of params: 0
$req: 1; $opt: 2; number of params: 1
$req: 1; $opt: 2; number of params: 2

Utilisez l'opérateur ... pour l'expansion des paramètres

  • Lors de l'appel d'une fonction, utilisez l'opérateur... pour développer les tableaux et les objets traversables en paramètres de fonction. Dans d'autres langages de programmation, comme Ruby, cela s'appelle l'opérateur de concaténation.

<?php
function add($a, $b, $c) {
    return $a + $b + $c;
}

$operators = [2, 3];
echo add(1, ...$operators);
?>

La routine ci-dessus affichera :

6

utiliser la fonction et utiliser const

  • utiliser l'opérateur A a été étendu pour prendre en charge l'importation de fonctions externes et de constantes dans les classes. Les structures correspondantes sont use function et use const.

<?php
namespace Name\Space {
    const FOO = 42;
    function f() { echo __FUNCTION__."\n"; }
}

namespace {
    use const Name\Space\FOO;
    use function Name\Space\f;

    echo FOO."\n";
    f();
}
?>

La routine ci-dessus affichera :

42
Name\Space\f

Utilisez hash_equals() pour comparer les chaînes afin d'éviter les attaques de synchronisation

À partir de PHP 5.6 .x Porté vers PHP 7.0.x

Nouvelles fonctionnalités

Déclaration de type scalaire

  • Il existe deux modes pour la déclaration de type scalaire : obligatoire (par défaut) et modèle strict. Les paramètres de type suivants sont désormais disponibles (en mode forcé ou strict) : string, int, float et bool.

<?php
// Coercive mode
function sumOfInts(int ...$ints)
{
    return array_sum($ints);
}

var_dump(sumOfInts(2, &#39;3&#39;, 4.1));

La routine ci-dessus affichera :

int(9)

Déclaration de type de valeur de retour

  • Support PHP 7 ajouté pour les déclarations de type de retour. Semblable à la déclaration de type de paramètre, la déclaration de type de retour spécifie le type de valeur de retour de la fonction. Les types disponibles sont les mêmes que ceux disponibles dans la déclaration des paramètres.

<?php

function arraysSum(array ...$arrays): array
{
    return array_map(function(array $array): int {
        return array_sum($array);
    }, $arrays);
}

opérateur de coalescence nul

  • En raison du grand nombre d'utilisations simultanées d'expressions ternaires et d'isset() dans l'usage quotidien, nous ajouté le sucre syntaxique de l'opérateur de coalescence nul (??). Si la variable existe et n'est pas NULL, elle renvoie sa propre valeur, sinon elle renvoie son deuxième opérande.

<?php
// Fetches the value of $_GET[&#39;user&#39;] and returns &#39;nobody&#39; if it does not exist.
$username = $_GET[&#39;user&#39;] ?? &#39;nobody&#39;;
// This is equivalent to:
$username = isset($_GET[&#39;user&#39;]) ? $_GET[&#39;user&#39;] : &#39;nobody&#39;;

// Coalesces can be chained: this will return the first defined value out of $_GET[&#39;user&#39;], $_POST[&#39;user&#39;], and &#39;nobody&#39;.
$username = $_GET[&#39;user&#39;] ?? $_POST[&#39;user&#39;] ?? &#39;nobody&#39;;
?>

Opérateur de vaisseau spatial (opérateurs de comparaison combinés)

  • L'opérateur de vaisseau spatial est utilisé pour comparer deux expressions. Il renvoie -1, 0 ou 1 lorsque $a est respectivement inférieur, égal ou supérieur à $b. Le principe de comparaison suit les règles de comparaison habituelles de PHP.

<?php
// 整数
echo 1 <=> &#39;1&#39;; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

// 浮点数
echo &#39;1.50&#39; <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
 
// 字符串
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
?>

Définition de tableaux de constantes via définir()

  • Les constantes de type Array peuvent désormais être définies via définir(). En PHP5.6, il ne peut être défini que via const.

define(&#39;ANIMALS&#39;, [
    &#39;dog&#39;,
    &#39;cat&#39;,
    &#39;bird&#39;
]);

echo ANIMALS[1]; // 输出 "cat"

Closure::call()

  • Closure::call() a désormais de meilleures performances, une exécution plus courte et plus propre Lier un méthode à la fermeture sur l’objet et appelez-la.

<?php
class A {private $x = 1;}

// PHP 7 之前版本的代码
$getXCB = function() {return $this->x;};
$getX = $getXCB->bindTo(new A, &#39;A&#39;); // 中间层闭包
echo $getX();

// PHP 7+ 及更高版本的代码
$getX = function() {return $this->x;};
echo $getX->call(new A);

La routine ci-dessus produira :

1

Groupe use Déclaration

  • du même espace de noms Les classes, fonctions et constantes importées peuvent désormais être importées en même temps avec une seule instruction d'utilisation.

<?php

// PHP 7 之前的代码
use some\namespace\ClassA;
use some\namespace\ClassB;
use some\namespace\ClassC as C;

use function some\namespace\fn_a;
use function some\namespace\fn_b;
use function some\namespace\fn_c;

use const some\namespace\ConstA;
use const some\namespace\ConstB;
use const some\namespace\ConstC;

// PHP 7+ 及更高版本的代码
use some\namespace\{ClassA, ClassB, ClassC as C};
use function some\namespace\{fn_a, fn_b, fn_c};
use const some\namespace\{ConstA, ConstB, ConstC};
?>

Les générateurs peuvent renvoyer des expressions

  • Cette fonctionnalité s'appuie sur la fonctionnalité de générateur introduite dans la version PHP 5.5. Il vous permet de renvoyer une expression (mais ne permet pas le retour d'une valeur de référence) en utilisant la syntaxe de retour dans une fonction génératrice. Vous pouvez obtenir la valeur de retour du générateur en appelant la méthode Generator::getReturn(), mais. cette méthode ne peut être utilisée que lors de la génération d'appelés une fois que le processeur a fini de générer du travail.

Fonction de division entière intp()


Porté de PHP 7.0.x vers PHP 7.1.x

Nouvelles fonctionnalités

Types nullables

  • Les types de paramètres et les valeurs de retour peuvent désormais être nullables en ajoutant un point d'interrogation avant le type. Lorsque cette fonctionnalité est activée, les paramètres transmis ou le résultat renvoyé par la fonction sont soit du type donné, soit null .

<?php

function testReturn(): ?string
{
    return &#39;elePHPant&#39;;
}

var_dump(testReturn());

function testReturn(): ?string
{
    return null;
}

var_dump(testReturn());

function test(?string $name)
{
    var_dump($name);
}

test(&#39;elePHPant&#39;);
test(null);
test();

La routine ci-dessus affichera :

string(10) "elePHPant"
NULL
string(10) "elePHPant"
NULL
Uncaught Error: Too few arguments to function test(), 0 passed in...

Fonction Void

  • Une nouvelle valeur de retour de type void est introduit. Les méthodes dont les valeurs de retour sont déclarées de type void omettent complètement l'instruction return ou utilisent une instruction return vide. NULL n'est pas une valeur de retour légale pour les fonctions void.

<?php
function swap(&$left, &$right) : void
{
    if ($left === $right) {
        return;
    }

    $tmp = $left;
    $left = $right;
    $right = $tmp;
}

$a = 1;
$b = 2;
var_dump(swap($a, $b), $a, $b);

La routine ci-dessus affichera :

null
int(2)
int(1)

Symmetric array destructuring

  • 短数组语法([])现在作为list()语法的一个备选项,可以用于将数组的值赋给一些变量(包括在foreach中)。

<?php
$data = [
    [1, &#39;Tom&#39;],
    [2, &#39;Fred&#39;],
];

// list() style
list($id1, $name1) = $data[0];

// [] style
[$id1, $name1] = $data[0];

// list() style
foreach ($data as list($id, $name)) {
    // logic here with $id and $name
}

// [] style
foreach ($data as [$id, $name]) {
    // logic here with $id and $name
}

类常量可见性

  • 现在起支持设置类常量的可见性。

<?php
class ConstDemo
{
    const PUBLIC_CONST_A = 1;
    public const PUBLIC_CONST_B = 2;
    protected const PROTECTED_CONST = 3;
    private const PRIVATE_CONST = 4;
}

iterable 伪类

  • 现在引入了一个新的被称为iterable的伪类 (与callable类似)。 这可以被用在参数或者返回值类型中,它代表接受数组或者实现了Traversable接口的对象。 至于子类,当用作参数时,子类可以收紧父类的iterable类型到array 或一个实现了Traversable的对象。对于返回值,子类可以拓宽父类的 array或对象返回值类型到iterable。

<?php
function iterator(iterable $iter) : iterable
{
    foreach ($iter as $val) {
        //
    }
}

多异常捕获处理

  • 一个catch语句块现在可以通过管道字符(|)来实现多个异常的捕获。 这对于需要同时处理来自不同类的不同异常时很有用。

<?php
try {
    // some code
} catch (FirstException | SecondException $e) {
    // handle first and second exceptions
}

list()现在支持键名

  • 现在list()和它的新的[]语法支持在它内部去指定键名。这意味着它可以将任意类型的数组 都赋值给一些变量(与短数组语法类似)

<?php
$data = [
    ["id" => 1, "name" => &#39;Tom&#39;],
    ["id" => 2, "name" => &#39;Fred&#39;],
];

// list() style
list("id" => $id1, "name" => $name1) = $data[0];

// [] style
["id" => $id1, "name" => $name1] = $data[0];

// list() style
foreach ($data as list("id" => $id, "name" => $name)) {
    // logic here with $id and $name
}

// [] style
foreach ($data as ["id" => $id, "name" => $name]) {
    // logic here with $id and $name
}

从PHP 7.1.x 移植到 PHP 7.2.x

新特性

新的对象类型

  • 这种新的对象类型, object, 引进了可用于逆变(contravariant)参数输入和协变(covariant)返回任何对象类型。

<?php

function test(object $obj) : object
{
    return new SplQueue();
}

test(new StdClass());

允许重写抽象方法(Abstract method)

  • 当一个抽象类继承于另外一个抽象类的时候,继承后的抽象类可以重写被继承的抽象类的抽象方法。

abstract class A
{
    abstract function test(string $s);
}
abstract class B extends A
{
    // overridden - still maintaining contravariance for parameters and covariance for return
    abstract function test($s) : int;
}

扩展了参数类型

  • 重写方法和接口实现的参数类型现在可以省略了。不过这仍然是符合LSP,因为现在这种参数类型是逆变的。

interface A
{
    public function Test(array $input);
}

class B implements A
{
    public function Test($input){} // type omitted for $input
}

允许分组命名空间的尾部逗号

  • 命名空间可以在PHP 7中使用尾随逗号进行分组引入。

use Foo\Bar\{
    Foo,
    Bar,
    Baz,
};



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!

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn