首页 文章

如何在JavaScript中创建二维数组?

提问于
浏览
969

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

  • 如何在JavaScript中声明二维数组? (假设有可能)

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

30 回答

  • 19

    有人说这是不可能的原因是因为二维数组实际上只是一个数组数组 . 这里的其他注释提供了在JavaScript中创建二维数组的完全有效的方法,但最纯粹的观点是你有一维对象数组,每个对象都是一个由两个元素组成的一维数组 .

    所以,这是观点冲突的原因 .

  • 1

    Javascript不支持二维数组,而是将数组存储在另一个数组中,并根据您要访问的数组的位置从该数组中获取数据 . 记住数组计算从 ZERO 开始 .

    Code Example:

    /* 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
    
  • 384

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

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

  • 72

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

    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


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

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

    您只需将数组中的每个项目都设为一个数组 .

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

    二维数组的创建方式与单维数组相同 . 你可以像_454760那样访问它们 .

    var arr = [1, 2, [3, 4], 5];
    
    alert (arr[2][1]); //alerts "4"
    
  • 14

    最简单的方法:

    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'
    
  • 26

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

    我的方法与@Bineesh的答案非常相似,但采用了更为通用的方法 .

    您可以按如下方式声明double数组:

    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
    
  • 5

    在一个下方,创建一个5x5矩阵并用 null 填充它们

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

    一个衬垫用于创建填充0的m * n 2维阵列 .

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

    要创建一个非稀疏的“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)时间复杂度,因此它可能不适合非常大的阵列 .

  • 3

    使用数组理解

    在JavaScript 1.7及更高版本中,您可以使用 array comprehensions 创建二维数组 . 您还可以在填充数组时过滤和/或操作条目,而不必使用循环 .

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

    可以找到更多示例和文档here .

    请注意,这不是标准功能 .

  • 4

    我已经修改了Matthew Crumley 's answer for creating a multidimensional array function. I' ve添加了要作为数组变量传递的数组的维度,还有另一个变量 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]]
    
  • 4

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

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