Я читаю онлайн, и некоторые места говорят, что это невозможно, некоторые говорят, что это так, а затем приводят пример, а другие опровергают пример и т.д.
Как объявить 2-мерный массив в JavaScript? (при условии, что это возможно)
Как я могу получить доступ к своим членам? (myArray[0][1] или myArray[0,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);Вы просто делаете каждый элемент массива массивом.
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 имеет только 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;
// ...
Самый простой способ:
var myArray = [[]];
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);Причина, по которой некоторые говорят, что это невозможно, состоит в том, что двухмерный массив - это просто массив массивов. Другие комментарии здесь представляют собой совершенно правильные методы создания двумерных массивов в 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);Самый простой способ:
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, мы можем сначала создать массив, а затем добавить массивы в качестве его элементов. Этот метод вернет 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);
Чтобы создать нерезкий "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],
]
*/
Дополнительные примеры и документацию можно найти здесь.
Обратите внимание, что это еще не стандартная функция.
Мой подход очень похож на @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
Для любителей одного лайнера 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"));
Я нашел ниже самый простой способ:
var array1 = [[]];
array1[0][100] = 5;
alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);
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
Мне пришлось создать гибкую функцию массива, чтобы добавить к ней "записи", а также иметь возможность обновлять их и выполнять любые вычисления, необходимые до того, как я отправил их в базу данных для дальнейшей обработки. Вот код, надеюсь, он поможет:).
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).
Ниже один создает матрицу 5x5 и заполняет ее null
var md = [];
for(var i=0; i<5; i++) {
md.push(new Array(5).fill(null));
}
console.log(md);
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);Вы можете выделить массив строк, где каждая строка представляет собой массив с одинаковой длиной. Или вы можете выделить одномерный массив с элементами столбцов * * столбцов и определить методы для сопоставления координат строк и столбцов с индексами элементов.
Какую бы реализацию вы ни выбрали, если вы ее оберните в объект, вы можете определить методы доступа в прототипе, чтобы упростить использование 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;
Один вкладыш для создания m * n 2-мерного массива, заполненного 0.
new Array(m).fill(new Array(n).fill(0));
Я сделал модификацию ответа 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]]