Я читав в Інтернеті, а деякі місця кажуть, що це неможливо, деякі кажуть, що це є, а потім наводять приклад, а інші спростовують приклад тощо.

1. Як я можу оголосити двовимірний масив у JavaScript? (припускаючи, що це можливо)

2. Як я отримав би доступ до своїх членів? ( myArray[0][1]або myArray[0,1]?)

Ви просто робите кожен елемент у масиві масиву.

var x = new Array(10);

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

console.log(x);

Подібно до відповіді активації, ось функція створення 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)]

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

Як створити порожній двовимірний масив (однорядковий)

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, але найчистішою точкою зору буде те, що у вас є одновимірний масив об'єктів, кожен з цих об'єктів був би одновимірним масивом, що складається з двох елементів.

Отже, це причина суперечливих точок зору.

Мало хто показує використання push:
Щоб принести щось нове, я покажу вам, як ініціалізувати матрицю з деяким значенням, наприклад: 0 або порожнім рядком "".
Нагадуючи, що якщо у вас масив 10 елементів, у 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);

Зауважте, що ми не можемо безпосередньо заповнювати рядки, оскільки для використання використовується неглибокий конструктор копій, тому всі рядки матимуть однакову пам’ять ... ось приклад, який демонструє, як би поділявся кожен рядок (взято з інших відповідей):

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

Я не впевнений, чи хтось відповів на це, але я вважав, що це спрацювало для мене досить добре -

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

наприклад:

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

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

Щоб створити 2D масив в javaScript, ми можемо спершу створити масив, а потім додати масиви як його елементи. Цей метод поверне двовимірний масив із заданою кількістю рядків та стовпців.

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

Щоб створити нерозріджений "2D" масив (x, y) з усіма індексами, адресованими та значеннями, встановленими на нуль:

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), тому, ймовірно, не підходить для дуже великих масивів.

Використовуйте розуміння масиву

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

Більше прикладів та документації можна знайти тут .

Зверніть увагу, що це ще не стандартна функція .

Для одного любителя лайнера 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"))

Мій підхід дуже схожий на відповідь @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);

Продуктивність

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

Висновки для неініціалізованого 2d масиву

• езотеричне рішення {}/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 є найповільнішим для всіх масивів у всіх браузерах

Висновки для ініціалізованого 2d масиву

• рішення на основі 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 для великих масивів є середніми або швидкими для хрому та сафарі, але найповільнішими для 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

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, наповненого true

[...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).

Внизу однієї створюється матриця розміром 5х5 і заповнює їх null

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

console.log(md);

Розміри рядків і стовпців масиву, відомі лише під час виконання, тоді для створення динамічного 2d масиву можна використовувати наступний метод .

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

Є ще одне рішення, яке не змушує вас заздалегідь визначити розмір 2d масиву, і це дуже стисло.

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

Це працює тому, що [1,2]перетворюється в рядок, який використовується як рядовий ключ для tableоб'єкта.

Щоб створити масив 4x6, просто зробіть це

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