L'opérateur de propagation de PHP 8.1 peut être utilisé pour étendre les objets iTables dans un tableau. 1. Il peut simplifier la combinaison et la fusion des numéros, et remplacer Array_merge par [... $ array1, ... $ array2]; 2. Il peut étendre directement l'objet et le générateur Traversable sans avoir besoin de iterator_to_array (); 3. Il prend en charge le passage des paramètres variables dans les appels de fonction; Il convient de noter qu'il ne s'applique qu'aux objets itérables. Les types de non-itérations lanceront des erreurs, les clés numériques seront réindexées et la valeur après la touche de cha?ne écrase la valeur précédente. Par conséquent, il est recommandé d'utiliser dans PHP 8.1 pour améliorer la lisibilité du code.

PHP 8.1 a introduit plusieurs améliorations de la qualité de vie, mais l'un des ajouts les plus pratiques pour travailler avec les tableaux est l' opérateur de propagation ( ... ) dans des contextes de tableau. Alors que les développeurs JavaScript ont longtemps apprécié cette syntaxe, l'implémentation de PHP apporte un moyen plus propre et plus expressif de créer et de fusionner des tableaux, en particulier lorsqu'ils traitent des itérables et des variadiques.

Voici comment vous pouvez tirer parti de l'opérateur de diffusion en PHP moderne pour écrire un code plus lisible et flexible.

Ce que fait l'opérateur de propagation dans les tableaux

Dans PHP, l'opérateur de propagation déballait un itérable (comme un tableau ou un objet traversable) en éléments individuels dans un nouveau tableau. Il fonctionne à l'intérieur des littéraux de tableau à l'aide de crochets ( [] ).

Avant PHP 8.1, les tableaux de fusion signifient souvent que s'appuyer sur array_merge() ou le L'opérateur, qui avait des limites, en particulier lorsqu'il s'agit de clés non nucères ou de structures imbriquées.

Avec l'opérateur de diffusion, vous pouvez le faire:

 $ couleurs = [?rouge?, ?vert?];
$ moreColors = [?bleu?, ?jaune?];

$ allColors = [... $ couleurs, ... $ morecolors];
// Résultats: [?rouge?, ?vert?, ?bleu?, ?jaune?]

Ceci est fonctionnellement équivalent à array_merge($colors, $moreColors) , mais plus concis et lisible, en particulier lors de la combinaison de plusieurs sources.

Cas d'utilisation clés et avantages

1. Fusion de réseau plus propre

Au lieu de:

 $ combiné = array_merge ($ array1, $ array2, $ array3);

Vous pouvez maintenant écrire:

 $ combiné = [... $ array1, ... $ array2, ... $ array3];

Ceci est particulièrement utile lors de la construction de tableaux en ligne ou conditionnellement:

 $ options = [
    'debug' => true,
    ... ($ aperviseCache? ['cache_dir' => '/ tmp']: []),
    ... $ userOptions,
]]

Cela évite la nécessité d'appeler conditionnellement array_merge et maintient tout déclaratif.

2. Déballage des objets traversables

L'opérateur de diffusion fonctionne non seulement avec les tableaux, mais avec n'importe quel itérable, y compris les générateurs et les objets implémentant Traversable .

 fonction getNumbers () {
    rendement 1;
    rendement 2;
    rendement 3;
}

$ nombres = [... getNumbers ()];
// Résultats: [1, 2, 3]

Cela comble l'écart entre les générateurs et l'utilisation du tableau sans avoir besoin d'être iterator_to_array() .

3. Travailler avec des arguments variadiques

Lorsque vous appelez des fonctions qui acceptent les arguments variadiques, vous pouvez utiliser l'opérateur de propagation pour passer les éléments du tableau comme arguments individuels.

 Sum de fonction (... $ nombres) {
    return array_sum ($ nombres);
}

$ valeurs = [1, 2, 3, 4];
ECHO SUM (... $ VALEUR); // Sortie: 10

Ce n'est pas la création de tableaux en soi, mais il complète le r?le de la propagation dans les flux de travail PHP modernes.

Limitations importantes et gotchas

• Fonctionne uniquement avec itérables : vous ne pouvez pas répartir null , les cha?nes ou les types non itréables. Cela lance une TypeError .

   $ bad = [... null]; // Erreur fatale

• Les clés numériques sont réindexées : comme array_merge() , la diffusion des tableaux indexés renvoile les touches numériques.

   $ a = [0 => 'x'];
  $ b = [0 => 'y'];
  $ c = [... $ a, ... $ b]; // [0 => 'x', 1 => 'y']

• Les touches de cha?ne sont conservées et peuvent écraser:

   $ a = ['couleur' => 'red'];
  $ b = ['couleur' => 'bleu'];
  $ c = [... $ a, ... $ b]; // ['Color' => 'Blue']

  Donc, la propagation des tableaux associés se comporte comme array_merge() - les valeurs de la bureau écrasent les valeurs plus t?t.

  ---

  Quand utiliser Spread vs array_merge

  Cas d'utilisation	Approche recommandée
  Fusion simple de tableaux indexés	Opérateur de propagation
  Inclusion conditionnelle dans les littéraux du tableau	Propagation (syntaxe plus propre)
  Tableaux associatifs avec logique d'écrasement	Soit (la propagation est plus lisible)
  Besoin de préserver exactement les clés originales	array_merge() (même comportement)
  Travailler avec des non-itérables	array_merge() (plus indulgent)

  Dans la plupart des cas d'utilisation moderne, l'opérateur de propagation est préféré pour sa clarté et son expressivité en ligne.

  ---

  Réflexions finales

  L'opérateur de diffusion dans PHP Arrays n'est pas une fonctionnalité révolutionnaire, mais c'est une évolution bienvenue dans la syntaxe qui rend le code plus intuitif et moins encombré. En réduisant la dépendance à la fonction des appels pour la composition de base, il aligne le PHP plus étroitement avec les tendances linguistiques modernes.

  Utilisez-le pour:

  • Fusionner les tableaux proprement
  • étendre les générateurs ou les collections en ligne
  • Construire des tableaux dynamiques avec une logique conditionnelle

  N'oubliez pas: cela ne fonctionne qu'avec des iterables, et la manipulation des clés suit les règles array_merge() .

  Fondamentalement, si vous êtes sur PHP 8.1, il n'y a aucune raison de ne pas commencer à utiliser ... dans votre création de tableau. C'est simple, s?r et rend votre code un peu plus lisible.

  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!