Présentation des méthodes courantes d'opérateur de propagation en JavaScript

Compréhension personnelle des... méthodes courantes

...en tant qu'opérateur d'expansion

L'expansion ici fait référence à un tableau ou une chaîne ou un pseudo-tableau (qui est similaire à un tableau) Vous pouvez utiliser des indices pour supprimer chaque élément et avoir l'attribut de longueur globale des données (ci-après dénommé l'objet traversable), ce qui signifie supprimer chaque élément du tableau et le séparer avec (lors de l'utilisation, c'est le cas, s'ils sont imprimés séparément, ils sont séparés par des espaces).

• ...Vous pouvez développer un tableau unidimensionnel, c'est-à-dire que vous ne pouvez supprimer que la couche la plus externe de [] ;
• Le résultat est le résultat de la suppression du [] du tableau, pas une chaîne, un array, ou quoi que ce soit d'autre, donc selon sa méthode séparée par des virgules, vous pouvez le transmettre comme paramètre formel de la fonction, ou vous pouvez l'envelopper avec un [] à l'extérieur et l'utiliser comme tableau comme retour de une fonction Cependant, elle ne peut pas être renvoyée directement et vous pouvez utiliser la console pour la générer.

<script>
        let arr = [
            5,
            "str",
            [1,2,3],
            ["hello","world"],
        ];

        function fn(arr){
            console.log(...arr);   
            return [...arr]        
        }
        function fo(...arr){
            console.log(arr);
        }
        // function foo(arr){
        //     return ...arr;  //    Expression expected.
        // }
        console.log(fn(arr));     //  5 "str" (3) [1, 2, 3] (2) ["hello", "world"]
                                  //  (4) [5, "str", Array(3), Array(2)]
		//   外面的[]去掉了，但是里面的[1,2,3]、["hello","world"]的[]没有去掉
    </script>

…en tant qu'opérateur reste

• L'opérateur reste signifie que je ne sais pas combien de paramètres il y a au total, j'utilise... pour représenter le reste, et il ne s'applique également qu'aux tableaux.
• Et le résultat obtenu par ces deux méthodes est un array, pas un tableau sans [].
• Il existe principalement les deux méthodes suivantes :
  • La première : Tous les paramètres sont inconnus, et je ne sais pas combien en passer.
  • Deuxième type : il existe un ou plusieurs paramètres connus et les paramètres restants sont inconnus.

//  第一种所有参数都未知function aa(...arr){
    console.log(arr);}aa(5,"sss",22)     //  (3) [5, "sss", 22]     =>    结果是一个数组//  第二种，有两个已知参数function ff(a,b,...arr){
    console.log(arr)}ff(2,3,"str","111")    // (2) ["str", "111"]   =>    结果是一个数组

Autres applications de fonctionnalités :

Décomposer des chaînes

Vous pouvez utiliser str.split("") ou [...str]

Les pseudo-tableaux peuvent être convertis en de vrais tableaux

Parce qu'il peut convertir objets traversables La méthode de suppression de [] d'un tableau est affichée et elle peut être utilisée pour les pseudo-tableaux, il est donc facile de comprendre qu'après avoir utilisé des pseudo-tableaux, après avoir converti la forme du pseudo-tableau, l'ajout de [] est le vrai tableau, et la méthode du tableau réel peut être appelée . => […arr.]

Copie superficielle

Puisqu'il utilise une boucle sur un objet traversable, il ne modifiera pas le tableau d'origine, mais effectuera une opération de clonage superficiel, il peut donc être utilisé pour les tableaux Copie superficielle. => […arr]

Aplatissement du tableau

  <script>
        // 简单的二维数组（一个数组里面又套了一个数组  =>  二维)
        let arr = [
            5,
            "str",
            [1,2,3],
            ["hello","world"],
        ];

        // 三维数组（一个数组里面套一个数组，里面又套一个数组）
        let arr1 = [
            5,
            "str",
            [
                1,2,3,
                ["ccc","dddd"]
            ],
            ["hello","world"],
        ];


        function flatten(arr){
            return [].concat(...arr);
        }

        function flatten1(arr){
            return [].concat(...arr.map(x => Array.isArray(x) ? flatten1(x) : x));
        }
        console.log(flatten(arr));    // (7) [5, "str", 1, 2, 3, "hello", "world"]
        console.log(flatten1(arr));   // (7) [5, "str", 1, 2, 3, "hello", "world"]
        console.log(flatten(arr1));   // (8) [5, "str", 1, 2, 3, Array(2), "hello", "world"]
        console.log(flatten1(arr1));  // (9) [5, "str", 1, 2, 3, "ccc", "dddd", "hello", "world"]
    </script>

Comme le montre ce qui précède, lorsque la structure du tableau est très simple (bidimensionnelle), l'opérateur de propagation peut résoudre le tableau à l'intérieur et utiliser concat pour l'épissage. Mais lorsque le tableau est multidimensionnel, il ne peut pas résoudre le tableau plus profond. Il doit utiliser l'opérateur de propagation et la récursivité pour y parvenir.

Apprentissage recommandé : "Tutoriel de base javascript"

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!