Javascript函数创建多维数组

海伊

我想要一个创建多维数组的函数（纯javascript）（无jQuery）

我已经做了一个完全硬编码的，这限制了我可以深入的维度的数量

function nestTriArray(first, second, third){
  const arr = new Array(first);
  for(let i=0; i<first; i++){
    arr[i] = new Array(second);
    for(let j=0; j<second; j++){
      arr[i][j] = new Array(third);
    }
  }
  return arr;
}

const test = nestTriArray(3,2,3);
console.log(test);

我还尝试在一个函数中实现多维化（而不是为第四维、第五维……硬编码一个独立的函数），其中我向函数传递一个数组，数组的长度是维数，每个元素表示每个子数组的长度。 它使用递归函数。 它输出错误

这就是尝试：

function nestArray(conf_array/*first, second, third*/){
  conf_array = [1].concat(conf_array);
  const arr = [];

  let last_in_ref = arr;
  function re(index){
    last_in_ref[conf_array[index]] = new Array(conf_array[index+1]);
    for(let i=0; i<conf_array[index]; i++){
      last_in_ref[i] = new Array(conf_array[index+1]);
    }
    last_in_ref = last_in_ref[index];
    console.log(arr);
    index++;
    if(index < conf_array.length){re(index);}
  }

  re(0);

  return arr;
}

const test = nestArray([3,2,3]);
console.log(test);

---

提前谢谢

下面是一个递归实现，它实现了您想要的功能：

函数嵌套数组（arrDims）{
常数[头，…尾]=arrDims；
const arr=新阵列（头）；
返回tail.length>0？arr.fill（0）.map（（）=>nestary（tail））：arr；
}
log（nestArray（[5]））；
log（nestArray（[4,3,2]）这里是一个递归实现，它实现了您想要的功能：


函数嵌套数组（arrDims）{
常数[头，…尾]=arrDims；
const arr=新阵列（头）；
返回tail.length>0？arr.fill（0）.map（（）=>nestary（tail））：arr；
}
log（nestArray（[5]））；
log（nestArray（[4,3,2]）这里是带有
reduce

[编辑]修复了浅拷贝和注释中的还原光

const nestArray = arr =>
  arr.reduceRight((acc, v) => {
    return new Array(v).fill(null).map(()=> acc ? [...acc] : acc);
  }, undefined);

console.log（nestArray（[2,5,7,10]）
这里是带有
reduce的变体

[编辑]修复了浅拷贝和注释中的还原光

const nestArray = arr =>
  arr.reduceRight((acc, v) => {
    return new Array(v).fill(null).map(()=> acc ? [...acc] : acc);
  }, undefined);

console.log（nestArray（[2,5,7,10]）
在不太可能的情况下，您需要这些优化：

如果您试图通过预初始化阵列进行优化，请阅读

还原法：


const nestedArray=（…args）=>args.reduceRight（（arr，length，i）=>
from（{length}，=>i？arr:arr.map（x=>[…x]）），Array（args.pop（））
让x
console.log(
x=嵌套阵列（3,2,4）
)
x[0][0][0]=123
console.log(
x
)
在不太可能的情况下，您需要这些优化：

如果您试图通过预初始化阵列进行优化，请阅读

还原法：


const nestedArray=（…args）=>args.reduceRight（（arr，length，i）=>
from（{length}，=>i？arr:arr.map（x=>[…x]）），Array（args.pop（））
让x
console.log(
x=嵌套阵列（3,2,4）
)
x[0][0][0]=123
console.log(
x
)
太多了。而且它非常简洁。太完美了，太多了。而且它非常简洁。太完美了，这是不对的。您需要浅克隆[…acc]以避免重复使用同一引用。它告诉我它包含一个“循环对象数组”，我不知道它是什么。@user120242您是对的，试图使其过于简洁。仅供参考：您可以使用reduceRight而不是reverse。而且，在每次迭代中，它仍然指向同一个引用，只是这次它们指向一个克隆。这是不正确的。您需要浅克隆[…acc]以避免重复使用同一引用。它告诉我它包含一个“循环对象数组”，我不知道它是什么。@user120242您是对的，试图使其过于简洁。仅供参考：您可以使用reduceRight而不是reverse。而且，在每次迭代中，它仍然指向相同的引用，只是这次他们指向了一个克隆。嘿，伙计们，非常感谢你们，非常感谢所有的答案！！总之，有很多方法可以做到这一点（谢谢！！）。但是除了简洁，哪一个执行得最快？？？嘿，伙计们，非常感谢你们的回答！！总之，有很多方法可以做到这一点（谢谢！！）。但除了简洁性，哪一种执行速度最快？？？感谢这两种方法！！哪一个执行得更快？在具有非常大数组的微基准测试中，仅使用push和Array（）构造函数的for循环可能是最快的。下面是上面的递归方法。填充贴图可能比Array.from更好。事实上，这种差异在大多数情况下可以忽略不计，可能也无关紧要。如果嵌套量过大，则无尾部递归的递归会有堆栈溢出的风险。多亏了这两种方法！！哪一个执行得更快？在具有非常大数组的微基准测试中，仅使用push和Array（）构造函数的for循环可能是最快的。下面是上面的递归方法。填充贴图可能比Array.from更好。实际上，这种差异在大多数情况下是可以忽略的，并且可能无关紧要。如果嵌套量过多，没有尾部递归的递归会有堆栈溢出的风险
const nestArray = arr =>
  arr.reduceRight((acc, v) => {
    return new Array(v).fill(null).map(()=> acc ? [...acc] : acc);
  }, undefined);