Organisieren Sie neue Funktionen von PHP5.5 bis PHP7.2

PHP5.5 ~ PHP7.2 neue Funktionen organisiert

1. Portierung von PHP 5.5.x auf PHP 5.6.x

Verwenden Sie Ausdrücke, um Konstanten zu definieren

In früheren PHP-Versionen haben Sie Sie müssen statische Werte verwenden, um Konstanten zu definieren, Eigenschaften zu deklarieren und Standardwerte für Funktionsparameter anzugeben. Sie können jetzt numerische Ausdrücke wie Zahlen, Zeichenfolgenliterale und andere Konstanten verwenden, um Konstanten zu definieren, Eigenschaften zu deklarieren und Standardwerte für Funktionsparameter festzulegen.

<?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;
}

Sie können jetzt Konstanten vom Typ Array über das Schlüsselwort const definieren.

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

echo ARR[0];

Verwenden Sie den Operator ..., um eine Parameterfunktion mit variabler Länge zu definieren... 运算符定义变长参数函数

现在可以不依赖 func_get_args()， 使用 ... 运算符 来实现 变长参数函数。

<?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);
?>

以上例程会输出：

$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

使用 ... 运算符进行参数展开

在调用函数的时候，使用 ... 运算符， 将 数组 和 可遍历 对象展开为函数参数。 在其他编程语言，比如 Ruby中，这被称为连接运算符。

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

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

以上例程会输出：

6

use function 以及 use const

use 运算符 被进行了扩展以支持在类中导入外部的函数和常量。 对应的结构为 use function 和 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();
}
?>

以上例程会输出：

42
Name\Space\f

使用 hash_equals() 比较字符串避免时序攻击

推荐（免费）：PHP7

---

二、从PHP 5.6.x 移植到 PHP 7.0.x

标量类型声明

标量类型声明 有两种模式: 强制 (默认) 和 严格模式。 现在可以使用下列类型参数（无论用强制模式还是严格模式）： 字符串(string), 整数 (int), 浮点数 (float), 以及布尔值 (bool)。

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

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

以上例程会输出：

int(9)

返回值类型声明

PHP 7 增加了对返回类型声明的支持。 类似于参数类型声明，返回类型声明指明了函数返回值的类型。可用的类型与参数声明中可用的类型相同。

<?php

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

null合并运算符

由于日常使用中存在大量同时使用三元表达式和 isset()的情况， 我们添加了null合并运算符 (??) 这个语法糖。如果变量存在且值不为NULL， 它就会返回自身的值，否则返回它的第二个操作数。

<?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;;
?>

太空船操作符（组合比较符）

太空船操作符用于比较两个表达式。当$a小于、等于或大于$b时它分别返回-1、0或1。 比较的原则是沿用 PHP 的常规比较规则进行的。

<?php
// 整数
echo 1 <=> '1'; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

// 浮点数
echo '1.50' <=> 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
?>

通过 define() 定义常量数组

Array 类型的常量现在可以通过 define() 来定义。在 PHP5.6 中仅能通过 const 定义。

define('ANIMALS', [
    'dog',
    'cat',
    'bird'
]);

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

Closure::call()

Closure::call() 现在有着更好的性能，简短干练的暂时绑定一个方法到对象上闭包并调用它。

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

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

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

以上例程会输出：

1

分组 use

Jetzt können Sie den Operator ... verwenden, um eine Parameterfunktion mit variabler Länge zu implementieren, ohne auf func_get_args() angewiesen zu sein.

<?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};
?>

Die obige Routine gibt Folgendes aus:

<?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();

Verwenden Sie den Operator ... für die Parametererweiterung

Verwenden Sie beim Aufruf der Funktion den Operator..., um das Array zu kombinieren und durchquerbare Objekte zu erweitern in Funktionsparameter umwandeln. In anderen Programmiersprachen wie Ruby wird dies als Verkettungsoperator bezeichnet.

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

Die obige Routine gibt Folgendes aus:

<?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);

---

use-Funktion und use-const

use-Operator wurden erweitert, um den Import externer Funktionen und Konstanten in die Klasse zu unterstützen. Die entsprechenden Strukturen sind use function und use const.

null
int(2)
int(1)

Die obige Routine gibt Folgendes aus:

<?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
}

Verwenden Sie hash_equals(), um Zeichenfolgen zu vergleichen und Timing-Angriffe zu vermeiden

Empfohlen (kostenlos): PHP7

2. Portierung von PHP 5.6.x nach PHP 7.0.x

Skalare Typdeklaration

Es gibt zwei Skalare Typdeklarationsmodi: obligatorischer (Standard) und strikter Modus. Die folgenden Typparameter sind jetzt verfügbar (entweder im erzwungenen oder strikten Modus): string, int, float und bool.

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

Die obige Routine gibt Folgendes aus:

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

Deklaration des Rückgabewerttyps

PHP 7 fügt Unterstützung für die Deklaration des Rückgabetyps hinzu. Ähnlich wie die Parametertypdeklaration gibt die Rückgabetypdeklaration den Typ des Rückgabewerts der Funktion an. Die verfügbaren Typen sind dieselben wie die in der Parameterdeklaration verfügbaren. 🎜

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

🎜🎜Null-Koaleszenzoperator🎜🎜🎜Aufgrund der großen Anzahl von Situationen, in denen ternäre Ausdrücke und isset() im täglichen Gebrauch gleichzeitig verwendet werden, haben wir die Syntax des Null-Koaleszenzoperators (??) hinzugefügt. Zucker. Wenn die Variable existiert und nicht NULL ist, gibt sie ihren eigenen Wert zurück, andernfalls gibt sie ihren zweiten Operanden zurück. 🎜

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

// 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
}

🎜🎜Raumschiff-Operator (Kombinationsvergleichsoperator)🎜🎜🎜Der Raumschiff-Operator wird zum Vergleichen zweier Ausdrücke verwendet. Es gibt -1, 0 oder 1 zurück, wenn $a kleiner, gleich oder größer als $b ist. Das Vergleichsprinzip folgt den regulären Vergleichsregeln von PHP. 🎜

<?php

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

test(new StdClass());

🎜🎜Konstanten-Arrays über define() definieren 🎜🎜🎜Konstanten vom Typ Array können jetzt über define() definiert werden. In PHP5.6 kann es nur über const definiert werden. 🎜

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;
}

🎜🎜Closure::call()🎜🎜🎜Closure::call() hat jetzt eine bessere Leistung, eine kurze und prägnante Möglichkeit, eine Methode vorübergehend an einen Abschluss eines Objekts zu binden und es aufzurufen. 🎜

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

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

🎜Die obige Routine gibt Folgendes aus: 🎜

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

🎜🎜Gruppen-use-Deklaration🎜🎜🎜Klassen, Funktionen und Konstanten, die aus demselben Namespace importiert wurden, können jetzt auf einmal mit einer einzigen use-Anweisung importiert werden. 🎜rrreee🎜🎜Generatoren können Ausdrücke zurückgeben🎜🎜🎜Diese Funktion baut auf der Generatorfunktion auf, die in der PHP-Version 5.5 eingeführt wurde. Sie können einen Ausdruck zurückgeben (aber nicht die Rückgabe eines Referenzwerts), indem Sie die Rückgabesyntax in einer Generatorfunktion verwenden. Sie können den Rückgabewert des Generators erhalten, indem Sie die Methode Generator::getReturn() aufrufen Diese Methode kann nur beim Generieren verwendet werden. Wird einmal aufgerufen, nachdem der Prozessor die Generierung der Arbeit abgeschlossen hat. 🎜🎜🎜Die Ganzzahldivisionsfunktion intp()🎜🎜🎜🎜🎜portiert von PHP 7.0.x nach PHP 7.1.x🎜🎜🎜🎜Nullable-Typ🎜🎜🎜Die Parametertypen und Rückgabewerte können jetzt im übergeben werden Geben Sie davor ein Fragezeichen ein, damit es leer bleibt. Wenn diese Funktion aktiviert ist, sind die übergebenen Parameter oder das von der Funktion zurückgegebene Ergebnis entweder vom angegebenen Typ oder null . 🎜rrreee🎜Die obige Routine gibt Folgendes aus: 🎜rrreee🎜🎜Void-Funktion🎜🎜🎜Ein neuer Rückgabewerttyp void wird eingeführt. Methoden, deren Rückgabewerte vom Typ void deklariert sind, lassen die Return-Anweisung entweder ganz weg oder verwenden eine leere Return-Anweisung. NULL ist kein zulässiger Rückgabewert für Void-Funktionen. 🎜rrreee🎜Die obige Routine gibt Folgendes aus: 🎜rrreee🎜🎜Symmetrische Array-Destrukturierung🎜🎜🎜Die kurze Array-Syntax ([]) ist jetzt eine Alternative zur list()-Syntax und kann verwendet werden, um den Wert des Arrays einigen zuzuweisen Variablen (auch in foreach). 🎜rrreee🎜🎜Sichtbarkeit von Klassenkonstanten🎜🎜🎜Unterstützt jetzt das Festlegen der Sichtbarkeit von Klassenkonstanten. 🎜

<?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" => 'Tom'],
    ["id" => 2, "name" => 'Fred'],
];

// 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,
};

Das obige ist der detaillierte Inhalt vonOrganisieren Sie neue Funktionen von PHP5.5 bis PHP7.2. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!