Signification de trois points (…) en PHP

Quelle est la signification de trois points (...) en PHP?

Pendant que j'installe Magento 2 sur mon serveur, j'ai une erreur. Examinez le code et constatez qu'il y a un trois points (...), qui produit l'erreur. J'ai mentionné le code ci-dessous

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

Le ...$strs'appelle un opérateur splat en PHP .

Cette fonction vous permet de capturer un nombre variable d'arguments à une fonction, combiné avec des arguments "normaux" passés si vous le souhaitez. C'est plus simple à voir avec un exemple:

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

La liste des paramètres dans la déclaration de fonction contient l' ...opérateur, et cela signifie en gros "... et tout le reste devrait aller dans $ strings". Vous pouvez passer 2 arguments ou plus dans cette fonction et le second et les suivants seront ajoutés au tableau $ strings, prêts à être utilisés.

J'espère que cela t'aides!

Chaque réponse fait référence au même article de blog, à côté d'eux, voici la documentation officielle sur les listes d'arguments de longueur variable :

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

Dans PHP 5.6 et versions ultérieures, les listes d'arguments peuvent inclure le jeton ... pour indiquer que la fonction accepte un nombre variable d'arguments. Les arguments seront passés dans la variable donnée sous forme de tableau

Il semble que l'opérateur "splat" ne soit pas un nom officiel, c'est quand même mignon!

Il y a DEUX utilisations pour le jeton PHP des points de suspension (...) - pensez-y comme emballer un tableau et décompresser un tableau. Les deux objectifs s'appliquent aux arguments de fonction.

Pack

Lors de la définition d'une fonction, si vous avez besoin d'un nombre dynamique de variables fournies à la fonction (c'est-à-dire que vous ne savez pas combien d'arguments seront fournis à cette fonction lorsqu'elle est appelée dans le code), utilisez le jeton points de suspension (...) pour capture tous les arguments restants fournis à cette fonction dans un tableau accessible à l'intérieur du bloc fonction. Le nombre d'arguments dynamiques capturés par les points de suspension (...) peut être égal ou supérieur à zéro.

Par exemple :

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

Lorsque l'empaquetage est utilisé dans l'instanciation de fonction, les points de suspension (...) capturent tous les arguments restants , c'est-à-dire que vous pouvez toujours avoir n'importe quel nombre d'arguments initiaux fixes (positionnels):

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

Déballer

Alternativement, lors de l'appel d'une fonction, si les arguments que vous fournissez à cette fonction sont précédemment combinés dans un tableau, utilisez le jeton points de suspension (...) pour convertir ce tableau en arguments individuels fournis à la fonction - chaque élément du tableau est assigné à l'élément respectif variable d'argument de fonction nommée dans la définition de fonction.

Par exemple:

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

Le déballage est particulièrement utile lorsque vous utilisez des fonctions de tableau pour manipuler des tableaux ou des variables.

Par exemple, décompression du résultat de 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

Pour utiliser cette fonctionnalité, avertissez simplement PHP qu'il doit décompresser le tableau en variables en utilisant le ... operator. Voir ici pour plus de détails, un exemple simple pourrait ressembler à ceci:

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

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

Cela signifie qu'il décompose un tableau associatif en une liste. Vous n'avez donc pas besoin de taper N paramètres pour appeler une méthode, un seul. Si la méthode autorise un paramètre décomposé et si les paramètres sont du même type.

Pour moi, la chose la plus importante à propos de l'opérateur splat est qu'il peut aider à taper des paramètres de tableau:

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

cela permet d'économiser des efforts sur le contrôle de type, en particulier lorsque vous travaillez avec d'énormes collections ou très orientées objet.

Il est important de noter que ...$arraydécomposez un tableau malgré le type de ses éléments , vous pouvez donc également suivre la voie laide:

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!

Mais ne le faites pas.

Il s'agit de l'opérateur dit "splat". Fondamentalement, cette chose se traduit par "un nombre quelconque d'arguments"; introduit avec PHP 5.6

Voir ici pour plus de détails.

Il semble que personne ne l'ait mentionné, alors ici pour rester [Cela aidera également Google (et d'autres SE) à guider les développeurs qui demandent des paramètres de repos en PHP ]:

Comme indiqué ici, il s'appelle Paramètres de repos sur JS et je préfère ce nom significatif à ce truc splat!

En PHP, la fonctionnalité fournie par ... args est appelée fonctions Variadic qui est introduite sur PHP5.6. La même fonctionnalité a été utilisée pour être implémentée en utilisant func_get_args().

Pour l'utiliser correctement, vous devez utiliser la syntaxe des paramètres de repos, partout où cela aide à réduire le code standard .

En PHP 7.4, les points de suspension sont également l' opérateur Spread :

$parts = ['apple', 'pear'];
$fruits = ['banana', 'orange', ...$parts, 'watermelon'];
// ['banana', 'orange', 'apple', 'pear', 'watermelon'];

Source: https://wiki.php.net/rfc/spread_operator_for_array

J'aimerais partager une utilisation de cet opérateur dans le framework Magento, où il instancie des objets avec des paramètres configurables dynamiques (fichiers de configuration XML).

Comme nous pouvons le voir createObjectdans l'extrait de code suivant, la fonction prend dans un tableau des arguments préparés pour la création de l'objet. Ensuite, il utilise l' ...opérateur (trois points) pour transmettre les valeurs du tableau en tant qu'arguments réels au constructeur de la classe.

<?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) {
            ...
        }
    }

    ...

}

c'est un opérateur splat ou scatter en PHP

référence: opérateur splat ou scatter en PHP

La version 5.6 a ajouté un opérateur splat ou parfois appelé décompression d'arguments. Un opérateur splat est 3 points avant un paramètre. L'opérateur splat permet à un utilisateur de transmettre une quantité arbitraire de paramètres. Les paramètres arbitraires sont ensuite transformés en tableau par PHP.

Quelle est donc la différence entre l'utilisation de l'opérateur splat et un tableau ou un tableau associatif. Vous pouvez spécifier le type de données des objets affectés à l'opérateur splat et s'ils ne correspondent pas à php, une erreur sera générée.

function addItemsToCart(CartItem ...$cartItems) {
    //$cartItems is an array of CartItem objects
}

$cartItem1 = new CartItem();
$cartItem2 = new CartItem();
$cartItem3 = new CartItem();

addItemsToCart($cartItem1, $cartItem2, $cartItem3);

ref: Ici