Czy istnieje bardziej zwięzły sposób inicjowania pustych tablic wielowymiarowych?

Question

Próbowałem znaleźć rozsądnie zwięzły sposób ustawiania wymiarów pustej wielowymiarowej tablicy JavaScript, ale bez powodzenia.

Po pierwsze, próbowałem zainicjować pustą tablicę 10x10x10 przy użyciu var theArray = new Array(10, 10 10), ale zamiast tego stworzyłem tylko jednowymiarową tablicę z 3 elementami.

Zorientowałem się, jak zainicjować pustą tablicę 10x10x10 za pomocą zagnieżdżonych pętli for-owych, ale bardzo uciążliwe jest zapisywanie inicjalizatora tablic w ten sposób. Inicjowanie tablic wielowymiarowych za pomocą zagnieżdżonych pętli for może być dość uciążliwe: czy istnieje bardziej zwięzły sposób ustawiania wymiarów pustych tablic wielowymiarowych w JavaScript (z dowolnie wieloma wymiarami)?

//Initializing an empty 10x10x10 array: 
var theArray = new Array(); 
for(var a = 0; a < 10; a++){ 
    theArray[a] = new Array(); 
    for(var b = 0; b < 10; b++){ 
     theArray[a][b] = new Array(); 
     for(var c = 0; c < 10; c++){ 
      theArray[a][b][c] = 10 
     } 
    } 
} 

console.log(JSON.stringify(theArray)); 

Answer 1

Adaptacja this answer:

function createArray(length) { 
    var arr = new Array(length || 0), 
     i = length; 

    if (arguments.length > 1) { 
    var args = Array.prototype.slice.call(arguments, 1); 
    while(i--) arr[i] = createArray.apply(this, args); 
    }   
    return arr; 
} 

Wystarczy zadzwonić z argumentem o długości każdego wymiaru. przykłady wykorzystania:

• var multiArray = createArray(10,10,10); daje 3-wymiarową tablicę równej długości.
• var weirdArray = createArray(34,6,42,2); Powoduje czterowymiarowy układ nierównych długości.

Answer 2

Oto moje podejście do problemu: nArray funkcja użyteczności

function nArray() { 
    var arr = new Array(); 
    var args = Array.prototype.slice.call(arguments, 1); 
    for(var i=0;i<arguments[0];i++) { 
     arr[i] = (arguments.length > 1 && nArray.apply(this, args)) || undefined; 
    } 
    return arr; 
} 

Przykład użycia:

var arr = nArray(3, 3, 3); 

Wyniki w 3x3x3 tablicy wartości niezdefiniowanych.

Uruchamianie kodu z niektórych testach również dostępny jako Fiddle tutaj: http://jsfiddle.net/EqT3r/7/

Answer 3

function multiDimArrayInit(dimensions, leafValue) { 
    if (!dimensions.length) { 
     return leafValue; 
    } 
    var arr = []; 
    var subDimensions = dimensions.slice(1); 
    for (var i = 0; i < dimensions[0]; i++) { 
     arr.push(multiDimArrayInit(subDimensions, leafValue)); 
    } 
    return arr; 
} 


console.log(multiDimArrayInit([2,8], "hi")); // counting the nested "hi"'s yields 16 of them 

demo http://jsfiddle.net/WPrs3/

Answer 4

Im bardziej wymiar masz, tym więcej masz zainteresowanie wykorzystaniem pojedynczą płaską tablicę i getter/setter dla twojej tablicy.
Ponieważ dla [d1 X d2 X d3 X .. X dn] będziesz tworzyć tablice d2 * d3 * ... * dn zamiast jednego, a podczas uzyskiwania dostępu będziesz n indirection zamiast 1.

interfejs wyglądałby następująco:

var myNArray = new NArray(10,20,10); 
var oneValue = myNArray.get(5,8,3); 
myNArray.set(8,3,2, 'the value of (8,3,2)'); 

realizacja zależy od preferencji dla stałej wielkości n-dimensionnal tablicy lub tablicy w stanie wcisnąć/pop i tym podobne.

Answer 5

bardziej zwięzła wersja @chris kodu:

function multiDim (dims, leaf) { 
    dims = Array.isArray (dims) ? dims.slice() : [dims]; 
    return Array.apply (null, Array (dims.shift())).map (function (v, i) { 
    return dims.length 
     ? multiDim (dims, typeof leaf == 'string' ? leaf.replace ('%i', i + ' %i') : leaf) 
     : typeof leaf == 'string' ? leaf.replace ('%i', i) : leaf; 
    });  
} 

console.log (JSON.stringify (multiDim ([2,2], "hi %i"), null, ' ')); 

Produkuje:

[ 
    [ 
    "hi 0 0", 
    "hi 0 1" 
    ], 
    [ 
    "hi 1 0", 
    "hi 1 1" 
    ] 
] 

W tej wersji można przejść pierwszy argument jako numer do jednej macierzy wymiaru. W tym %i w wartości liścia zostaną podane wartości indeksów w wartościach liści.

grać z nim w: http://jsfiddle.net/jstoolsmith/r3eMR/

Answer 6

bardzo prostych funkcji generuje tablicę z dowolnej liczbie wymiarów. Określ długość każdego wymiaru i treść, która jest dla mnie „” zwykle

function arrayGen(content,dims,dim1Len,dim2Len,dim3Len...) { 
    var args = arguments; 
    function loop(dim) { 
    var array = []; 
    for (var a = 0; a < args[dim + 1]; a++) { 
     if (dims > dim) { 
     array[a] = loop(dim + 1); 
     } else if (dims == dim) { 
     array[a] = content; 
     } 
    } 
    return array; 
    } 
    var thisArray = loop(1); 
    return thisArray; 
}; 

używam tej funkcji bardzo często, to oszczędza dużo czasu