Question

我想了很多，并且搜索了很多，但找不到答案：

我需要编写一个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, .... "}

我希望我不仅仅是忽略了一些非常明显的东西 - 但是我花了太多时间在它身上并且无法理解它。现在我是一个紧张的残骸，不能再思考了。我非常感谢一些帮助！提前致谢！

Answer 1

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

作为数字基础（但基数根据数字而变化）我们递增较低的一个，如果这个达到允许的最大数量，我们将其重新设置为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;
}

（见this fiddle）

Answer 2

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

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

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

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

通过为第0个键调用“rc”并将空字符串作为起始值来启动该过程。

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

2 个答案: