Javascript 编写一个递归函数，迭代嵌套循环的未知深度

给定一个值数组：

var values = new Array(); 

array.push(2);
array.push(3);
array.push(4); 

我想创建一个迭代函数，它可以存储任意长度数组中所有可能的值组合

例如，在这种情况下，可能的值是（1,1,1）（1,1,2）（1,1,3）（1,1,4）（1,2,1）（1,2,2）（1,2,3）（1,2,4）（2,1,1）（2,1,2）（2,1,3）（2,1,4）（2,2,1）（2,2,3）（2,2,4）

我知道要做到这一点，我需要使用一个递归函数，如果没有达到最大深度，它会更深一层并再次调用该函数

我知道从哪里开始（我想可能是吧）

函数迭代循环（级别、深度）{
对于（变量i=0；i

我不知道，一旦函数被调用得更深，我如何才能访问“更高”级别。。。i、 e.我不确定如何访问（1,2,4），而不仅仅是（？，4）

我希望这有意义

---

（很抱歉，我知道我的标题不是很好，我想不出如何简洁地解释它）

您不需要递归，因为任意数据集的长度是在运行时开始时定义的：

var numbers = [2,3,4];
var result_array = [];
var num_product = 1;
var i=0, j=0, k=0; // iterators

for (i=0; i<numbers.length; i++) {
    num_product *= numbers[i];
}
for (i=0; i<num_product; i++) {
    result_array.push([]);
}
for (i=0; i<result_array.length; i++) {
    product = 1;
    for (j=0; j<numbers.length; j++) {
        k = (Math.floor(i/product)%numbers[j]) + 1;
        product *= numbers[j];
        result_array[i][j] = k;
    }
}

var数=[2,3,4]；
var结果_数组=[]；
var num_乘积=1；
变量i=0，j=0，k=0；//迭代器
对于（i=0；i
我不确定在函数被调用到更深层时如何访问“上层”…也就是说，我不确定如何访问（1,2,4），而不仅仅是（？，，4）

您将需要传递它们，例如在数组中


如果要对这些值进行迭代，可以通过向结果数组添加越来越多的状态（每个级别增加一个值），最终将包含所有可能的组合：

var values = [2,3,4];
var result = [[]]; // one empty state at level 0
for (var i=0; i<values.length; i++) {
    var reslen = result.length,
        val = values[i];
    var mult = []; // will become the new result with a length of (reslen * val)
    for (var j=0; j<reslen; j++) {
        for (var k=1; k<=val; k++) {
            var state = result[j].slice(); // make a copy
            state.push(k);
            mult.push(state);
        }
    }
    result = mult;
}

// logging the `result` on each level will show us
// 0 - [[]]
// 1 - [[1],[2]]
// 2 - [[1,1],[1,2],[1,3],[2,1],[2,2],[2,3]]
// 3 - [[1,1,1],[1,1,2],[1,1,3],[1,1,4],[1,2,1],[1,2,2],[1,2,3],[1,2,4],[1,3,1],[1,3,2],[1,3,3],[1,3,4],[2,1,1],[2,1,2],[2,1,3],[2,1,4],[2,2,1],[2,2,2],[2,2,3],[2,2,4],[2,3,1],[2,3,2],[2,3,3],[2,3,4]]

var值=[2,3,4]；
var result=[[]]；//级别0处有一个空状态
对于（var i=0；您要找的词是“递归的”，而不是“迭代的”（如果您正在搜索，可能会有帮助）。如果我有时间，我会写一个例子。而且，可能没有必要。现在就写一个答案。您永远不必真正编写递归函数。第一段代码意味着
var值=[2,3,4]
还是我遗漏了什么？我仍然想知道
1
从何而来=/递归从何而来^^^当我对最初的问题进行评论时，我认为这更适合于非递归方法，我的印象是他不要求它是递归的，他只是认为这是必要的。不幸的是，我有点草率我不认为我的解决方案是可行的。等我有时间的时候，我会回来再看一看。我确实需要它，正如我发布的那样，我希望它适用于任何长度的数组。3长度数组只是一个例子。我修正了算法，它适用于任何长度的数组，你不需要递归。
for(var i = 0; i < values.length; i++)

var values = [2,3,4];
function recurse(state) {
    var level = state.length;
    var depth = values.length;
    if (level == depth) {
        console.log.apply(console, state); // or whatever you want to do
    } else {
        for (var i=1; i<=values[level]; i++) {
            state.push(i); // save current question mark
                           // notice state.length = level + 1 now
            recurse(state); // enter next level
            state.pop(); // delete it after we're so state doesn't grow infinitely :-)
        }
    }
}
recurse([]);

var values = [2,3,4];
var result = [[]]; // one empty state at level 0
for (var i=0; i<values.length; i++) {
    var reslen = result.length,
        val = values[i];
    var mult = []; // will become the new result with a length of (reslen * val)
    for (var j=0; j<reslen; j++) {
        for (var k=1; k<=val; k++) {
            var state = result[j].slice(); // make a copy
            state.push(k);
            mult.push(state);
        }
    }
    result = mult;
}

// logging the `result` on each level will show us
// 0 - [[]]
// 1 - [[1],[2]]
// 2 - [[1,1],[1,2],[1,3],[2,1],[2,2],[2,3]]
// 3 - [[1,1,1],[1,1,2],[1,1,3],[1,1,4],[1,2,1],[1,2,2],[1,2,3],[1,2,4],[1,3,1],[1,3,2],[1,3,3],[1,3,4],[2,1,1],[2,1,2],[2,1,3],[2,1,4],[2,2,1],[2,2,2],[2,2,3],[2,2,4],[2,3,1],[2,3,2],[2,3,3],[2,3,4]]