Javascript 如何在未知数量的数组中获得未知数量元素的所有组合？

我想了很久，找了很久，却找不到答案：

我需要编写一个js函数来获取一个数组数量未知的对象，而数组的元素数量也未知。像这样：

{
    Color: ["Color : Red", "Color : Blue", "Color : Green"], 
    Size : ["Size : S", "Size : M", "Size : L"], 
    Material : ["Material : Cotton"], 
    Something : ["Something : Anything", "Something : Anotherthing"]
}

同样，这可能是更多（或更少）的数组和元素，但在这种情况下，我希望实现如下输出：

{0: "Color : Red > Size : S > Material : Cotton > Something : Anything",
 1: "Color : Red > Size : S > Material : Cotton > Something : Anotherthing",
 2: "Color : Red > Size : M > Material : Cotton > Something : Anything",
 3: "Color : Red > Size : M > Material : Cotton > Something : Anotherthing",
 4: "Color : Red > Size : L > Material : Cotton > Something : Anything",
 5: "Color : Red > Size : L > Material : Cotton > Something : Anotherthing",
 6: "Color : Blue > Size : S > Material : Cotton > Something : Anything",
 ...
 ...[and so forth... ]}

我试着在循环中循环，但是失败了。 然后，我尝试首先查找最长的数组，从其余数组中提取它，然后针对最长数组中的每个元素遍历每个数组：

createMap = function(tagObj, longest){

  var longObj = tagObj[longest];
  var current = {};

  delete tagObj[longest];

  $.each(tagObj, function(name, obj){
    $.each(obj, function(index, tag){
      $.each(longObj, function(i, iniTag){
        if (current[i]!= undefined){
          current[i] += " > " + tag; 
        }
        else current[i] = iniTag + " > " + tag;
      })
    })
  })
  console.log(current);
}

但这只会导致：

{0: "Color : Red, Size : S, Size : M, Size : L, .... "}

我希望我没有忽略一些非常明显的事情，但我花了太多时间在上面，就是想不出来。现在我是一个神经衰弱的人，不能再直接思考了。

---

我将非常感谢您的帮助！提前谢谢

您可以使用某种类型的多个计数器来完成此操作：首先，收集每个键及其元素数，以及每个键的计数器

作为一个数字基数（但基数随着数字的变化而变化），我们增加较低的一个，如果这个基数达到了允许的最大值，我们将它放回0，然后增加下一个基数，等等。当每个数字都增加时，我们就对元素进行了一个完整的循环

function combinations(obj)
{
    var output = [];
    var meta = [], ml, cm;
    //ml: meta length
    //cm: current meta (in the while loop)

    for(var p in obj) if(obj.hasOwnProperty(p))
    {
        if(Object.prototype.toString.call(obj[p]) != '[object Array]')
            obj[p] = [obj[p]];
        meta.push({prop: p, len: obj[p].length, current: 0});
    }
    function addNow()
    {
        var add = {};
        for(var i = 0, l = meta.length; i < l; i++)
            add[meta[i].prop] = obj[meta[i].prop][meta[i].current]
        output.push(add);
    }
    cm = ml = meta.length - 1;
    while(cm >= 0)
    {
        addNow();
        cm = ml;
        while(cm >= 0 && ++meta[cm].current >= meta[cm].len)
        {
            meta[cm].current = 0;
            cm--;
        }
    }
    return output;
}

功能组合（obj）
{
var输出=[]；
var meta=[]，ml，cm；
//ml：元长度
//cm：当前元（在while循环中）
对于（对象中的var p）如果（对象hasOwnProperty（p））
{
if（Object.prototype.toString.call（obj[p]）！='[Object Array]'）
obj[p]=[obj[p]]；
push（{prop:p，len:obj[p].length，current:0}）；
}
函数addNow（）
{
var add={}；
for（var i=0，l=meta.length；i=0）
{
addNow（）；
cm=ml；
while（cm>=0&&++meta[cm]。当前>=meta[cm]。len）
{
元[cm]。当前值=0；
厘米--；
}
}
返回输出；
}

---

（请参阅）

您可以使用一个简单的递归解决方案：

function combine( obj ) {
  var keys = Object.keys(obj), combinations = [];

  // keys.sort(); // optional

  function rc(ki, combo) {
    var list;

    if (ki === keys.length)
      combinations.push(combo);
    else {
      list = obj[ keys[ki] ];
      for (var i = 0; i < list.length; ++i)
        rc( ki + 1, combo + " " + list[i] );
    }
  }

  rc(0, '');
  return combinations;
}

功能联合收割机（obj）{
var keys=Object.keys（obj），组合=[]；
//keys.sort（）；//可选
函数rc（ki，combo）{
var列表；
if（ki==键长度）
组合。推（组合）；
否则{
list=obj[key[ki]]；
对于（变量i=0；i

它以起始对象的键列表和空结果数组开始。请注意，对键进行排序可能是明智的，这样结果将以可预测的顺序返回，因为属性名列表没有定义顺序

递归“rc”函数从键数组中的特定索引开始。对于数组中与该键关联的每个字符串，该函数递归调用自身以对下一个键进行操作，并通过将列表元素附加到传入的字符串的末尾来形成一个基字符串。当键列表用尽时，每个完成的组合字符串都会附加到结果列表中

---

通过调用第0个键的“rc”和一个空字符串作为起始值，进程将停止。

此处嵌套的深度不应超过2。循环对象键，对于每个键，循环它的值（这是一个数组）。您将遇到的一个问题是，主对象中的键没有保证的遍历顺序。这意味着您无法预测组合字符串的外观。“Color”属性可能是第一个，也可能不是第一个。好吧，初始顺序并不重要，但您是对的，最后，输出应该都具有相同的顺序。我甚至都没到那里。Thx@Pointy，谢谢你指出了这一点！所以你要列出每种可能的组合。是这样吗？这个列表可能会很长。@Seb它可能会很长，是的。但要明确的是，我不想在同一个数组中组合元素！