Я читал в Интернете, и некоторые места говорят, что это невозможно, некоторые говорят, что это возможно, а затем приводят пример, а другие опровергают пример и т. Д.

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

Подобно ответу 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)]

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

Несмотря на то, что он возвращает желаемый двумерный массив array ( [ [ <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" Array (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

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

Сегодня 2020.02.05 я выполняю тесты на MacO 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 для больших массивов являются средними или быстрыми на 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 array1 = [[]];   
array1[0][100] = 5; 

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

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

Пример кода:

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