Javascript 使用递归组合数组值，即使它们'；空的

我有一个函数，它结合数组来构建笛卡尔积（取自）

当存在空数组时，如何调整下面的函数以使函数工作

var array_1 = [['a', 'b'], ['c', 'z'], ['d', 'e', 'f']];
var array_2 = [[], ['b', 'z'], ['d', 'e', 'f']];

function allPossibleCases(arr) {
  if (arr.length === 0) {
    return [];
  } 
  else if (arr.length ===1){
    return arr[0];
  }
  else {
    var result = [];
    var allCasesOfRest = allPossibleCases(arr.slice(1));  // recur with the rest of array
    for (var c in allCasesOfRest) {
      for (var i = 0; i < arr[0].length; i++) {
        result.push(arr[0][i] + allCasesOfRest[c]);
      }
    }
    return result;
  }
}

var result_1 = allPossibleCases(array_1);
// outputs ["acd", "bcd", "azd", "bzd", "ace", "bce", "aze", "bze", "acf", "bcf", "azf", "bzf"];

var result_2 = allPossibleCases(array_2);
// current output [];
// desired output ["bd", "be", "bf", "zd", "ze", "zf"];

var数组_1=['a'，'b']，['c'，'z']，['d'，'e'，'f']；
变量数组_2=[[]、['b'，'z']、['d'，'e'，'f']；
功能所有可能情况（arr）{
如果（arr.length==0）{
返回[]；
} 
else if（arr.length==1）{
返回arr[0]；
}
否则{
var结果=[]；
var allCasesOfRest=allPossibleCases（arr.slice（1））；//与数组的其余部分一起递归
用于（所有情况下的var c其余）{
对于（var i=0；i

找到两个集合的笛卡尔积非常简单：

function product(f, xs, ys) {
    var zs = [];

    var m = xs.length;
    var n = ys.length;

    for (var i = 0; i < m; i++) {
        var x = xs[i];

        for (var j = 0; j < n; j++) {
            var y = ys[j];
            var z = f(x, y);
            zs.push(z);
        }
    }

    return zs;
}

如果要查找多个集合的笛卡尔积，可以使用

reduce

：

var xss = [["a","b"],["c","z"],["d","e","f"]];

var xs = xss.reduce(productAdd); // ["acd","ace","acf",
                                 //  "azd","aze","azf",
                                 //  "bcd","bce","bcf",
                                 //  "bzd","bze","bzf"]

function productAdd(xs, ys) {
    return product(add, xs, ys);
}

但是，您需要

过滤
空集：

var yss = [[],["b","z"],["d","e","f"]];

var ys = yss.filter(nonEmpty).reduce(productAdd); // ["bd","be","bf",
                                                  //  "zd","ze","zf"]

function nonEmpty(xs) {
    return xs.length > 0;
}

function productAdd(xs, ys) {
    return product(add, xs, ys);
}

我们需要这样做的原因很简单。任何与
0
相乘的值都是
0
。因此，我们删除了集合列表中所有要相乘的零

演示1

var xss=[[“a”、“b”]、[“c”、“z”]、[“d”、“e”、“f”]；
var xs=xss.reduce（productAdd）；
警报（JSON.stringify（xs））；
函数productAdd（xs，ys）{
退货产品（添加、xs、ys）；
}
功能添加（a、b）{
返回a+b；
}
功能产品（f、xs、ys）{
var zs=[]；
var m=xs.length；
var n=ys.长度；
对于（变量i=0；i}
出于好奇，为什么这是期望的输出？一个空集与其他任何东西的笛卡尔积本身就是一个空集，因此
result_2
在数学上是正确的。无论如何，如果你真的需要这个，你可以只做
var result2=allpossibleCase（数组_2.filter（函数（v）{return v.length；}））。创建一个没有空数组的新数组，并将其作为allPossibleCases函数的参数传递。答案非常棒。这完美地解决了问题。谢谢。当在空数组数组上运行此操作时，例如
空数组.filter（nonEmpty）.reduce（productAdd）
，我在控制台中得到一个
未捕获类型错误：没有初始值的空数组reduce
。我将如何解决这个问题？我假设
空数组
类似于
[]、[]、[]]
。如果是，则
空\u数组。过滤器（非空）
是一个没有值的数组（即
[]
）。你会得到一个错误，因为你不能得到零的乘积。
[]、[]、[]]
的产品是
[]
（即
0*0*0=0
）。但是，
[]
的产品不存在。因此，解决方案是不筛选列表（即不执行
。筛选（非空）
）。然而，这让我们回到第1步。因此，改为：
function productOf（xss）{var yss=xss.filter（非空）；返回yss.length？yss.reduce（productAdd）：yss；}
&
productOf（空数组）
。
var yss = [[],["b","z"],["d","e","f"]];

var ys = yss.filter(nonEmpty).reduce(productAdd); // ["bd","be","bf",
                                                  //  "zd","ze","zf"]

function nonEmpty(xs) {
    return xs.length > 0;
}

function productAdd(xs, ys) {
    return product(add, xs, ys);
}