如何在JavaScript中创建二维数组？
我一直在网上阅读，有些地方说这是不可能的，有人说它是，然后给出一个例子，其他人反驳这个例子，等等。
-
如何在JavaScript中声明二维数组？ （假设有可能）
-
我如何访问其成员？ （
myArray[0][1]或myArray[0,1]？）
52 个答案:
答案 0 :(得分：1159)
var items = [
[1, 2],
[3, 4],
[5, 6]
];
console.log(items[0][0]); // 1
console.log(items);
答案 1 :(得分：400)
您只需将数组中的每个项目都设为数组。
var x = new Array(10);
for (var i = 0; i < x.length; i++) {
x[i] = new Array(3);
}
console.log(x);
答案 2 :(得分：179)
与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)]
答案 3 :(得分：78)
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;
// ...
答案 4 :(得分：70)
最简单的方法：
var myArray = [[]];
答案 5 :(得分：44)
有些人说这是不可能的原因是因为二维数组实际上只是一个数组数组。这里的其他注释提供了在JavaScript中创建二维数组的完全有效的方法，但最纯粹的观点是你有一维对象数组，每个对象都是一个由两个元素组成的一维数组。 / p>
所以，这是观点冲突的原因。
答案 6 :(得分：31)
如何创建空的二维数组（单行）
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);
同样的技巧可以用于Create a JavaScript array containing 1...N
或者（但more inefficient 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]);
答案 7 :(得分：29)
很少有人表示使用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
答案 8 :(得分：26)
两衬垫：
var a = [];
while(a.push([]) < 10);
它将生成一个长度为10的数组a，其中包含数组。 （Push将一个元素添加到数组并返回新的长度）
答案 9 :(得分：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);
注意我们不能直接填充行，因为fill使用浅拷贝构造函数，因此所有行都将共享相同的内存...这里是演示的示例如何分享每一行（取自其他答案）：
// 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);
答案 10 :(得分：18)
这就是我所取得的成就：
var appVar = [[]];
appVar[0][4] = "bineesh";
appVar[0][5] = "kumar";
console.log(appVar[0][4] + appVar[0][5]);
console.log(appVar);
这拼写了我的bineeshkumar
答案 11 :(得分：18)
最简单的方法：
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 :(得分：16)
二维数组的创建方式与单维数组相同。您可以像array[0][1]一样访问它们。
var arr = [1, 2, [3, 4], 5];
alert (arr[2][1]); //alerts "4"
答案 13 :(得分：13)
要在javaScript中创建2D数组，我们可以先创建一个Array，然后添加Arrays作为它的元素。此方法将返回具有给定行数和列数的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);
答案 14 :(得分：13)
我不确定是否有人回答过此问题，但我发现这对我很有帮助 -
var array = [[,],[,]]
例如：
var a = [[1,2],[3,4]]
例如，对于二维数组。
答案 15 :(得分：11)
要创建一个非稀疏的“ 2D”数组（x，y），将所有可寻址索引和值设置为null：
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）时间复杂度，因此它可能不适用于非常大的数组。
答案 16 :(得分：11)
性能
今天2020.02.05，我针对所选解决方案在Chrome v79.0，Safari v13.0.4和Firefox v72.0的MacOs HighSierra 10.13.6上进行了测试。
未初始化的二维数组的结论
- 深奥解决方案
{}/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对于所有浏览器上的所有阵列而言都是最慢的
初始化的二维数组的结论
- 基于
for/while（A，B，C，D，E，G）的解决方案对于所有浏览器上的小型阵列都是最快/非常快的 - 基于
for（A，B，C，E）的解决方案对于所有浏览器上的大型阵列都是最快/非常快的
对于所有浏览器中的小型阵列，基于 - 解决方案的速度中等或较慢
- 大型阵列的解决方案F，G，H，I，J，K，L在chrome和safari上中等或快速，但在Firefox上最慢。
- 深奥的解决方案
{}/arr[[i,j]]（N）对于所有浏览器上的小型和大型阵列而言都是最慢的
Array..map/from/fill（I，J，K，L，M）的 
详细信息
测试未填充（初始化）输出数组的解决方案
我们测试解决方案的速度
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
测试填充（初始化）输出数组的解决方案
我们测试解决方案的速度
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
答案 17 :(得分：8)
对于一位班轮爱好者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"));
答案 18 :(得分：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
答案 19 :(得分：7)
要创建4x6阵列，只需执行此操作
const x = [...new Array(6)].map(elem => new Array(4))
从空数组开始而不是填充w个随机值通常是一个好习惯。 （通常在1D中将数组声明为const x = []，因此最好在2D中将w开头为空。）
答案 20 :(得分：7)
Array(m).fill(v).map(() => Array(n).fill(v))
您可以创建具有初始值m x n的二维数组m，并且n可以是任意数字v可以是任意值string，{{ 1}}，number。
一种方法可以是undefined
答案 21 :(得分：6)
我发现下面是最简单的方法：
var array1 = [[]];
array1[0][100] = 5;
alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);
答案 22 :(得分：5)
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
答案 23 :(得分：5)
在下面，创建一个5x5矩阵并用null
＆＃13;
＆＃13;
＆＃13;
＆＃13;
var md = [];
for(var i=0; i<5; i++) {
md.push(new Array(5).fill(null));
}
console.log(md);
答案 24 :(得分：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"
}
随意优化和/或指出任何错误：）
答案 25 :(得分：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）。
答案 26 :(得分：3)
我不喜欢使用.fill()的ES6解决方案。某些方法可能会起作用，但为避免按引用复制问题而产生的额外麻烦使它们变得不直观。
我建议的ES6方法是对外部和内部阵列充分利用散布运算符。对IMO进行推理更容易。
[...Array(3)].map(() => [...Array(4)])
如果需要设置初始值，则在内部数组创建的.map()上进行链接：
[...Array(3)].map(() => [...Array(4)].map(() => 0))
最后，一个类型安全的TypeScript util函数：
export const createMultiDimensionalArray = <T>(
n: number,
m: number,
initialVal?: T,
): T[][] => {
const matrix = [...Array(n)].map(() => [...Array(m)]);
return initialVal === undefined
? matrix
: matrix.map(r => r.map(() => initialVal));
};
使用它的示例：
const a = createMultiDimensionalArray(1, 2);
a[1][2] = 3; // Works
const b = createMultiDimensionalArray(2, 3, false);
b[1][2] = true; // Works
b[1][2] = 3; // Error: Type '3' is not assignable to type 'boolean'.
答案 27 :(得分：3)
一个衬垫，用于创建填充为0的m * n 2维阵列。
new Array(m).fill(new Array(n).fill(0));
答案 28 :(得分：3)
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 = '<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);
答案 29 :(得分：3)
简化示例：
var blocks = [];
blocks[0] = [];
blocks[0][0] = 7;
答案 30 :(得分：3)
我发现此代码适用于我：
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];
}
}
}
答案 31 :(得分：3)
您可以分配一个行数组，其中每一行都是一个长度相同的数组。或者您可以使用rows * columns元素分配一维数组，并定义将行/列坐标映射到元素索引的方法。
无论您选择哪种实现，如果将其包装在对象中，您都可以在原型中定义访问器方法，以使API易于使用。
答案 32 :(得分：2)
我修改了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's 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's 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]]
答案 33 :(得分：1)
还有另一个解决方案，它不会强制您预先定义2d数组的大小，这非常简洁。
var table = {}
table[[1,2]] = 3 // Notice the double [[ and ]]
console.log(table[[1,2]]) // -> 3
这是有效的，因为[1,2]被转换为字符串，用作table对象的字符串键。
答案 34 :(得分：1)
行和列的大小，只有在运行时才知道的数组，然后可以使用以下方法用于创建动态二维数组。
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
答案 35 :(得分：1)
您还可以创建一个函数来创建这样的2D数组：
.t-fht-wrapper{
max-height: 407px;
position: relative;
width: 100%;
}
您可以使用以下方法调用它，它将为您提供10x10 2D阵列。
var myTable = [];
function createArray(myLength) {
myTable = new Array(myLength);
var cols, rows;
for (cols = 0; cols < myLength; cols++) {
myTable[cols] = new Array(myLength);
}
}
您也可以使用此方法创建3D数组。
答案 36 :(得分：1)
创建多维数组的递归函数：
var makeArray = function (dims, arr) {
if (dims[1] === undefined) {
return new Array(dims[0]);
}
arr = new Array(dims[0]);
for (var i=0; i<dims[0]; i++) {
arr[i] = new Array(dims[1]);
arr[i] = makeArray(dims.slice(1), arr[i]);
}
return arr;
}
构建2x3x4x2 4D阵列：
var array = makeArray([2, 3, 4, 2]);
答案 37 :(得分：0)
The following example defines a two-dimensional array named activities:
let activities = [
['Work', 9],
['Eat', 1],
['Commute', 2],
['Play Game', 1],
['Sleep', 7]
];
In the activities array, the first dimension represents the activity and the second one shows the number of hours spent per day for each.
To show the activities array in the console, you use the console.table() method as follows:
console.table(activities);
Code language: JavaScript (javascript)
The following illustrates the output:
┌─────────┬─────────────┬───┐
│ (index) │ 0 │ 1 │
├─────────┼─────────────┼───┤
│ 0 │ 'Work' │ 9 │
│ 1 │ 'Eat' │ 1 │
│ 2 │ 'Commute' │ 2 │
│ 3 │ 'Play Game' │ 1 │
│ 4 │ 'Sleep' │ 7 │
└─────────┴─────────────┴───┘
Code language: plaintext (plaintext)
Note that the (index) column is for the illustration that indicates the indices of the inner array.
To access an element of the multidimensional array, you first use square brackets to access an element of the outer array that returns an inner array; and then use another square bracket to access the element of the inner array.
The following example returns the second element of the first inner array in the activities array above:
console.log(activities[0][1]); // 9
Code language: JavaScript (javascript)
Adding elements to the JavaScript multidimensional array
You can use the Array methods such as push() and splice() to manipulate elements of a multidimensional array.
For example, to add a new element at the end of the multidimensional array, you use the push() method as follows:
activities.push(['Study',2]);
console.table(activities);
Code language: CSS (css)
┌─────────┬─────────────┬───┐
│ (index) │ 0 │ 1 │
├─────────┼─────────────┼───┤
│ 0 │ 'Work' │ 9 │
│ 1 │ 'Eat' │ 1 │
│ 2 │ 'Commute' │ 2 │
│ 3 │ 'Play Game' │ 1 │
│ 4 │ 'Sleep' │ 7 │
│ 5 │ 'Study' │ 2 │
└─────────┴─────────────┴───┘
Code language: plaintext (plaintext)
To insert an element in the middle of the array, you use the splice() method. The following inserts an element in the second position of the activities array:
activities.splice(1, 0, ['Programming', 2]);
console.table(activities);
Code language: CSS (css)
Here is the output:
┌─────────┬───────────────┬───┐
│ (index) │ 0 │ 1 │
├─────────┼───────────────┼───┤
│ 0 │ 'Work' │ 9 │
│ 1 │ 'Programming' │ 2 │
│ 2 │ 'Eat' │ 1 │
│ 3 │ 'Commute' │ 2 │
│ 4 │ 'Play Game' │ 1 │
│ 5 │ 'Sleep' │ 7 │
│ 6 │ 'Study' │ 2 │
└─────────┴───────────────┴───┘
Code language: plaintext (plaintext)
This example calculates the percentage of the hours spent on each activity and appends the percentage to the inner array.
activities.forEach(activity => {
let percentage = ((activity[1] / 24) * 100).toFixed();
activity[2] = percentage + '%';
});
console.table(activities);
Code language: JavaScript (javascript)
The following shows the output in the console:
┌─────────┬───────────────┬───┬───────┐
│ (index) │ 0 │ 1 │ 2 │
├─────────┼───────────────┼───┼───────┤
│ 0 │ 'Work' │ 9 │ '38%' │
│ 1 │ 'Programming' │ 2 │ '8%' │
│ 2 │ 'Eat' │ 1 │ '4%' │
│ 3 │ 'Commute' │ 2 │ '8%' │
│ 4 │ 'Play Game' │ 1 │ '4%' │
│ 5 │ 'Sleep' │ 7 │ '29%' │
│ 6 │ 'Study' │ 2 │ '8%' │
└─────────┴───────────────┴───┴───────┘
Code language: plaintext (plaintext)
Removing elements from the JavaScript multidimensional array
To remove an element from an array, you use the pop() or splice() method.
For example, the following statement removes the last element of the activities array.
activities.pop();
console.table(activities);
Code language: CSS (css)
Output:
┌─────────┬───────────────┬───┬───────┐
│ (index) │ 0 │ 1 │ 2 │
├─────────┼───────────────┼───┼───────┤
│ 0 │ 'Work' │ 9 │ '38%' │
│ 1 │ 'Programming' │ 2 │ '8%' │
│ 2 │ 'Eat' │ 1 │ '4%' │
│ 3 │ 'Commute' │ 2 │ '8%' │
│ 4 │ 'Play Game' │ 1 │ '4%' │
│ 5 │ 'Sleep' │ 7 │ '29%' │
└─────────┴───────────────┴───┴───────┘
Code language: plaintext (plaintext)
Similarly, you can remove the elements from the inner array of the multidimensional array by using the pop() method. The following example removes the percentage element from the inner arrays of the activities array.
activities.forEach((activity) => {
activity.pop(2);
});
console.table(activities);
Code language: JavaScript (javascript)
Output:
┌─────────┬───────────────┬───┐
│ (index) │ 0 │ 1 │
├─────────┼───────────────┼───┤
│ 0 │ 'Work' │ 9 │
│ 1 │ 'Programming' │ 2 │
│ 2 │ 'Eat' │ 1 │
│ 3 │ 'Commute' │ 2 │
│ 4 │ 'Play Game' │ 1 │
│ 5 │ 'Sleep' │ 7 │
└─────────┴───────────────┴───┘
Code language: plaintext (plaintext)
Iterating over elements of the JavaScript multidimensional array
To iterate a multidimensional array, you use a nested for loop as in the following example.
// loop the outer array
for (let i = 0; i < activities.length; i++) {
// get the size of the inner array
var innerArrayLength = activities[i].length;
// loop the inner array
for (let j = 0; j < innerArrayLength; j++) {
console.log('[' + i + ',' + j + '] = ' + activities[i][j]);
}
}
Code language: JavaScript (javascript)
The first loop iterates over the elements of the outer array and the nested loop iterates over elements of the inner array.
The following shows the output of the script in the console:
[0,0] = Work
[0,1] = 9
[1,0] = Eat
[1,1] = 1
[2,0] = Commute
[2,1] = 2
[3,0] = Play Game
[3,1] = 1
[4,0] = Sleep
[4,1] = 7
[5,0] = Study
[5,1] = 2
Or you can use the forEach() method twice:
activities.forEach((activity) => {
activity.forEach((data) => {
console.log(data);
});
});
Code language: JavaScript (javascript)
Output:
Work
9
Eat
1
Commute
2
Play Game
1
Sleep
7
Study
2
答案 38 :(得分：0)
const arr = new Array(5).fill(new Array(5).fill(0));
console.log(arr);
答案 39 :(得分：0)
使用全局对象 Array 并用数组填充项目：
let arr = new Array(5).fill([]);
或如果已知长度的二维数组：
let arr = new Array(5).fill(new Array(2));
答案 40 :(得分：0)
ES6 +，ES2015 +可以更简单的方式实现
创建3 x 2填充为真的数组
[...Array(3)].map(item => Array(2).fill(true))
答案 41 :(得分：0)
在一些评论中提到了这一点，但使用Array.fill（）将有助于构建二维数组：
function create2dArr(x,y) {
var arr = [];
for(var i = 0; i < y; i++) {
arr.push(Array(x).fill(0));
}
return arr;
}
这将导致在返回的数组中长度为x，y的数组。
答案 42 :(得分：0)
为Java脚本创建n维矩阵数组，其初始默认值为0。
function arr (arg, def = 0){
if (arg.length > 2){
return Array(arg[0]).fill().map(()=>arr(arg.slice(1)));
} else {
return Array(arg[0]).fill().map(()=>Array(arg[1]).fill(def));
}
}
// Simple Usage of 4 dimensions
var s = arr([3,8,4,6])
// Use null default value with 2 dimensions
var k = arr([5,6] , null)
答案 43 :(得分：0)
var items = [
["January 01", 42.5],
["February 01", 44.3],
["March 01", 28.7],
["April 01", 44.3],
["May 01", 22.9],
["June 01", 54.4],
["July 01", 69.3],
["August 01", 19.1],
["September 01", 82.5],
["October 01", 53.2],
["November 01", 75.9],
["December 01", 58.7]
];
alert(items[1][0]); // February 01
alert(items[5][1]); // 54.4
答案 44 :(得分：0)
Array.from({length: rows}).map(e => new Array(columns));
答案 45 :(得分：0)
如果您想要的是4x4矩阵，请查看DOMMatrix，我可以轻松使用，
let m = new DOMMatrix();
// m.m11, m.m12, m.m13, m.m14, ..., m.m41, m.m42, m.m43, m.m44
最初由于不同的原因，它在node.js上不可用，仅限于4x4。
另外你可以考虑使用一个自动生成对象而不是JS的数组，看看my answer here但是为了更有说服力而带到这里：
var tree = () => new Proxy({}, { get: (target, name) => name in target ? target[name] : target[name] = tree() });
var t = tree();
t[0][2][3] = 4;
console.log(t[0][2][3]);
它使用新的JS并且在迭代它时行为不正确所以要小心它。
如果您需要灵活的多维数组生成器，还可以查看this。
答案 46 :(得分：0)
这是我对多维数组的实现。
在这种方法中，我正在创建一个单维数组
我已将一个原型函数multi添加到Array对象，可用于创建任何维度数组。
我还在index对象中添加了原型函数Array，可用于从多维索引中获取线性数组中的索引。
创建数组
//Equivalent to arr[I][J][K]..[] in C
var arr = new Array().multi(I,J,K,..);
访问任何索引处的数组值
//Equivalent in C arr[i][j][k];
var vaue = arr[arr.index(i,j,k)];
<强>段
＆＃13;
＆＃13;
＆＃13;
＆＃13;
/*
Storing array as single dimension
and access using Array.index(i,j,k,...)
*/
Array.prototype.multi = function(){
this.multi_size = arguments;
this.multi_len = 1
for(key in arguments) this.multi_len *= arguments[key];
for(var i=0;i<this.multi_len;i++) this.push(0);
return this;
}
Array.prototype.index = function(){
var _size = this.multi_len;
var temp = 1;
var index = 0;
for(key in arguments) {
temp*=this.multi_size[key];
index+=(arguments[key]*(_size/temp))
}
return index;
}
// Now you can use the multi dimension array
// A 3x3 2D Matrix
var arr2d = new Array().multi(3,3); // A 2D Array
arr2d[arr2d.index(1,1,1)] = 5;
console.log(arr2d[arr2d.index(1,1,1)]);
// A 3x3x3 3D Matrix
var arr3d = new Array().multi(3,3,3); // a 3D Array
arr3d[arr3d.index(1,1,1)] = 5;
console.log(arr3d[arr3d.index(1,1,1)]);
// A 4x3x3 4D Matrix
var arr4d = new Array().multi(4,3,3,3); // a 4D Array
arr4d[arr4d.index(4,0,0,1)] = 5;
console.log(arr4d[arr4d.index(4,0,0,1)]);
答案 47 :(得分：0)
var _field = (function()
{
var array = [];
for(var y = 0; y != 3; y++) { array[y] = new Array(5); }
return array;
})();
// var item = _field[2][4];
答案 48 :(得分：0)
nodejs + lodash版本：
var _ = require("lodash");
var result = _.chunk(['a', 'b', 'c', 'd', 'e', 'f'], 2);
console.log(result);
console.log(result[2][0]);
输出：
[ [ 'a', 'b' ], [ 'c', 'd' ], [ 'e', 'f' ] ]
e
答案 49 :(得分：0)
一个很棒的存储库here。
-
api：masfufa.js
-
示例：masfufa.html
两个例子足以理解这个库：
示例1：
/* | 1 , 2 , 3 |
* MX= | 4 , 5 , 6 | Dimensions= 3 x 3
* | 7 , 8 , 9 |
*/
jsdk.getAPI('my');
var A=[1, 2, 3, 4, 5, 6, 7, 8, 9];
var MX=myAPI.getInstance('masfufa',{data:A,dim:'3x3'});
然后：
MX.get[0][0] // -> 1 (first)
MX.get[2][2] // ->9 (last)
示例2：
/* | 1 , 9 , 3 , 4 |
* MXB= | 4 , 5 , 6 , 2 | Dimensions= 2 x 4
*
*/
var B=[1 , 9 , 3 , 4 , 4 , 5 , 6 , 2];
var MXB=myAPI.getInstance('masfufa',{data:B,dim:'2x4'});
然后：
MXB.get[0][0] // -> 1 (first)
MXB.get[1][3] // -> 2 (last)
MXB.get[1][2] // -> 6 (before last)
答案 50 :(得分：0)
如果你正在使用谷歌图表的二维数组，最好的方法是
var finalData = [];
[["key",value], ["2013-8-5", 13.5], ["2013-7-29",19.7]...]
答案 51 :(得分：0)
如果数组的大小未知，会发生什么？或者应该动态创建和填充数组？对我有用的替代解决方案是使用带有静态2d数组变量的类，如果数组中不存在索引，则会启动它：
function _a(x,y,val){
// return depending on parameters
switch(arguments.length){
case 0: return _a.a;
case 1: return _a.a[x];
case 2: return _a.a[x][y];
}
// declare array if wasn't declared yet
if(typeof _a.a[x] == 'undefined')
_a.a[x] = [];
_a.a[x][y] = val;
}
// declare static empty variable
_a.a = [];
语法为：
_a(1,1,2); // populates [1][1] with value 2
_a(1,1); // 2 or alternative syntax _a.a[1][1]
_a(1); // [undefined × 1, 2]
_a.a; // [undefined × 1, Array[2]]
_a.a.length
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？