Как я могу создать двумерный массив в JavaScript?

1137

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

  1. Как мне объявить двумерный массив в JavaScript? (при условии, что это возможно)

  2. Как бы я получить доступ к его членам? ( myArray[0][1]или myArray[0,1]?)

Диего
источник
21
Предполагая несколько педантичное определение, технически невозможно создать 2d-массив в javascript. Но вы можете создать массив массивов, что равносильно тому же.
IJ Кеннеди
10
К вашему сведению ... когда вы заполняете массив большим количеством массивов, используя var arr2D = new Array(5).fill(new Array(3));каждый элемент Array (5), он будет указывать на один и тот же Array (3). Поэтому лучше использовать цикл for для динамического заполнения подмассивов.
Джош Стриблинг
51
a = Array(5).fill(0).map(x => Array(10).fill(0))
Longfei Wu
2
Другими словами, fillне вызывает new Array(3)для каждого индекса заполняемого массива, так как это не лямбда-выражение или что-то подобное, например, приведенный выше комментарий Longfei Wu, который изначально заполняет массив нулями, затем использует функцию map с лямбда-выражением для заполните каждый элемент новым массивом. Функция fill просто заполняет массив именно тем, что вы ему говорите. Имеет ли это смысл? Для получения дополнительной информации о mapфункции см .: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Джош Стриблинг
2
@kalehmann, это хорошо: meta.stackoverflow.com/a/252017/2311074 If the new question is a better question or has better answers, then vote to close the old one as a duplicate of the new one.
Адам

Ответы:

1232

var items = [
  [1, 2],
  [3, 4],
  [5, 6]
];
console.log(items[0][0]); // 1
console.log(items[0][1]); // 2
console.log(items[1][0]); // 3
console.log(items[1][1]); // 4
console.log(items);

Ballsacian1
источник
32
Таким образом, было бы трудно инициализировать большой многомерный массив. Однако эту функцию можно использовать для создания пустого многомерного объекта с размерами, указанными в качестве параметров.
Андерсон Грин,
2
@AndersonGreen Хорошо, что вы упомянули ссылку для тех, кто интересуется решением для многомерных массивов, но вопрос и ответ Ballsacian1 касаются массива «2D», а не массива «multi-D»
evilReiko
Вы должны пройти через все это ... например, оповещение (items [0] [1]); // 2 и т. Д.
Дойс
1
@SashikaXP, это не работает для первых индексов, кроме 0.
Michael Franzl
1
Вопрос в том, как объявить двумерный массив. Вот что я искал и нашел этот и последующие ответы, которые не различают разницу между объявлениями и инициализацией. Также есть объявление с известной длиной или неограниченным, ни одно из которых не обсуждается.
Крис
444

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

var x = new Array(10);

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

console.log(x);

Суфьян
источник
6
Могут ли они использовать такие вещи, как строки для своих ключей и значений? myArray ['Book'] ['item1']?
Диего
42
@ Диего, да, но это не то, для чего предназначены массивы. Лучше использовать объект, когда ваши ключи являются строками.
Мэтью Крамли
10
Мне нравится этот пример лучше, чем принятый ответ, потому что это может быть реализовано для массивов динамического размера, например, new Array(size)где sizeесть переменная.
Вариадизм
1
не работает - ошибка при назначении. Как этот ответ получил 280 лайков, если он бесполезен?
Гарго
1
Это работает, спасибо. Вы можете увидеть пример Гарго jsfiddle.net/matasoy/oetw73sj
Матасой
198

Подобно ответу 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)]
Мэтью Крамли
источник
2
Может ли это создать 4-х мерный массив?
trusktr
4
@trusktr: Да, вы можете создать столько измерений, сколько захотите (в рамках ограничений памяти). Просто пройдите по длине четырех измерений. Например, var array = createArray(2, 3, 4, 5);.
Мэтью Крамли
4
Лучший ответ ! Однако я бы не рекомендовал использовать его с 0 или 1 параметрами (бесполезно)
Apolo
2
@BritishDeveloper Да. Это 5D массив с каждой длиной в 5:[[[[[null,null],[null,null]],[[null,null],[null,null]]],[[[null,null],[null,null]],[[null,null],[null,null]]]],[[[[null,null],[null,null]],[[null,null],[null,null]]],[[[null,null],[null,null]],[[null,null],[null,null]]]]]
haykam
2
@haykam жаль тратить ваше время - я был саркастичен: /
BritishDeveloper
84

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;
// ...
Филипп Лейбер
источник
Я хочу сделать 2-мерный массив, который будет представлять колоду карт. Это будет 2-мерный массив, который содержит значение карты и затем в масти. Что было бы самым простым способом сделать это.
Даг Хауф,
1
function Create2DArray (lines) {var arr = []; for (var i = 0; i <row; i ++) {arr [i] = []; } return arr; } функция print (deck) {for (t = 1; t <= 4; t ++) {for (i = 1; i <= 13; i ++) {document.writeln (deck [t] [i]); }}} fucntion fillDeck (d) {for (t = 1; t <= 4; t ++) {myCardDeck [t] [1] = t; for (i = 1; i <= 13; i ++) {myCardDeck [t] [i] = i; }}} function loadCardDeck () {var myCardDeck = Create2DArray (13); fillDeck (myCardDeck); печать (myCardDeck); }
Даг Хауф,
2
@Doug: Вы на самом деле хотите одномерный массив объектов с 2 атрибутами. var deck = []; колода [0] = {лицо: 1, костюм: 'H'};
TeasingDart
@ DougHauf это миниатюрный 2D-массив ?? : P: D
Махи
78

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

var myArray = [[]];
Фред
источник
29
который является двумерным массивом
Маурицио в Дании
15
Да, осторожно с этим. Назначение myArray [0] [что угодно] хорошо, но попробуйте установить myArray [1] [что угодно], и он жалуется, что myArray [1] не определен.
Филипп
22
@Philip вы должны установить myArray[1]=[];перед назначениемmyArray[1][0]=5;
182764125216
4
Имейте в виду , что это не «создает пустой массив 1x1», как писал @AndersonGreen. Он создает массив «1x0» (т.е. 1 строка, содержащая массив с 0 столбцами). myArray.length == 1и myArray[0].length == 0. Что тогда дает неправильный результат, если вы затем скопируете в него «действительно пустой» массив «0x0».
JonBrave
3
@ 182764125216 это было знание дня для меня. Спасибо :)
th3pirat3
76

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

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

zurfyx
источник
Я предлагаю это:Array.from({length:5}, () => [])
vsync
Здесь субъективно, но этот ответ (первый и второй внутри него) кажется лучшим балансом краткого, быстрого и современного.
Брейди Доулинг
@zurfyx любая идея, или кто-нибудь знает, почему веб-шторм жалуется на это? Кажется, array.from продолжает оставлять значения как неопределенные, и тогда я не могу работать с созданным массивом, даже несмотря на то, что фрагмент отлично работает здесь на stackoverflow
FaultyJuggler
46

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

Это и есть причина противоречивых точек зрения.

Джеймс Конильяро
источник
42
Нет, это не так. В некоторых языках вы можете иметь многомерные массивы, такие как string[3,5] = "foo";. Это лучший подход для некоторых сценариев, поскольку ось Y на самом деле не является дочерней по отношению к оси X.
Рафаэль Соареш
3
Как только он попадает в базовый машинный код, все тензоры измерения> 1 являются массивами массивов, на каком бы языке мы ни говорили. Стоит помнить об этом по причинам оптимизации кэша. Любой приличный язык, который серьезно подходит для числовых вычислений, позволит вам выровнять вашу многомерную структуру в памяти так, чтобы ваши наиболее часто используемые измерения сохранялись непрерывно. Вспоминаются Numpy, Fortran и C Python. Действительно, есть случаи, когда по этой причине стоит уменьшить размерность на несколько структур.
Томас Браун
Компьютеры не имеют понятия о размерах. Существует только 1 измерение, адрес памяти. Все остальное является условным обозначением в пользу программиста.
TeasingDart
3
@ThomasBrowne Не совсем. «Массивы массивов» требуют некоторого хранения для размеров внутренних массивов (они могут отличаться) и разыменования другого указателя, чтобы найти место, где хранится внутренний массив. В любом «приличном» языке многомерные массивы отличаются от зубчатых массивов, потому что они представляют собой разные структуры данных как таковые. (И запутанная часть состоит в том, что массивы C многомерны, даже если они проиндексированы с помощью синтаксиса [a] [b].)
polkovnikov.ph
33

Мало кто демонстрирует использование 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
Серхио Абреу
источник
Я удаляю last for(который устанавливает значение по умолчанию) из вашей процедуры и записываю m=matrix(3,4); m[1][2]=2; console.log(JSON.stringify(m));- и мы получаем очень странную матрицу (слишком много вложенных) - вы исправляете ее в последнем шаге for-defaultValue, но я думаю, что вы можете переписать процедуру, чтобы использовать меньше вложенных массивов до того, как установка значений по умолчанию.
Камиль Келчевски
27

Два лайнера:

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

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

domenukk
источник
13
Один лайнер: for (var a=[]; a.push([])<10;);?
Берги
@Bergi будет ли переменная все еще определяться в следующей строке ..?
StinkyCat
1
@StinkyCat: Да, вот как это varработает. Это всегда функционально ограничено.
Берги
Я знаю, поэтому ваша однострочная в этом случае бесполезна: вы не можете «получить доступ к ее членам» (проверьте вопрос)
StinkyCat
1
Доменюк и @ Берги, вы оба правы. Я попробовал это, и я могу получить доступ после. Приношу извинения! и спасибо, это может быть уроком для меня;)
StinkyCat
24

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

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);
Франческо Донди
источник
Это должно быть на самом верху. Я сделал нечто подобное, используя Array.apply(null, Array(nrows))это, но это гораздо элегантнее.
Димигель
В связи с этим мой последний комментарий ... Internet Explorer и Opera не поддерживают fill. Это не будет работать в большинстве браузеров.
Димигель
В этом случае @dimgl Fill можно эмулировать постоянной картой:, Array(nrows).map(() => 0)или,Array(nrows).map(function(){ return 0; });
Conor O'Brien
20

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

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'
Чичарито
источник
18

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

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

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

Bineesh
источник
2
Обратите внимание, как вы можете получить доступ только к индексу 0 родительского массива. Это не так полезно, как то, что позволяет вам установить, например, appVar [5] [9] = 10; ... вы получите 'Невозможно установить свойство "9" из неопределенного "с этим.
RaisinBranCrunch
Но appVar[1][4] = "bineesh";неправильно, как это решить?
Ганк
16

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

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

alert (arr[2][1]); //alerts "4"
TJ L
источник
14

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

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

например:

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

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

Uchenna
источник
Как я могу сделать это динамически? Я хочу, чтобы внутренние массивы с разными размерами.
Алап
3
Вам не нужны дополнительные запятые var array = [[],[]], достаточно.
Кая Тост
13

Чтобы создать 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);
простое число
источник
2
Пожалуйста, добавьте в свой ответ некоторую пояснительную информацию, показывающую, как она работает и почему она решает проблему. Это поможет другим, кто найдет эту страницу в будущем
Наш Человек в Бананах
Когда вам нужен массив, предварительно инициализированный определенным количеством столбцов в Javascript? Вы также можете получить доступ к n-му элементу массива [].
Доменукк
Я заметил, что функция начинается с заглавной буквы C, что (согласно некоторым соглашениям) предполагает, что это будет конструктор Function, и вы будете использовать его с ключевым словом new. Может быть, очень незначительное и несколько самоуверенное, но я бы все-таки предложил слово без заглавных букв.
Хати
12

Чтобы создать не разреженный массив «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), поэтому, вероятно, не подходит для очень больших массивов.

Джастин ом
источник
1
будьте осторожны, потому что fillустановите то же значение. если поменять nullна `объект, это будет один и тот же объект в каждом столбце
Станислав Майоров
@StanislavMayorov Если вы хотите установить значение каждой ячейки, просто используйте один и тот же трюк:let 2Darray = new Array(x).fill(null).map(item =>(new Array(y).fill(null).map(cell =>(yourValueHere))))
haykam
10

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

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

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

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

Тим Хэллибертон
источник
Быстрая проверка Google здесь ... ага ... forзаявление все еще в цикле ...
Pimp Trizkit
1
Это не поддерживается ни одним браузером - ЗДЕСЬ ?
Камиль Келчевски
10

Для любителей одного лайнера 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"))
my-
источник
2
мы можем удалить 0в первой fill()функции:const arr2d = Array(8).fill().map(() => Array(8).fill("0"));
Jinsong Li
8

Мой подход очень похож на ответ @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
Александр
источник
8

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

Сегодня 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 миллион элементов) - вы можете выполнять тесты на своем компьютере ЗДЕСЬ

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

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

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

введите описание изображения здесь

Камил Келчевски
источник
7

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

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

alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);
GMsoF
источник
array1[1][100] = 666;броскиUncaught TypeError: Cannot set property '100' of undefined
Камиль Келчевски
@ KamilKiełczewski вы правы, похоже, это инициировать только для первого массива массива, для второго, прежде чем вы это сделаете array1[1][100] = 666;, вам нужно сделать это array1[1] = [];.
GMsoF
6

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
стог
источник
6

var playList = [
  ['I Did It My Way', 'Frank Sinatra'],
  ['Respect', 'Aretha Franklin'],
  ['Imagine', 'John Lennon'],
  ['Born to Run', 'Bruce Springsteen'],
  ['Louie Louie', 'The Kingsmen'],
  ['Maybellene', 'Chuck Berry']
];

function print(message) {
  document.write(message);
}

function printSongs( songs ) {
  var listHTML;
  listHTML = '<ol>';
  for ( var i = 0; i < songs.length; i += 1) {
    listHTML += '<li>' + songs[i][0] + ' by ' + songs[i][1] + '</li>';
  }
  listHTML += '</ol>';
  print(listHTML);
}

printSongs(playList);

antelove
источник
6

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


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

[...Array(3)].map(item => Array(2).fill(true))
jwchang
источник
Мне нужно признаться. Я «принял» ваш ответ и добавил в мой список однострочников.
my-
5

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

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

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

CJ Мендес
источник
Как насчет просто aLine.push([clmn1, clmn2, clmn3]);?
Сутенер Тризкит
5

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

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

dimiguel
источник
5

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

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

console.log(md);

zeah
источник
3
Этот ответ неверен. Он создаст массив с таким же заполнением массива в своих слотах. md[1][0] = 3 и все остальные элементы тоже обновляются
Qiang
5

Размеры строк и столбцов массива известны только во время выполнения, тогда для создания динамического 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
SridharKritha
источник
4

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

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

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

Oli
источник
Один этот ответ заставляет меня не хотеть связываться с мусором, который является «многомерным» массивом в JavaScript, даже если у меня есть очень элегантное решение. Это также показывает, что все остальные на самом деле вообще не создают многомерных массивов. «массив» в JavaScript; этот ответ будет полностью "имитировать" массив бесконечного размера псевдо-бесконечного размера произвольных размеров и содержимого. Все остальные ответы на основе рекурсии и цикла имеют гораздо более низкий верхний предел размера структуры массива, который они могут создать. И создание скорость будет главной проблемой для этих больших структур.
Сутенер Тризкит
Вместо этого используйте эту строку для имитации предварительного заполнения:var table = new Proxy({}, {get:(t,n)=>n in t ? t[n] : 42});
Pimp Trizkit
Хороший, творческий способ «эмулировать» Array2D с помощью объекта :)
Камиль Келчевски
4

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

const x = [...Array(6)].map(elem => new Array(4))
гость
источник