这种类型函数应该怎么封装

Question

var arr = ['1','2'];
var arr1 =['a','b','c','d'];
var arr2 =['!','@','#','$'];
// ... arr3   arr4  arr5 很多个


var newArr = [];
arr.forEach(a1=>{
   arr1.forEach(a2=>{
       arr2.forEach(a3=>{
          newArr.push(a1+a2+a3)
       })
    })
});

如何用函数去实现，可以传入多个数组达到上面的效果

Answer 1

function a(...arrs) {
  return innerA('', arrs);
}

function innerA(prefix, arrs) {
  const [fisrt, ...rest] = arrs;
  if (!rest.length) {
    return fisrt.map(i => prefix + i);
  }

  return fisrt.reduce((acc, i) => {
    acc = acc.concat(innerA(prefix + i, rest));
    return acc;
  }, []);
}

a(['1', '2'], ['a', 'b', 'c', 'd'], ['!', '@', '#', '$']);

Answer 2

来个循环的，不过效率似乎没递归那个高，可能是因为创建的对象要多一些

function b(...groups) {
    let r = [""];
    for (let group of groups) {
        r = r.map(t1 => group.map(t2 => t1 + t2))
            .reduce((acc, t) => acc.concat(t));
    }
    return r;
}

如果不使用 map()，直接用循环会效率高一些，比递归的效率高

function c(...groups) {
    let r = [""];
    for (let group of groups) {
        const newr = [];
        for (let t1 of r) {
            for (let t2 of group) {
                newr.push(t1 + t2);
            }
        }
        r = newr;
    }
    return r;
}