Bedeutung von drei Punkten (…) in PHP

Was bedeutet Three Dot (...) in PHP?

Während ich Magento 2 in meinem Server installiere, ist ein Fehler aufgetreten. Untersuchen Sie den Code und stellen Sie fest, dass ein Dreipunkt (...) vorhanden ist, der den Fehler erzeugt. Ich habe den folgenden Code erwähnt

return new $type(...array_values($args));

Der ...$strwird in PHP als Splat-Operator bezeichnet .

Mit dieser Funktion können Sie eine variable Anzahl von Argumenten für eine Funktion erfassen, kombiniert mit "normalen" Argumenten, die übergeben werden, wenn Sie möchten. Am einfachsten ist es anhand eines Beispiels zu sehen:

function concatenate($transform, ...$strings) {
    $string = '';
    foreach($strings as $piece) {
        $string .= $piece;
    }
    return($transform($string));
}

echo concatenate("strtoupper", "I'd ", "like ", 4 + 2, " apples");
// This would print:
// I'D LIKE 6 APPLES

Die Parameterliste in der Funktionsdeklaration enthält den ...Operator und bedeutet im Grunde "... und alles andere sollte in $ Strings gehen". Sie können dieser Funktion zwei oder mehr Argumente übergeben. Das zweite und die folgenden Argumente werden dem Array $ strings hinzugefügt und können verwendet werden.

Hoffe das hilft!

Jede Antwort bezieht sich auf denselben Blog-Beitrag. Außerdem finden Sie hier die offizielle Dokumentation zu Argumentlisten mit variabler Länge :

http://php.net/manual/en/functions.arguments.php#functions.variable-arg-list

In PHP 5.6 und höher können Argumentlisten das Token ... enthalten, um anzuzeigen, dass die Funktion eine variable Anzahl von Argumenten akzeptiert. Die Argumente werden als Array an die angegebene Variable übergeben

Es scheint, dass "splat" Operator kein offizieller Name ist, aber es ist süß!

Es gibt ZWEI Verwendungszwecke für das PHP-Token mit Auslassungspunkten (...) Verpackung ein Array und Auspacken eines Arrays. Beide Zwecke gelten für Funktionsargumente.

Pack

Wenn Sie beim Definieren einer Funktion eine dynamische Anzahl von Variablen benötigen, die für die Funktion bereitgestellt werden (dh Sie wissen nicht, wie viele Argumente für diese Funktion beim Aufrufen im Code bereitgestellt werden), verwenden Sie das Auslassungszeichen (...) to Erfassen Sie alle verbleibenden Argumente, die für diese Funktion bereitgestellt wurden, in einem Array, auf das innerhalb des Funktionsblocks zugegriffen werden kann. Die Anzahl der von Auslassungspunkten (...) erfassten dynamischen Argumente kann null oder mehr betragen.

Zum Beispiel :

// function definition
function sum(...$numbers) { // use ellipsis token when defining function
    $acc = 0;
    foreach ($numbers as $nn) {
        $acc += $nn;
    }
    return $acc;
}

// call the function
echo sum(1, 2, 3, 4); // provide any number of arguments

> 10

// and again...
echo sum(1, 2, 3, 4, 5);

> 15

// and again...
echo sum();

> 0

Wenn das Packen bei der Funktionsinstanziierung verwendet wird, erfasst die Ellipse (...) alle verbleibenden Argumente , dh Sie können immer noch eine beliebige Anzahl von anfänglichen, festen (Positions-) Argumenten haben:

function sum($first, $second, ...$remaining_numbers) {
    $acc = $first + $second;
    foreach ($remaining_numbers as $nn) {
        $acc += $nn;
    }
    return $acc;
}

// call the function
echo sum(1, 2); // provide at least two arguments

> 3

// and again...
echo sum(1, 2, 3, 4); // first two are assigned to fixed arguments, the rest get "packed"

> 10

Auspacken

Wenn Sie beim Aufrufen einer Funktion die Argumente, die Sie für diese Funktion angeben, zuvor zu einem Array zusammengefasst haben, verwenden Sie alternativ das Auslassungszeichen (...) mit , um dieses Array in einzelne Argumente zu konvertieren, die für die Funktion bereitgestellt werden. Jedes Array-Element wird dem jeweiligen Element zugewiesen Funktionsargumentvariable, die in der Funktionsdefinition genannt wird.

Beispielsweise:

function add($aa, $bb, $cc) {
    return $aa + $bb + $cc;
}

$arr = [1, 2, 3];
echo add(...$arr); // use ellipsis token when calling function

> 6

$first = 1;
$arr = [2, 3];
echo add($first, ...$arr); // used with positional arguments

> 6

$first = 1;
$arr = [2, 3, 4, 5]; // array can be "oversized"
echo add($first, ...$arr); // remaining elements are ignored

> 6

Das Entpacken ist besonders nützlich, wenn Sie Array-Funktionen zum Bearbeiten von Arrays oder Variablen verwenden.

Beispiel: Entpacken des Ergebnisses von array_slice :

function echoTwo ($one, $two) {
    echo "$one\n$two";
}

$steaks = array('ribeye', 'kc strip', 't-bone', 'sirloin', 'chuck');

// array_slice returns an array, but ellipsis unpacks it into function arguments
echoTwo(...array_slice($steaks, -2)); // return last two elements in array

> sirloin
> chuck

Um diese Funktion zu verwenden, warnen Sie PHP einfach, dass das Array mithilfe von mit in entpackt werden muss ... operator. Sehen Sie hier , um weitere Informationen, ein einfaches Beispiel könnte wie folgt aussehen:

$email[] = "Hi there";
$email[] = "Thanks for registering, hope you like it";

mail("someone@example.com", ...$email);

Dies bedeutet, dass ein assoziatives Array in eine Liste zerlegt wird. Sie müssen also keine N Parameter eingeben, um eine Methode aufzurufen, sondern nur eine. Wenn die Methode einen zerlegten Parameter zulässt und wenn die Parameter vom gleichen Typ sind.

Für mich ist das Wichtigste am Splat-Operator, dass es helfen kann, Array-Parameter einzugeben:

$items = [
    new Item(), 
    new Item()
];

$collection = new ItemCollection();
$collection->add(...$items); // !

// what works as well:
// $collection->add(new Item());
// $collection->add(new Item(), new Item(), new Item()); // :(

class Item  {};

class ItemCollection {

    /**
     * @var Item[]
     */
    protected $items = [];

    public function add(Item ...$items)
    {
        foreach ($items as &$item) {
            $this->items[] = $item;
        }
    }
} 

Dies spart einige Anstrengungen bei der Typsteuerung, insbesondere bei der Arbeit mit großen Sammlungen oder sehr objektorientiert.

Es ist wichtig zu beachten, dass ...$arrayein Array trotz der Art seiner Elemente zerlegt wird , sodass Sie auch den hässlichen Weg gehen können:

function test(string $a, int $i) {
    echo sprintf('%s way as well', $a);

    if ($i === 1) {
        echo('!');
    }
}

$params = [
    (string) 'Ugly',
    (int) 1
];

test(...$params);

// Output:
// Ugly way as well!

Aber bitte nicht.

Dies ist der sogenannte "Splat" -Operator. Im Grunde bedeutet das "eine beliebige Anzahl von Argumenten"; eingeführt mit PHP 5.6

Sehen Sie hier für weitere Details.

Es scheint, dass niemand es erwähnt hat, also bleiben Sie hier [Es wird auch Google (& anderen SEs) helfen, Entwickler zu führen, die nach Ruheparametern in PHP fragen ]:

Wie hier angegeben, heißt es Rest Parameters on JS & ich bevorzuge diese aussagekräftige Benennung gegenüber dieser Splat-Sache!

In PHP ist die Funktionalität zur Verfügung gestellt von ... args heißt Variadische Funktionen , die auf PHP5.6 eingeführt wird . Dieselbe Funktionalität wurde verwendet, um mit implementiert zu werden func_get_args().

Um es richtig zu verwenden, sollten Sie die Syntax der Ruheparameter verwenden , wo immer dies zur Reduzierung des Boilerplate-Codes beiträgt .

Ich möchte eine Verwendung dieses Operators im Magento-Framework teilen, wo er Objekte mit dynamisch konfigurierbaren Parametern (gedachte XML-Konfigurationsdateien) instanziiert.

Wie wir createObjectaus dem folgenden Codeausschnitt ersehen können, enthält es ein Array der Argumente, die für die Objekterstellung vorbereitet wurden. Anschließend wird der ...Operator (drei Punkte) verwendet, um die Array-Werte als echte Argumente an den Konstruktor der Klasse zu übergeben.

<?php

namespace Magento\Framework\ObjectManager\Factory;

abstract class AbstractFactory implements \Magento\Framework\ObjectManager\FactoryInterface
{
    ...

    /**
     * Create object
     *
     * @param string $type
     * @param array $args
     *
     * @return object
     * @throws RuntimeException
     */
    protected function createObject($type, $args)
    {
        try {
            return new $type(...array_values($args));
        } catch (\TypeError $exception) {
            ...
        }
    }

    ...

}

Es ist ein Splat- oder Scatter-Operator in PHP

Referenz: Splat- oder Scatter-Operator in PHP