Ответ 1

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

Ответ 2

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

var x = new Array(10);

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

console.log(x);

Ответ 3

Как и для ответа 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)]

Ответ 4

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

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

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

Ответ 5

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

var myArray = [[]];

Ответ 6

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

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

2 и 4 являются первым и вторым измерениями соответственно.

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

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

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

Ответ 7

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

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

Ответ 8

Мало кто показывает использование 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

Ответ 9

Два лайнера:

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

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

Ответ 10

Кажется, что самый здравый ответ

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

Ответ 11

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

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'

Ответ 12

Это то, что я достиг:

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

Ответ 13

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

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

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

Ответ 14

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

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

например:

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

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

Ответ 15

Чтобы создать 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);

Ответ 16

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

Ответ 17

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

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

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

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

Ответ 18

Мой подход очень похож на @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

Ответ 19

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

Ответ 20

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

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

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

Ответ 21

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

Пример кода:

/* Two dimensional array that 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

Ответ 22

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

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

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

Ответ 23

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

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

Ответ 24

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

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

console.log(md);

Ответ 25

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

Ответ 26

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

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

Ответ 27

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

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

Ответ 28

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

var blocks = [];

blocks[0] = [];

blocks[0][0] = 7;

Ответ 29

Один вкладыш для создания m * n 2-мерного массива, заполненного 0.

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

Ответ 30

Я сделал модификацию ответа Matthew Crumley для создания многомерной функции массива. Я добавил размеры массива, который будет передан как переменная массива, и будет существовать другая переменная - 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 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 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]]