Wie kann ich ein zweidimensionales Array in JavaScript erstellen?

Sie machen einfach jedes Element innerhalb des Arrays zu einem Array.

var x = new Array(10);

for (var i = 0; i < x.length; i++) {
  x[i] = new Array(3);
}

console.log(x);

Ähnlich wie die Antwort von activa, hier eine Funktion zum Erstellen eines n-dimensionalen Arrays:

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[length-1 - i] = createArray.apply(this, args);
    }

    return arr;
}

createArray();     // [] or new Array()

createArray(2);    // new Array(2)

createArray(3, 2); // [new Array(2),
                   //  new Array(2),
                   //  new Array(2)]

Javascript hat nur 1-dimensionale Arrays, aber Sie können Arrays aus Arrays erstellen, wie andere bereits erwähnt haben.

Die folgende Funktion kann zum Erstellen eines 2-D-Arrays mit festen Dimensionen verwendet werden:

function Create2DArray(rows) {
  var arr = [];

  for (var i=0;i<rows;i++) {
     arr[i] = [];
  }

  return arr;
}

Die Anzahl der Spalten ist nicht wirklich wichtig, da die Größe eines Arrays nicht vor der Verwendung festgelegt werden muss.

Dann kannst du einfach anrufen:

var arr = Create2DArray(100);

arr[50][2] = 5;
arr[70][5] = 7454;
// ...

Der einfachste Weg:

var myArray = [[]];

Einige sagen, dass dies nicht möglich ist, weil ein zweidimensionales Array eigentlich nur ein Array von Arrays ist. Die anderen Kommentare hier bieten perfekt gültige Methoden zum Erstellen von zweidimensionalen Arrays in JavaScript. Der reinste Standpunkt wäre jedoch, dass Sie ein eindimensionales Array von Objekten haben. Jedes dieser Objekte wäre ein eindimensionales Array, das aus zwei Elementen besteht.

Das ist also die Ursache für die widersprüchlichen Sichtweisen. 

Nur wenige Leute zeigen den Einsatz von Push:
.__ Um etwas Neues zu bringen, zeige ich Ihnen, wie Sie die Matrix mit einem Wert wie beispielsweise 0 oder einer leeren Zeichenfolge "" initialisieren.
Erinnert daran, dass bei einem 10-Elemente-Array in Javascript der letzte Index 9 ist!

function matrix( rows, cols, defaultValue){

  var arr = [];

  // Creates all lines:
  for(var i=0; i < rows; i++){

      // Creates an empty line
      arr.Push([]);

      // Adds cols to the empty line:
      arr[i].Push( new Array(cols));

      for(var j=0; j < cols; j++){
        // Initializes:
        arr[i][j] = defaultValue;
      }
  }

return arr;
}

anwendungsbeispiele: 

x = matrix( 2 , 3,''); // 2 lines, 3 cols filled with empty string
y = matrix( 10, 5, 0);// 10 lines, 5 cols filled with 0

Zwei-Liner:

var a = []; 
while(a.Push([]) < 10);

Es wird ein Array a der Länge 10 generiert, das mit Arrays gefüllt ist.

Die vernünftigste Antwort scheint zu sein

var nrows = ~~(Math.random() * 10);
var ncols = ~~(Math.random() * 10);
console.log(`rows:${nrows}`);
console.log(`cols:${ncols}`);
var matrix = new Array(nrows).fill(0).map(row => new Array(ncols).fill(0));
console.log(matrix);

Beachten Sie, dass wir nicht direkt mit den Zeilen füllen können, da fill den flachen Kopierkonstruktor verwendet. Daher würden sich alle Zeilen den gleichen - Speicher teilen Andere Antwort):

// DON'T do this: each row in arr, is shared
var arr = Array(2).fill(Array(4));
arr[0][0] = 'foo'; // also modifies arr[1][0]
console.info(arr);

So erstellen Sie ein leeres zweidimensionales Array (einzeilig)

Array.from(Array(2), () => new Array(4))

2 und 4 sind erste bzw. zweite Abmessungen.

Wir verwenden Array.from , das einen Array-ähnlichen Parameter und ein optionales Mapping für jedes Element verwenden kann.

Array.from (arrayLike [ mapFn [ thisArg]])

var arr = Array.from(Array(2), () => new Array(4));
arr[0][0] = 'foo';
console.info(arr);

Derselbe Trick kann verwendet werden, um ein JavaScript-Array mit 1 ... N zu erstellen

Alternativ (aber ineffizienter 12% mit n = 10,000)

Array(2).fill(null).map(() => Array(4))

Der Leistungsabfall geht mit der Tatsache einher, dass die ersten Dimensionswerte initialisiert werden müssen, um .map auszuführen. Denken Sie daran, dass Array die Positionen erst dann zuweist, wenn Sie sie durch .fill oder eine direkte Wertzuweisung bestellen.

var arr = Array(2).fill(null).map(() => Array(4));
arr[0][0] = 'foo';
console.info(arr);

Nachverfolgen

Warum funktioniert das nicht?

 Array(2).fill(Array(4));

Während das scheinbar gewünschte zweidimensionale Array ([ [ <4 empty items> ], [ <4 empty items> ] ]) zurückgegeben wird, wurden Arrays catch: first dimension per Verweis kopiert. Das heißt, ein arr[0][0] = 'foo' würde tatsächlich zwei statt einer Zeile ändern.

var arr = Array(2).fill(Array(4));
arr[0][0] = 'foo';
console.info(arr);
console.info(arr[0][0], arr[1][0]);

Der einfachste Weg:

var arr  = [];

var arr1 = ['00','01'];
var arr2 = ['10','11'];
var arr3 = ['20','21'];

arr.Push(arr1);
arr.Push(arr2);
arr.Push(arr3);

alert(arr[0][1]); // '01'
alert(arr[1][1]); // '11'
alert(arr[2][0]); // '20'

Das habe ich erreicht:

var appVar = [[]];
appVar[0][4] = "bineesh";
appVar[0][5] = "kumar";
console.log(appVar[0][4] + appVar[0][5]);
console.log(appVar);

Das hat mich Bineeshkumar buchstabiert 

Zweidimensionale Arrays werden auf dieselbe Weise erstellt wie eindimensionale Arrays. Und Sie greifen auf sie zu wie array[0][1].

var arr = [1, 2, [3, 4], 5];

alert (arr[2][1]); //alerts "4"

Ich bin mir nicht sicher, ob jemand dies beantwortet hat, aber ich fand, dass dies für mich ziemlich gut funktioniert hat. 

var array = [[,],[,]]

z.B: 

var a = [[1,2],[3,4]]

Zum Beispiel für ein 2-dimensionales Array. 

Um ein 2D-Array in JavaScript zu erstellen, können Sie zuerst ein Array erstellen und dann Arrays als Elemente hinzufügen. Diese Methode gibt ein 2D-Array mit der angegebenen Anzahl von Zeilen und Spalten zurück. 

function Create2DArray(rows,columns) {
   var x = new Array(rows);
   for (var i = 0; i < rows; i++) {
       x[i] = new Array(columns);
   }
   return x;
}

um ein Array zu erstellen, verwenden Sie diese Methode wie folgt.

var array = Create2DArray(10,20);

Verwenden Sie Array-Erkenntnisse

In JavaScript 1.7 und höher können Sie Array Complections verwenden, um zweidimensionale Arrays zu erstellen. Sie können die Einträge auch filtern und/oder bearbeiten, während Sie das Array füllen. Sie müssen keine Schleifen verwenden.

var rows = [1, 2, 3];
var cols = ["a", "b", "c", "d"];

var grid = [ for (r of rows) [ for (c of cols) r+c ] ];

/* 
         grid = [
            ["1a","1b","1c","1d"],
            ["2a","2b","2c","2d"],
            ["3a","3b","3c","3d"]
         ]
*/

Sie können ein beliebiges n x m-Array erstellen und durch Aufrufen mit einem Standardwert füllen

var default = 0;  // your 2d array will be filled with this value
var n_dim = 2;
var m_dim = 7; 

var arr = [ for (n of Array(n_dim)) [ for (m of Array(m_dim) default ]] 
/* 
         arr = [
            [0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0],
         ]
*/

Weitere Beispiele und Dokumentationen finden Sie hier .

Bitte beachten Sie, dass dies noch keine Standardfunktion ist.

Mein Ansatz ist der Antwort von @Bineesh sehr ähnlich, jedoch mit einem allgemeineren Ansatz.

Sie können das Double-Array wie folgt deklarieren:

var myDoubleArray = [[]];

Und das Speichern und Zugreifen auf die Inhalte auf folgende Weise:

var testArray1 = [9,8]
var testArray2 = [3,5,7,9,10]
var testArray3 = {"test":123}
var index = 0;

myDoubleArray[index++] = testArray1;
myDoubleArray[index++] = testArray2;
myDoubleArray[index++] = testArray3;

console.log(myDoubleArray[0],myDoubleArray[1][3], myDoubleArray[2]['test'],) 

Dadurch wird die erwartete Ausgabe gedruckt

[ 9, 8 ] 9 123

Für einen Liner Liebhaber Array.from ()

// creates 8x8 array filed with "0"    
const arr2d = Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => "0"));

Eine andere (aus einem Kommentar von dmitry_romanov) benutze Array (). Fill ()

// creates 8x8 array filed with "0"    
const arr2d = Array(8).fill(0).map(() => Array(8).fill("0"));

So erstellen Sie ein nicht spärliches "2D" -Array (x, y), bei dem alle Indizes adressierbar sind und die Werte auf null gesetzt sind:

let 2Darray = new Array(x).fill(null).map(item =>(new Array(y).fill(null))) 

bonus "3D" Array (x, y, z)

let 3Darray = new Array(x).fill(null).map(item=>(new Array(y).fill(null)).map(item=>Array(z).fill(null)))

Variationen und Korrekturen dazu wurden in Kommentaren und an verschiedenen Stellen als Antwort auf diese Frage erwähnt, jedoch nicht als tatsächliche Antwort, deshalb füge ich sie hier hinzu.

Es sollte beachtet werden, dass dies (ähnlich wie die meisten anderen Antworten) eine O (x * y) -Komplexität aufweist, so dass es wahrscheinlich nicht für sehr große Arrays geeignet ist.

Ich habe unten den einfachsten Weg gefunden:

var array1 = [[]];   
array1[0][100] = 5; 

alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);

Hier ist eine schnelle Möglichkeit, ein zweidimensionales Array zu erstellen.

function createArray(x, y) {
    return Array.apply(null, Array(x)).map(e => Array(y));
}

Sie können diese Funktion auch leicht in eine ES5-Funktion umwandeln.

function createArray(x, y) {
    return Array.apply(null, Array(x)).map(function(e) {
        return Array(y);
    });
}

Warum dies funktioniert: Der new Array(n)-Konstruktor erstellt ein Objekt mit einem Prototyp von Array.prototype und weist dann die length des Objekts zu, was zu einem nicht besetzten Array führt. Da es keine echten Mitglieder gibt, können wir die Funktion Array.prototype.map nicht ausführen.

Wenn Sie dem Konstruktor jedoch mehr als ein Argument zur Verfügung stellen, beispielsweise wenn Sie Array(1, 2, 3, 4) ausführen, verwendet der Konstruktor das arguments-Objekt, um ein Array-Objekt korrekt zu instantiieren und zu füllen.

Aus diesem Grund können wir Array.apply(null, Array(x)) verwenden, da die apply-Funktion die Argumente in den Konstruktor verteilt. Zur Verdeutlichung ist das Ausführen von Array.apply(null, Array(3)) gleichbedeutend mit dem Ausführen von Array(null, null, null).

Nun, da wir ein tatsächlich gefülltes Array erstellt haben, müssen wir nur noch map aufrufen und die zweite Ebene (y) erstellen.

Javascript unterstützt keine zweidimensionalen Arrays, stattdessen speichern wir ein Array in einem anderen Array und rufen die Daten von diesem Array ab, abhängig von der Position des Arrays, auf das Sie zugreifen möchten. Denken Sie daran, dass die Nummerierung der Arrays beiZERObeginnt.

Code-Beispiel:

/* Two dimensional array that's 5 x 5 

       C0 C1 C2 C3 C4 
    R0[1][1][1][1][1] 
    R1[1][1][1][1][1] 
    R2[1][1][1][1][1] 
    R3[1][1][1][1][1] 
    R4[1][1][1][1][1] 
*/

var row0 = [1,1,1,1,1],
    row1 = [1,1,1,1,1],
    row2 = [1,1,1,1,1],
    row3 = [1,1,1,1,1],
    row4 = [1,1,1,1,1];

var table = [row0,row1,row2,row3,row4];
console.log(table[0][0]); // Get the first item in the array

Erzeugt darunter eine 5x5-Matrix und füllt sie mit null

var md = [];
for(var i=0; i<5; i++) {
    md.Push(new Array(5).fill(null));
}

console.log(md);

Ich musste eine flexible Array-Funktion erstellen, um nach Bedarf "Datensätze" hinzuzufügen und in der Lage zu sein, sie zu aktualisieren und alle Berechnungen durchzuführen, die ich brauchte, bevor ich sie zur weiteren Verarbeitung an eine Datenbank schickte. Hier ist der Code, hoffe es hilft :).

function Add2List(clmn1, clmn2, clmn3) {
    aColumns.Push(clmn1,clmn2,clmn3); // Creates array with "record"
    aLine.splice(aPos, 0,aColumns);  // Inserts new "record" at position aPos in main array
    aColumns = [];    // Resets temporary array
    aPos++ // Increments position not to overlap previous "records"
}

Fühlen Sie sich frei zu optimieren und/oder auf Fehler aufmerksam zu machen :)

Sie können ein Array von Zeilen zuordnen, wobei jede Zeile ein Array der gleichen Länge ist. Oder Sie können ein eindimensionales Array mit Zeilen- * Spaltenelementen zuweisen und Methoden definieren, um Zeilen-/Spaltenkoordinaten Elementindizes zuzuordnen.

Für welche Implementierung Sie sich auch entscheiden, wenn Sie sie in ein Objekt einschließen, können Sie die Zugriffsmethoden in einem Prototyp definieren, um die Verwendung der API zu vereinfachen. 

Ich habe festgestellt, dass dieser Code für mich funktioniert:

var map = [
    []
];

mapWidth = 50;
mapHeight = 50;
fillEmptyMap(map, mapWidth, mapHeight);

...

function fillEmptyMap(array, width, height) {
    for (var x = 0; x < width; x++) {
        array[x] = [];
        for (var y = 0; y < height; y++) {

            array[x][y] = [0];
        }
    }
}

Ein vereinfachtes Beispiel:

var blocks = [];

blocks[0] = [];

blocks[0][0] = 7;

Ein Liner zum Erstellen eines mit m * n 2 dimensionierten Arrays.

new Array(m).fill(new Array(n).fill(0));

Sie können auch eine Funktion erstellen, um ein 2D-Array wie folgt zu erstellen:

var myTable = [];

function createArray(myLength) {
    myTable = new Array(myLength);
    var cols, rows;
    for (cols = 0; cols < myLength; cols++) {
        myTable[cols] = new Array(myLength);
    }
}

Sie können es aufrufen, indem Sie Folgendes verwenden, wodurch Sie ein 10x10 2D-Array erhalten.

createArray(10);

Sie können mit dieser Methode auch ein 3D-Array erstellen.

Rekursive Funktion zum Erstellen eines mehrdimensionalen Arrays:

var makeArray = function (dims, arr) {          
    if (dims[1] === undefined) {
        return new Array(dims[0]);
    }

    arr = new Array(dims[0]);

    for (var i=0; i<dims[0]; i++) {
        arr[i] = new Array(dims[1]);
        arr[i] = makeArray(dims.slice(1), arr[i]);
    }

    return arr;
}

Erstellen Sie ein 2x3x4x2 4D-Array:

var array = makeArray([2, 3, 4, 2]);    

Ich habe eine Modifikation der Antwort von Matthew Crumley gemacht, um eine mehrdimensionale Array-Funktion zu erstellen. Ich habe die Dimensionen des Arrays hinzugefügt, die als Array-Variable übergeben werden sollen, und es wird eine weitere Variable - value - geben, mit der die Werte der Elemente der letzten Arrays im mehrdimensionalen Array festgelegt werden.

/*
*   Function to create an n-dimensional array
*
*   @param array dimensions
*   @param any type value
*
*   @return array array
 */
function createArray(dimensions, value) {
    // Create new array
    var array = new Array(dimensions[0] || 0);
    var i = dimensions[0];

    // If dimensions array's length is bigger than 1
    // we start creating arrays in the array elements with recursions
    // to achieve multidimensional array
    if (dimensions.length > 1) {
        // Remove the first value from the array
        var args = Array.prototype.slice.call(dimensions, 1);
        // For each index in the created array create a new array with recursion
        while(i--) {
            array[dimensions[0]-1 - i] = createArray(args, value);
        }
    // If there is only one element left in the dimensions array
    // assign value to each of the new array's elements if value is set as param
    } else {
        if (typeof value !== 'undefined') {
            while(i--) {
                array[dimensions[0]-1 - i] = value;
            }
        }
    }

    return array;
}

createArray([]);              // [] or new Array()

createArray([2], 'empty');    // ['empty', 'empty']

createArray([3, 2], 0);       // [[0, 0],
                              //  [0, 0],
                              //  [0, 0]]

Es gibt eine andere Lösung, die Sie nicht zwingt, die Größe des 2D-Arrays vorzugeben, und das ist sehr knapp.

var table = {}
table[[1,2]] = 3 // Notice the double [[ and ]]
console.log(table[[1,2]]) // -> 3

Dies funktioniert, weil [1,2] in einen String umgewandelt wird, der als string key für das table-Objekt verwendet wird.

nodejs + lodash version: 

var _ = require("lodash");
var result = _.chunk(['a', 'b', 'c', 'd', 'e', 'f'], 2);
console.log(result);
console.log(result[2][0]);

Die Ausgabe:

[ [ 'a', 'b' ], [ 'c', 'd' ], [ 'e', 'f' ] ]
e

Array.from({length: rows}).map(e => new Array(columns));

var _field = (function()
{
    var array = [];
    for(var y = 0; y != 3; y++) { array[y] = new Array(5); }
    return array;
})();

// var item = _field[2][4];

Dies wird in einigen Kommentaren erwähnt, aber die Verwendung von Array.fill () hilft beim Erstellen eines 2-D-Arrays:

function create2dArr(x,y) {
    var arr = [];
    for(var i = 0; i < y; i++) {
        arr.Push(Array(x).fill(0));
    }
    return arr; 
}

dies führt zu einem Array der Länge x, y mal im zurückgegebenen Array.

Wenn Sie nur eine 4x4-Matrix haben, schauen Sie sich die DOMMatrix an, es ist einfach zu benutzen, ich kann sagen,

let m = new DOMMatrix(); 
// m.m11, m.m12, m.m13, m.m14, ..., m.m41, m.m42, m.m43, m.m44

Ursprünglich aus verschiedenen Gründen zur Verfügung gestellt, ist es nicht auf node.js verfügbar und nur auf 4x4 beschränkt.

Sie können auch erwägen, ein Auto-Vivification-Objekt anstelle von Arrays für JS zu verwenden. Schauen Sie sich meine Antwort hier an aber bringen Sie hier auch mehr zum überzeugen:

var tree = () => new Proxy({}, { get: (target, name) => name in target ? target[name] : target[name] = tree() });

var t = tree();
t[0][2][3] = 4;
console.log(t[0][2][3]);

Es verwendet neue JS und verhält sich nicht korrekt, wenn Sie es durchlaufen. Seien Sie also vorsichtig.

Werfen Sie einen Blick auf this , wenn Sie einen flexiblen Multi-Dimension-Array-Generator benötigen.

Ein tolles Repository hier . 

• api: masfufa.js

• beispiel: masfufa.html 

Zwei Beispiele werden ausreichen, um diese Bibliothek zu verstehen: 

Beispiel 1:

   /*     | 1 , 2 , 3 |
    * MX= | 4 , 5 , 6 |     Dimensions= 3 x 3
    *     | 7 , 8 , 9 |
    */ 


  jsdk.getAPI('my');
  var A=[1, 2, 3, 4, 5, 6, 7, 8, 9];
  var MX=myAPI.getInstance('masfufa',{data:A,dim:'3x3'});

dann : 

MX.get[0][0]  // -> 1 (first)
MX.get[2][2] //  ->9 (last)

Beispiel 2

   /*      | 1 , 9 , 3 , 4 |
    * MXB= | 4 , 5 , 6 , 2 |     Dimensions= 2 x 4
    *   
    */ 

  var B=[1 , 9 , 3 , 4 , 4 , 5 , 6 , 2];
  var MXB=myAPI.getInstance('masfufa',{data:B,dim:'2x4'});

dann : 

MXB.get[0][0]  // -> 1 (first)
MXB.get[1][3] //  -> 2 (last)
MXB.get[1][2] //  -> 6 (before last)

Was passiert, wenn die Größe des Arrays unbekannt ist? Oder Array sollte dynamisch erstellt und gefüllt werden? Eine alternative Lösung, die sich für mich bewährt hat, ist die Verwendung einer Klasse mit einer statischen 2d-Arrayvariablen, die bei Nichtvorhandensein eines Index im Array diese initiiert:

function _a(x,y,val){
    // return depending on parameters
    switch(arguments.length){
        case 0: return _a.a;
        case 1: return _a.a[x];
        case 2: return _a.a[x][y];
    }

    // declare array if wasn't declared yet
    if(typeof _a.a[x] == 'undefined')
        _a.a[x] = [];

    _a.a[x][y] = val;
}
// declare static empty variable
_a.a = [];

Die Syntax lautet:

_a(1,1,2); // populates [1][1] with value 2
_a(1,1);   // 2 or alternative syntax _a.a[1][1]
_a(1);     // [undefined × 1, 2]
_a.a;      // [undefined × 1, Array[2]]
_a.a.length

 var items = [
      ["January 01", 42.5],
      ["February 01",  44.3],
      ["March 01",  28.7],
      ["April 01",  44.3],
      ["May 01",  22.9],
      ["June 01",  54.4],
      ["July 01",  69.3],
      ["August 01",  19.1],
      ["September 01",  82.5],
      ["October 01",  53.2],
      ["November 01",  75.9],
      ["December 01",  58.7]

    ];
  alert(items[1][0]); // February 01
  alert(items[5][1]); // 54.4

Wenn Sie nach einem 2D-Array für Google-Diagramme suchen, können Sie dies am besten tun 

var finalData = [];
[["key",value], ["2013-8-5", 13.5], ["2013-7-29",19.7]...]

verweis auf Kein gültiges 2D-Array-Google-Diagramm

Dies ist meine Implementierung von Multi-Dimension Array.

Bei diesem Ansatz erstelle ich ein Array mit einer einzigen Dimension

Ich habe eine Prototypfunktion multi zum Array-Objekt hinzugefügt, mit der ein beliebiges Dimensions-Array erstellt werden kann.

Ich habe auch eine Prototypfunktion index zum Array-Objekt hinzugefügt, die verwendet werden kann, um den Index eines linearen Arrays aus mehrdimensionalen Indizes abzurufen.

Erstellen eines Arrays

//Equivalent to arr[I][J][K]..[] in C
var arr = new Array().multi(I,J,K,..);

Zugriff auf Array-Werte an einem beliebigen Index

//Equivalent in C arr[i][j][k];
var vaue = arr[arr.index(i,j,k)];

SNIPPET

/*
   Storing array as single dimension 
   and access using Array.index(i,j,k,...)
*/


Array.prototype.multi = function(){
 this.multi_size = arguments;
 this.multi_len = 1
 for(key in arguments) this.multi_len *=  arguments[key];
 for(var i=0;i<this.multi_len;i++) this.Push(0);
 return this;
}

Array.prototype.index = function(){
   var _size = this.multi_len;
   var temp = 1;
   var index = 0;
   for(key in arguments) {
      temp*=this.multi_size[key];
      index+=(arguments[key]*(_size/temp))
   }
   return index;
}

// Now you can use the multi dimension array
// A 3x3 2D Matrix

var arr2d = new Array().multi(3,3); // A 2D Array
arr2d[arr2d.index(1,1,1)]  = 5;
console.log(arr2d[arr2d.index(1,1,1)]);

// A 3x3x3 3D Matrix

var arr3d = new Array().multi(3,3,3); // a 3D Array
arr3d[arr3d.index(1,1,1)]  = 5;
console.log(arr3d[arr3d.index(1,1,1)]);

// A 4x3x3 4D Matrix
var arr4d = new Array().multi(4,3,3,3); // a 4D Array
arr4d[arr4d.index(4,0,0,1)]  = 5;
console.log(arr4d[arr4d.index(4,0,0,1)]);