递归组合对象数组javascript/typescript

我有n个数组，结构如下

[{val_1: 2}, {val_1: 3}];
[{val_2: 2}];
[{val_3: 1}];

等等

我想创建一个结构类似

[{val_1: 2, val_2: 2, val_3: 1}, {val_1: 3, val_2: 2, val_3: 1}]

比较所有阵列并生成每个可能的输出。在下面的代码中，我有3个数组。一个具有4个值、2个值和3个值。我希望它返回24个不同的数组，显示所有可能的组合

      var val_1 = 3
  var val_2 = 2
  var val_3 = 1
  var total_val = 3;
  var useable = 50;

  var array_1 = new Array();
  var array_2 = new Array();
  var array_3 = new Array();
  var array_1_c = new Array();
  var array_2_c = new Array();
  var array_3_c = new Array();

  for(val_1; val_1 <= total_val && val_1 <= useable; val_1+=1){
    array_1 = [{val_1}];
    array_1.map(test =>{
      return{val_1}
    }).forEach(test => array_1_c.push(test));
  };
  var val_1 = 2
  for(val_1; val_1 >= 0; val_1-=1){
    array_1 = [{val_1}];
    array_1.map(test =>{
      return{val_1}
    }).forEach(test => array_1_c.push(test));
  };

  for(val_2; val_2 <= total_val && val_2 <= useable; val_2+=1){
    array_2 = [{val_2}];
    array_2.map(test =>{
      return{val_2}
    }).forEach(test => array_2_c.push(test));
  };
  for(val_3; val_3 <= total_val && val_3 <= useable; val_3+=1){
    array_3 = [{val_3}];
    array_3.map(test =>{
      return{val_3}
    }).forEach(test => array_3_c.push(test));
  }; console.log(array_1_c);console.log(array_2_c);console.log(array_3_c);

var val_1=3
var val_2=2
var val_3=1
var total_val=3；
var可用=50；
var array_1=新数组（）；
var array_2=新数组（）；
var array_3=新数组（）；
var array_1_c=新数组（）；
var array_2_c=新数组（）；
var array_3_c=新数组（）；
对于（val_1；val_1数组_1_c.推送（测试））；
};
var val_1=2
对于（val_1；val_1>=0；val_1-=1）{
数组_1=[{val_1}]；
数组_1.map（测试=>{
返回{val_1}
}).forEach（test=>array_1_c.push（test））；
};
对于（val_2；val_2数组_2_c.推送（测试））；
};
对于（val_3；val_3数组_3_c.推送（测试））；
}; console.log（数组_1_c）；console.log（数组_2_c）；console.log（数组_3_c）；

这样的事情是如何实现的？permute函数似乎是一种方法，但我找不到一种方法来输出每个组合。如果创建数百万个组合，我应该选择与使用对象数组不同的路线

---

谢谢

您可以通过使用对象数组来获取笛卡尔积的算法

结果是一个包含给定数据所有属性的对象数组

const
getCartesian=array=>array.reduce（（a，b）=>a.reduce（（r，v）=>r.concat（b.map（w=>（{…v，…w}）），[]），
all=[{val_1:2}、{val_1:3}、{val_2:2}、{val_3:1}]]，
笛卡尔=getCartesian（全部）；
console.log（笛卡尔）
.as console wrapper{max height:100%！important；top:0；}
您可以通过使用对象数组获取笛卡尔积的算法

结果是一个包含给定数据所有属性的对象数组


const
getCartesian=array=>array.reduce（（a，b）=>a.reduce（（r，v）=>r.concat（b.map（w=>（{…v，…w}）），[]），
all=[{val_1:2}、{val_1:3}、{val_2:2}、{val_3:1}]]，
笛卡尔=getCartesian（全部）；
console.log（笛卡尔）
。作为控制台包装器{max height:100%！important；top:0；}
您好，您能解释一下如何评估大小为4、2和3的数组中的12个组合吗？不知道为什么会被否决。对不起，我指的是24个组合*。4 * 2 * 3 = 24. 结果需要按顺序组合每个值。我想您需要的是
笛卡尔积的解，而不是置换。看一看：这个问题对你的问题有一个相关的答案。嗨，你能解释一下你是如何评估大小为4、2和3的数组中的12个组合的吗？不知道为什么会被否决。对不起，我指的是24个组合*。4 * 2 * 3 = 24. 结果需要按顺序组合每个值。我想您需要的是
笛卡尔积的解，而不是置换。看一看：这个问题对你的问题有一个相关的答案。