Вы просто превращаете каждый элемент в массив в массив.

var x = new Array(10);

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

console.log(x);

Подобно ответу activa, вот функция для создания n-мерного массива:

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)]

Как создать пустой двумерный массив (однострочный)

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

2 и 4 - первое и второе измерения соответственно.

Мы используем Array.from, который может принимать параметр, подобный массиву, и необязательное сопоставление для каждого из элементов.

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

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

Тот же трюк можно использовать для создания массива JavaScript, содержащего 1 ... N

В качестве альтернативы (но более неэффективно на 12% с n = 10,000)

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

Снижение производительности связано с тем, что нам нужно инициализировать значения первого измерения для запуска .map. Помните, что Array не будет распределять позиции, пока вы не укажете это через .fill или прямое присвоение значений.

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

Следовать за

Вот метод, который кажется правильным, но с проблемами.

 Array(2).fill(Array(4)); // BAD! Rows are copied by reference

Хотя он действительно возвращает явно желаемый двумерный массив ([ [ <4 empty items> ], [ <4 empty items> ] ]), есть уловка: массивы первого измерения были скопированы по ссылке. Это означает, что arr[0][0] = 'foo' фактически изменит две строки вместо одной.

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

Javascript имеет только одномерные массивы, но вы можете создавать массивы массивов, как указывали другие.

Следующая функция может использоваться для построения двумерного массива фиксированных размеров:

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

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

  return arr;
}

Количество столбцов не имеет особого значения, потому что не требуется указывать размер массива перед его использованием.

Тогда вы можете просто позвонить:

var arr = Create2DArray(100);

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

Самый простой способ:

var myArray = [[]];

Причина, по которой некоторые говорят, что это невозможно, заключается в том, что двумерный массив на самом деле является просто массивом массивов. Другие комментарии здесь предоставляют совершенно допустимые методы создания двумерных массивов в JavaScript, но наиболее чистая точка зрения будет заключаться в том, что у вас есть одномерный массив объектов, каждый из этих объектов будет одномерным массивом, состоящим из двух элементов.

Итак, в этом причина противоречивых точек зрения.

Мало кто демонстрирует использование push:
Чтобы привнести что-то новое, я покажу вам, как инициализировать матрицу некоторым значением, например: 0 или пустой строкой "".
Напоминаем, что если у вас есть 10 элементов array, в javascript последний индекс будет 9!

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

примеры использования:

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

Двухстрочный:

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

Он сгенерирует массив a длиной 10, заполненный массивами. (Push добавляет элемент в массив и возвращает новую длину)

Кажется, самый разумный ответ

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

Обратите внимание, что мы не можем напрямую заполнить строки, поскольку fill использует неглубокий конструктор копирования, поэтому все строки будут совместно использовать одну и ту же память ... вот пример, который демонстрирует, как каждая строка будет разделен (взят из других ответов):

// 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);

Самый простой способ:

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'

Вот чего я добился:

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

Это написало меня бинеешкумар

Двумерные массивы создаются так же, как и одномерные массивы. И вы обращаетесь к ним как array[0][1].

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

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

Представление

Сегодня 2020.02.05 я провожу тесты на MacOs HighSierra 10.13.6 на Chrome v79.0, Safari v13.0.4 и Firefox v72.0 для выбранных решений.

Выводы для неинициализированного 2-мерного массива

• эзотерическое решение {}/arr[[i,j]] (N) является самым быстрым для больших и малых массивов, и похоже, что это хороший выбор для больших разреженных массивов
• решения, основанные на for-[]/while (A, G), быстры и подходят для небольших массивов.
• решения for-[] (B, C) быстрые, и они являются хорошим выбором для больших массивов
• решения, основанные на Array..map/from/fill (I, J, K, L, M), довольно медленные для небольших массивов и довольно быстрые для больших массивов
• Удивительно, но for-Array(n) (B, C) намного медленнее в сафари, чем for-[] (A)
• удивительно for-[] (A) для большого массива работает медленно во всех браузерах
• решения K медленны для небольших массивов для всех браузеров
• решения A, E, G медленны для больших массивов для всех браузеров
• решение M является самым медленным для всех массивов во всех браузерах

Выводы для инициализированного двумерного массива

• решения на основе for/while (A, B, C, D, E, G) самые быстрые / довольно быстрые для небольших массивов во всех браузерах
• решения на основе for (A, B, C, E) самые быстрые / довольно быстрые для больших массивов во всех браузерах
• решения на основе Array..map/from/fill (I, J, K, L, M) являются средними или медленными для небольших массивов во всех браузерах.
• решения F, G, H, I, J, K, L для больших массивов - средние или быстрые в Chrome и Safari, но самые медленные в firefox.
• эзотерическое решение {}/arr[[i,j]] (N) самое медленное для малых и больших массивов во всех браузерах

Подробности

Проверить решения, которые не заполняют (не инициализируют) выходной массив

Тестируем скорость решений для

• небольшие массивы (12 элементов) - вы можете выполнять тесты на своей машине ЗДЕСЬ
• большие массивы (1 миллион элементов) массивы - вы можете выполнять тесты на своей машине ЗДЕСЬ

function A(r) {
  var arr = [];
  for (var i = 0; i < r; i++) arr[i] = [];
  return arr;
}

function B(r, c) {
  var arr = new Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = new Array(c);
  return arr;
}

function C(r, c) {
  var arr = Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = Array(c);
  return arr;
}

function D(r, c) {
  // strange, but works
  var arr = [];
  for (var i = 0; i < r; i++) {
    arr.push([]);
    arr[i].push(Array(c));
  }
  return arr;
}

function E(r, c) {
  let array = [[]];
  for (var x = 0; x < c; x++) {
    array[x] = [];
    for (var y = 0; y < r; y++) array[x][y] = [0];
  }
  return array;
}

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

    arr = Array(dims[0]);

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

    return arr;
  }
  return makeArray([r, c]);
}

function G(r) {
  var a = [];
  while (a.push([]) < r);
  return a;
}

function H(r,c) {
  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;
  }
  return createArray(r,c);
}

function I(r, c) {
  return [...Array(r)].map(x => Array(c));
}

function J(r, c) {
  return Array(r).fill(0).map(() => Array(c));
}

function K(r, c) {
  return Array.from(Array(r), () => Array(c));
}

function L(r, c) {
  return Array.from({length: r}).map(e => Array(c));
}

function M(r, c) {
  return Array.from({length: r}, () => Array.from({length: c}, () => {}));
}

function N(r, c) {
  return {}
}



// -----------------------------------------------
// SHOW
// -----------------------------------------------

log = (t, f) => {
  let A = f(3, 4); // create array with 3 rows and 4 columns
  A[1][2] = 6 // 2-nd row 3nd column set to 6
  console.log(`${t}[1][2]: ${A[1][2]}, full: ${JSON.stringify(A).replace(/null/g,'x')}`);
}

log2 = (t, f) => {
  let A = f(3, 4); // create array with 3 rows and 4 columns
  A[[1,2]] = 6 // 2-nd row 3nd column set to 6
  console.log(`${t}[1][2]: ${A[[1,2]]}, full: ${JSON.stringify(A).replace(/null/g,'x')}`);
}

log('A', A);
log('B', B);
log('C', C);
log('D', D);
log('E', E);
log('F', F);
log('G', G);
log('H', H);
log('I', I);
log('J', J);
log('K', K);
log('L', L);
log('M', M);
log2('N', N);

This is presentation of solutions - not benchmark

Проверка решений, заполняющих (инициализирующих) выходной массив

Тестируем скорость решений для

• небольшие массивы (12 элементов) - вы можете выполнять тесты на своей машине ЗДЕСЬ
• большие массивы (1 миллион элементов) массивы - вы можете выполнять тесты на своей машине ЗДЕСЬ

function A(r, c, def) {
  var arr = [];
  for (var i = 0; i < r; i++) arr[i] = Array(c).fill(def);
  return arr;
}

function B(r, c, def) {
  var arr = new Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = new Array(c).fill(def);
  return arr;
}

function C(r, c, def) {
  var arr = Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = Array(c).fill(def);
  return arr;
}

function D(r, c, def) {
  // strange, but works
  var arr = [];
  for (var i = 0; i < r; i++) {
    arr.push([]);
    arr[i].push(Array(c));
  }
  for (var i = 0; i < r; i++) for (var j = 0; j < c; j++) arr[i][j]=def
  return arr;
}

function E(r, c, def) {
  let array = [[]];
  for (var x = 0; x < c; x++) {
    array[x] = [];
    for (var y = 0; y < r; y++) array[x][y] = def;
  }
  return array;
}

function F(r, c, def) {
  var makeArray = function(dims, arr) {
    if (dims[1] === undefined) {
      return Array(dims[0]).fill(def);
    }

    arr = Array(dims[0]);

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

    return arr;
  }
  return makeArray([r, c]);
}

function G(r, c, def) {
  var a = [];
  while (a.push(Array(c).fill(def)) < r);
  return a;
}

function H(r,c, def) {
  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).fill(def);
    }

    return arr;
  }
  return createArray(r,c);
}

function I(r, c, def) {
  return [...Array(r)].map(x => Array(c).fill(def));
}

function J(r, c, def) {
  return Array(r).fill(0).map(() => Array(c).fill(def));
}

function K(r, c, def) {
  return Array.from(Array(r), () => Array(c).fill(def));
}

function L(r, c, def) {
  return Array.from({length: r}).map(e => Array(c).fill(def));
}

function M(r, c, def) {
  return Array.from({length: r}, () => Array.from({length: c}, () => def));
}

function N(r, c, def) {
  let arr={};
  for (var i = 0; i < r; i++) for (var j = 0; j < c; j++) arr[[i,j]]=def;
  return arr;
}



// -----------------------------------------------
// SHOW
// -----------------------------------------------

log = (t, f) => {
  let A = f(1000,1000,7); // create array with 1000 rows and 1000 columns, 
                          // each array cell initilised by 7
  A[800][900] = 5         // 800nd row and 901nd column set to 5
  console.log(`${t}[1][2]: ${A[1][2]}, ${t}[800][901]: ${A[800][900]}`);
}

log2 = (t, f) => {
  let A = f(1000,1000,7); // create array with 1000 rows and 1000 columns, 
                          // each array cell initilised by 7
  A[[800,900]] = 5            // 800nd row 900nd column set to 5
  console.log(`${t}[1][2]: ${A[[1,2]]}, ${t}[800][900]: ${A[[800,900]]}`);
}

log('A', A);
log('B', B);
log('C', C);
log('D', D);
log('E', E);
log('F', F);
log('G', G);
log('H', H);
log('I', I);
log('J', J);
log('K', K);
log('L', L);
log('M', M);
log2('N', N);

This is presentation of solutions - not benchmark

Я не уверен, что кто-нибудь ответил на это, но я обнаружил, что это сработало для меня очень хорошо -

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

eg:

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

Например, для двумерного массива.

Чтобы создать нерезкий «2D» массив (x, y) со всеми адресуемыми индексами и значениями, установленными на null:

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

бонусный "3D" массив (x, y, z)

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

Вариации и исправления были упомянуты в комментариях и в различных пунктах в ответ на этот вопрос, но не как фактический ответ, поэтому я добавляю его здесь.

Следует отметить, что (аналогично большинству других ответов) это имеет временную сложность O (x * y), поэтому, вероятно, он не подходит для очень больших массивов.

Чтобы создать 2D-массив в javaScript, мы можем сначала создать массив, а затем добавить массивы в качестве его элементов. Этот метод вернет 2D-массив с заданным количеством строк и столбцов.

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

чтобы создать массив, используйте этот метод, как показано ниже.

var array = Create2DArray(10,20);

Для любителей одного лайнера Array.from ()

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

Другой (из комментария dmitry_romanov) использует Array () .fill ()

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

Использование ES6 + оператора распространения («вдохновленный» автор: InspiredJW, ответ :))

// same as above just a little shorter
const arr2d = [...Array(8)].map(() => Array(8).fill("0"))

Чтобы создать массив 4x6, просто сделайте это

const x = [...new Array(6)].map(elem => new Array(4))

Обычно рекомендуется начинать с пустого массива, а не заполнять w случайными значениями. (Обычно вы объявляете массив как const x = [] в 1D, поэтому лучше начинать w пустым в 2D.)

Array(m).fill(v).map(() => Array(n).fill(v))

Вы можете создать двухмерный массив m x n с начальным значением m, а n может быть любым числом, v может быть любым значением string, number, undefined.

Один подход может быть var a = [m][n]

Использовать массивы понимания

В JavaScript 1.7 и выше вы можете использовать понимание массивов для создания двухмерных массивов. Вы также можете фильтровать и / или манипулировать записями при заполнении массива и не использовать циклы.

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"]
         ]
*/

Вы можете создать любой n x m массив и заполнить его значением по умолчанию, вызвав

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],
         ]
*/

Дополнительные примеры и документацию можно найти на здесь.

Обратите внимание, что это еще не стандартная функция.

Мой подход очень похож на ответ @Bineesh, но с более общим подходом.

Вы можете объявить двойной массив следующим образом:

var myDoubleArray = [[]];

И хранение и доступ к содержимому следующим образом:

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'],) 

Это напечатает ожидаемый результат

[ 9, 8 ] 9 123

Я нашел ниже самый простой способ:

var array1 = [[]];   
array1[0][100] = 5; 
    
alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);

Размеры строки и столбца в массиве известны только во время выполнения, тогда следующий метод можно использовать для создания динамический 2-мерный массив.

    var num = '123456';
    var row = 3; // Known at run time
    var col = 2; // Known at run time
    var i = 0;
    
    var array2D = [[]];
    for(var r = 0; r < row; ++r)
    {
        array2D[r] = [];
        for(var c = 0; c < col; ++c)
        {
            array2D[r][c] = num[i++];
        }
    }
    console.log(array2D); 
    // [[ '1', '2' ], 
    //  [ '3', '4' ], 
    //  [ '5', '6' ]]
    
    console.log(array2D[2][1]); // 6

Javascript не поддерживает двухмерные массивы, вместо этого мы храним массив внутри другого массива и извлекаем данные из этого массива в зависимости от того, к какой позиции этого массива вы хотите получить доступ. Помните, что нумерация массива начинается с ZERO.

Пример кода:

/* 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

ES6 +, ES2015 + могут сделать это еще проще

Создание массива 3 x 2, заполненного истиной

[...Array(3)].map(item => Array(2).fill(true))

Мне пришлось создать гибкую функцию массива, чтобы добавлять к нему «записи» по мере необходимости и иметь возможность обновлять их и выполнять все необходимые вычисления до того, как я отправлю его в базу данных для дальнейшей обработки. Вот код, надеюсь, поможет :).

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

Не стесняйтесь оптимизировать и / или указывать на ошибки :)

Вот быстрый способ создать двумерный массив.

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

Вы также можете легко превратить эту функцию в функцию ES5.

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

Почему это работает: конструктор new Array(n) создает объект с прототипом Array.prototype, а затем присваивает объекту length, в результате чего получается незаполненный массив. Из-за отсутствия фактических членов мы не можем запустить на нем функцию Array.prototype.map.

Однако, когда вы предоставляете конструктору более одного аргумента, например, когда вы делаете Array(1, 2, 3, 4), конструктор будет использовать объект arguments для правильного создания и заполнения объекта Array.

По этой причине мы можем использовать Array.apply(null, Array(x)), потому что функция apply распространит аргументы в конструктор. Для пояснения, выполнение Array.apply(null, Array(3)) эквивалентно выполнению Array(null, null, null).

Теперь, когда мы создали фактический заполненный массив, все, что нам нужно сделать, это вызвать map и создать второй слой (y).

Один лайнер для создания двумерного массива m * n, заполненного 0.

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

Есть еще одно решение, которое не заставляет вас заранее определять размер 2-го массива, и оно очень краткое.

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

Это работает, потому что [1,2] преобразуется в строку, которая используется как строковый ключ для объекта table.

Ниже одного создает матрицу 5x5 и заполняет их null

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

console.log(md);

Вы можете выделить массив строк, где каждая строка представляет собой массив одинаковой длины. Или вы можете выделить одномерный массив с элементами строки * столбцы и определить методы для сопоставления координат строки / столбца с индексами элементов.

Какую бы реализацию вы ни выбрали, если вы заключите ее в объект, вы можете определить методы доступа в прототипе, чтобы упростить использование API.

Я обнаружил, что у меня работает этот код:

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

Упрощенный пример:

var blocks = [];

blocks[0] = [];

blocks[0][0] = 7;

Я не поклонник решений ES6, использующих .fill(). Некоторые из них могут работать, но дополнительные пяльцы, позволяющие избежать проблем с копированием по ссылке, делают их не интуитивно понятными.

Предлагаемый мной подход ES6 состоит в том, чтобы полностью использовать оператор распространения как для внешних, так и для внутренних массивов. Про ИМО легче рассуждать.

[...Array(3)].map(() => [...Array(4)])

Если вам нужно установить начальное значение, вы добавляете .map() при создании внутреннего массива:

[...Array(3)].map(() => [...Array(4)].map(() => 0))

Наконец, типобезопасная служебная функция TypeScript:

export const createMultiDimensionalArray = <T>(
  n: number,
  m: number,
  initialVal?: T,
): T[][] => {
  const matrix = [...Array(n)].map(() => [...Array(m)]);
  return initialVal === undefined
    ? matrix
    : matrix.map(r => r.map(() => initialVal));
};

Примеры его использования:

const a = createMultiDimensionalArray(1, 2);
a[1][2] = 3;     // Works

const b = createMultiDimensionalArray(2, 3, false);
b[1][2] = true;  // Works
b[1][2] = 3;     // Error: Type '3' is not assignable to type 'boolean'.

Я внес изменения в ответ Мэтью Крамли для создания функции многомерного массива. Я добавил размеры массива, который будет передаваться как переменная массива, и будет еще одна переменная - value, которая будет использоваться для установки значений элементов последних массивов в многомерном массиве.

/*
*   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]]

Рекурсивная функция для создания многомерного массива:

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

Создайте 4D-массив 2x3x4x2:

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

Вы также можете создать функцию для создания 2D-массива следующим образом:

var myTable = [];

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

Вы можете вызвать его, используя следующее, что даст вам 2D-массив 10x10.

createArray(10);

Вы также можете создать трехмерный массив, используя этот метод.

nodejs + версия lodash:

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

Выход:

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

Если вам нужен 2D-массив для диаграмм Google, лучший способ сделать это -

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

ссылаясь на Недействительную диаграмму Google с двумерным массивом

Что произойдет, если размер массива неизвестен? Или массив нужно динамически создавать и заполнять? Альтернативное решение, которое сработало для меня, - использовать класс со статической переменной массива 2d, которая в случае отсутствия индекса в массиве инициирует его:

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 = [];

Синтаксис будет таким:

_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

Замечательный репозиторий здесь.

• api: masfufa.js

• образец: masfufa.html

Для понимания этой библиотеки будет достаточно двух примеров:

Пример 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'});

тогда :

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

Пример 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'});

тогда :

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

Об этом упоминается в нескольких комментариях, но использование Array.fill () поможет построить двумерный массив:

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

это приведет к массиву длины x, y раз в возвращенном массиве.

Это моя реализация многомерного массива.

В этом подходе я создаю одномерный массив

Я добавил функцию-прототип multi к объекту Array, который можно использовать для создания любого массива измерений.

Я также добавил функцию-прототип index к объекту Array, который можно использовать для получения индекса в линейном массиве из многомерных индексов.

Создание массива

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

Доступ к значению массива по любому индексу

//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)]);

Если вам нужна только матрица 4x4, взгляните на DOMMatrix, легко могу сказать,

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

Изначально добавленный по разным причинам, он недоступен на node.js и ограничен только 4x4.

Также вы можете рассмотреть возможность использования объекта авто-вивификации вместо массивов для JS, взгляните на мой ответ здесь, но также для получения дополнительной информации убеждать:

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]);

Он использует новый JS и работает некорректно, когда вы повторяете его, поэтому будьте осторожны с ним.

Также посмотрите this, если вам нужен гибкий генератор многомерных массивов.

Создает n-мерный матричный массив для Java Script с начальным значением по умолчанию 0.

function arr (arg, def = 0){
      if (arg.length > 2){
        return Array(arg[0]).fill().map(()=>arr(arg.slice(1)));
      } else {
        return Array(arg[0]).fill().map(()=>Array(arg[1]).fill(def));
      }
    }

// Simple Usage of 4 dimensions
var s = arr([3,8,4,6])

// Use null default value with 2 dimensions
var k = arr([5,6] , null)