如何实现多数组元素的全排列组合生成唯一名称数组？

我有如下多维数组：

var arr = [
    ['Red', 'Black'],
    ['S', 'M'],
    ['Cotton', 'Linen']
];

希望生成包含所有可能组合的结果数组，格式如下：

result: [
   'Red - S - Cotton',
   'Red - M - Cotton',
   'Red - S - Linen',
   'Red - M - Linen',
   'Black - S - Cotton',
   'Black - M - Cotton',
   'Black - S - Linen',
   'Black - M - Linen'
]

我之前编写的JavaScript代码无法得到预期结果，存在重复项且缺失部分组合（比如缺少'Black - M - Cotton'），以下是我的代码：

var arr = [
      ['Red', 'Black'],
      ['S', 'M'],
      ['Cotton', 'Linen']
    ]
    
    var sum = 1;
    for (var i = 0; i < arr.length; i++) {
      sum *= arr[i].length;
    }
    
    function FullRow(arr, len) {
      var index = 0
      var result = []
      var current = 0
      while (index < len) {
        if (current === arr.length)
          current = 0
        result[index] = arr[current]
        index++
        current++
      }
      return result
    }
    
    function Combine(arr, len) {
      var result = arr[0];
      for (var index = 1; index < arr.length; index++) {
        for (var current = 0; current < len; current++) {
          result[current] += ' - ' + arr[index][current];
        }
      }
      return result;
    }
    
    var combineArr = [];
    for (var i = 0; i < arr.length; i++) {
      combineArr.push(FullRow(arr[i], sum));
    }
    
    console.log('----COMBINE----')
    var finalArr = Combine(combineArr, sum)
    
    console.log(finalArr)

请问该如何修改代码以得到符合需求的结果？

你的代码问题在于FullRow生成的序列逻辑错误，导致后续组合时无法正确匹配所有排列。可以换用以下两种更可靠的方式实现：

方法1：迭代拼接法 #

逐层遍历数组，将已有组合与当前层元素逐一拼接：

var arr = [
    ['Red', 'Black'],
    ['S', 'M'],
    ['Cotton', 'Linen']
];

function generateCombinations(arr) {
  // 初始结果为第一个数组的元素副本
  let result = arr[0].slice();
  // 从第二个数组开始遍历
  for (let i = 1; i < arr.length; i++) {
    const temp = [];
    // 遍历已有结果，和当前数组的每个元素拼接
    for (const prev of result) {
      for (const curr of arr[i]) {
        temp.push(`${prev} - ${curr}`);
      }
    }
    // 更新结果为新生成的组合
    result = temp;
  }
  return result;
}

const finalArr = generateCombinations(arr);
console.log(finalArr);

方法2：递归深度遍历法 #

适用于维度不固定的多维数组，通过递归逐层构建组合：

var arr = [
    ['Red', 'Black'],
    ['S', 'M'],
    ['Cotton', 'Linen']
];

function generateAllCombinations(arr, index = 0, current = '', result = []) {
  // 遍历到最后一层时，将当前组合存入结果
  if (index === arr.length) {
    result.push(current.trim());
    return result;
  }
  // 遍历当前层的每个元素，递归拼接下一层
  for (const item of arr[index]) {
    const newCurrent = current ? `${current} - ${item}` : item;
    generateAllCombinations(arr, index + 1, newCurrent, result);
  }
  return result;
}

const finalArr = generateAllCombinations(arr);
console.log(finalArr);

以上两种方法都能正确生成所有8种组合，解决原代码中重复和缺失的问题。

内容的提问来源于stack exchange，提问作者Ryan can fly