javascript - new - 多维数组




我如何在JavaScript中创建二维数组? (20)

我一直在网上阅读,有些地方说这是不可能的,有些人说这是,然后举一个例子,其他人反驳这个例子,等等。

  1. 我如何在JavaScript中声明2维数组? (假设它是可能的)

  2. 我将如何访问其成员? ( myArray[0][1]myArray[0,1] ?)


如何创建一个空的二维数组(单行)

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

同样的技巧可以用来创建一个包含1 ... N的JavaScript数组

或者(但n = 10,000 效率更低,为 12%)

Array(2).fill(null).map(() => Array(4))

性能下降的原因是我们必须将第一维值初始化为运行.map 。 请记住,在您通过.fill或直接值赋值命令之前, Array不会分配职位。

var arr = Array(2).fill(null).map(() => Array(4));
arr[0][0] = 'foo';
console.info(arr);

跟进

为什么这不起作用?

 Array(2).fill(Array(4));

尽管它确实返回了明显需要的二维数组( [ [ <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 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"]
         ]
*/

您可以创建任何您想要的nxm数组,并通过调用将其填入默认值

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

更多的例子和文档可以在here找到。

请注意,这还不是一项标准功能


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

创建一个5x5矩阵并填充它们为null


一个简单的例子:

var blocks = [];

blocks[0] = [];

blocks[0][0] = 7;

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

二维数组的创建方式与单维数组相同。 你可以像array[0][1]那样访问它们。

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

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

双内胆:

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

它将生成长度为10的数组a,并填充数组。 (Push将一个元素添加到数组并返回新的长度)


对于Array.from()恋人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 x = new Array(10);
for (var i = 0; i < 10; i++) {
  x[i] = new Array(20);
}
x[5][12] = 3.0;

您可以分配一个行数组,其中每一行都是一个长度相同的数组。 或者,您可以分配一个具有行*列元素的一维数组,并定义将行/列坐标映射到元素索引的方法。

无论您选择哪种实现,如果将其包装在对象中,则可以在原型中定义访问器方法以使API易于使用。


我不确定是否有人回答了这个问题,但我发现这对我很有帮助 -

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

例如:

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

例如,对于2维数组。


我发现下面是最简单的方法:

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

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

我已经对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]]

我的方法与@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

最简单的方法是:

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 myArray = [[]];

正如其他人指出的那样,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 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]);    

这就是我所取得的成绩:

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

这拼写我bineeshkumar


这是我发现制作二维数组的一个快速方法。

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)例如,当您执行Array(1, 2, 3, 4) ,构造函数将使用arguments对象正确地实例化并填充Array对象。

由于这个原因,我们可以使用Array.apply(null, Array(x)) ,因为apply函数会将参数传播到构造函数中。 为了澄清,做Array.apply(null, Array(3))等同于做Array(null, null, null)

现在我们已经创建了一个实际的填充数组,我们需要做的就是调用map并创建第二个图层( y )。





multidimensional-array