Question JavaScript intéressante : initialisation d'un tableau multidimensionnel

Parfois, nous devons créer un tableau multidimensionnel et l'initialiser à la valeur par défaut souhaitée.

Normalement, nous allons d'abord créer un tableau à une dimension, puis référencer le tableau à deux dimensions au sein de ce tableau à une dimension... jusqu'au tableau à N dimensions, puis remplir son contenu avec la valeur par défaut .

Dans ce processus, nous devons écrire beaucoup de boucles, ce qui est inévitablement un peu fastidieux Alors, pourquoi ne pas penser à un moyen d'écrire une méthode outil pour l'initialisation de tableaux multidimensionnels afin que nous puissions appeler. c'est pratique ?

Je suppose que vous devez vouloir une méthode comme celle-ci :

dim( d1 [,d2 [,d3 [... ]]], value )

Regardez sa liste de paramètres, d1, d2, d3 représentent le nombre d'éléments référencés par chaque tableau de dimensions, la valeur représente le valeur initiale.

Cette valeur peut être une fonction. Si tel est le cas, on se réfère à la valeur de retour de la fonction.

Regardons quelques exemples :

dim( 3,3,"x" ) // => [['x','x','x'],['x','x','x'],['x','x','x']]

Ici, le tableau d'un bit fait référence à 3 tableaux bidimensionnels, et chaque tableau bidimensionnel fait référence à 3 valeurs d'initialisation ​​'x'

dim( 2,2,2,0 ) // => [[[0,0],[0,0]],[[0,0],[0,0]]]

Les règles ici sont les mêmes que ci-dessus

dim( 3, true ) // => [true,true,true]

Le tableau unidimensionnel ici fait référence à 3 valeurs booléennes vraies

var xxx = function(){ return "xX" }
dim( 2,5,xxx ) // => [['xX','xX','xX','xX','xX'],['xX','xX','xX','xX','xX']]

Initialisé ici La valeur est une fonction, nous remplissons donc le résultat qu'elle renvoie

Cette question nécessite une récursion car elle implique un tableau à N dimensions.

C'est un processus de construction d'un tableau et de parcours en profondeur.

Dans ma méthode, un paramètre deep est utilisé pour enregistrer la profondeur actuelle.

Par exemple, dim(2,2,2,0), si la profondeur actuelle est de 0, alors cela correspond au premier paramètre 2, indiquant que 2 tableaux sont à créer, c'est-à-dire la valeur de deep et la liste de paramètres L'index de est cohérent et représente le nombre de tableaux ou de valeurs à construire.

Si deep atteint le niveau le plus profond, cela signifie que l'affectation d'initialisation peut être effectuée et que la boucle for remplit le tableau actuel.

function dim(){  
    var len = arguments.length;  
    var args = Array.prototype.slice.call(arguments,0,len-1);  
    var content = arguments[len-1];  
    var result = [];  
      
    var traverse = function foo(from,deep){  
        var arg = args[deep];  
        if(deep < args.length - 1){  
            for(var i=0;i<arg;i++){  
                var array = [];  
                from.push(array);  
                foo(array,deep+1);  
            }  
        }  
        else{  
            for(var i=0;i<arg;i++){  
                if(typeof content === "function"){  
                    from.push(content());  
                }  
                else{  
                    from.push(content);  
                }  
            }  
        }  
    };  
    traverse(result,0);  
    return result;  
}

Ce qui précède est le contenu des questions intéressantes en JavaScript : initialisation de tableaux multidimensionnels. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !