Interessante JavaScript-Frage: Multidimensionale Array-Initialisierung

Manchmal müssen wir ein mehrdimensionales Array erstellen und es mit dem gewünschten Standardwert initialisieren.

Normalerweise erstellen wir zuerst ein eindimensionales Array, referenzieren dann das zweidimensionale Array innerhalb dieses eindimensionalen Arrays ... bis zum N-dimensionalen Array und füllen dann dessen Inhalt mit dem Standardwert .

In diesem Prozess müssen wir viele Schleifen schreiben, was zwangsläufig etwas umständlich ist. Warum also nicht eine Möglichkeit finden, eine Tool-Methode für die mehrdimensionale Array-Initialisierung zu schreiben, damit wir sie aufrufen können? es bequem?

Ich schätze, Sie wollen eine Methode wie diese:

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

Sehen Sie sich die Parameterliste an, d1, d2, d3 stellen die Anzahl der Elemente dar, auf die jedes Dimensionsarray verweist, und der Wert stellt die dar Anfangswert.

Dieser Wert kann eine Funktion sein. In diesem Fall beziehen wir uns auf den Rückgabewert der Funktion.

Sehen wir uns ein paar Beispiele an:

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

Hier bezieht sich das Ein-Bit-Array auf 3 zweidimensionale Arrays und jedes zweidimensionale Array bezieht sich auf 3 Initialisierungswerte ​​'x'

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

Die Regeln hier sind die gleichen wie oben

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

Das eindimensionale Array hier bezieht sich auf 3 boolesche Werte true

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

Hier initialisiert Der Wert ist eine Funktion, also geben wir das Ergebnis ein, das er zurückgibt

Diese Frage erfordert die Verwendung einer Rekursion, da es sich um ein N-dimensionales Array handelt.

Es ist ein Prozess des Aufbaus eines Arrays und der Tiefendurchquerung.

In meiner Methode wird ein Parameter deep verwendet, um die aktuelle Tiefe zu erfassen.

Zum Beispiel dim(2,2,2,0): Wenn die aktuelle Tiefe 0 ist, entspricht dies dem ersten Parameter 2, der angibt, dass 2 Arrays erstellt werden sollen, also dem Wert von tief und der Parameterliste Der Index von ist konsistent und gibt an, wie viele Arrays oder Werte erstellt werden sollen.

Wenn deep die tiefste Ebene erreicht, bedeutet dies, dass die Initialisierungszuweisung durchgeführt werden kann und die for-Schleife das aktuelle Array füllt.

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

Das Obige ist der Inhalt von JavaScript-interessanten Fragen: mehrdimensionale Array-Initialisierung Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!