这个递归组合函数中的“return a”有什么作用？

Question

I went over this function over and over in Chrome debugger and still can't understand what return a does. Thanks for helping me out!

Here's some clarification: I understand the first round. The anonymous function gets called with the following parameters:

active = "", rest = "abc", a = []

It then calls itself til rest is empty, when it populates the a array:

active = "abc", rest = "", a = ["abc"]

At this point we arrive to return a , and the debugger jumps to the second fn call in the else statement instead of the first if statement. The parameters already look like this:

active = "ab", rest = "c", a = ["abc"]

This is the part I don't understand at all. I know the recursion is only over when active and rest is empty, but after return a the if statements don't even get checked in the debugger, it just highlights the mentioned second function call, and at that point "c" is already assigned to rest . I guess the reason why this function doesn't produce duplicates also lies here, but that might be another question if not. Anyway, thanks again for the help!

combinations("abc");

function combinations(str) {
    var fn = function(active, rest, a) {
        if (!active && !rest)
            return;
        if (!rest) {
            a.push(active);
        } else {
            fn(active + rest[0], rest.slice(1), a);
            fn(active, rest.slice(1), a);
        }
        return a;
    }
    return fn("", str, []);
}

Answer 1

In this case the recursion construct is written oddly and the "return a" is merely to smuggle out the mutated array, the same object initially supplied, back to the helper function so that a direct return can be used on the inner recursive function call. (In most contexts, and especially those discussed in recursion primers , recursive functions usually utilize the returned value.)

Here is a cleaner re-write using the helper function more. I also removed all explicit return statements because they were not adding value here.

function combinations(str) {
    var fn = function(active, rest, a) {
        if (!active && !rest) {
            // base case #1 - implicit return, no recursive call
        } else if (!rest) {
            // base case #2 - implicit return, no recursive call
            a.push(active);
        } else {
            // recursive case, where function is called again
            // (the object "a" is modified in recursion;
            //  result of recursion not directly used)
            fn(active + rest[0], rest.slice(1), a);
            fn(active, rest.slice(1), a);
        }
    }

    var o = [];     // only one output object created..
    fn("", str, o); // ..mutated..
    return o;       // ..and returned to caller.
}

It should then be easy to observe that passing "a" to the recursive function is not needed (ie. it could access "o" in the enclosing scope) because there is no new object assigned to "a" after the initial result array is created.

There is a subtle difference in the re-write will (more correctly) return an empty array for an empty input string.

Answer 2

While I understand that this question is primarily about how that particular recursive implementation works (and there's already an excellent answer to that!), I think it's worth pointing out that it's an odd implementation, and something like this is probably cleaner:

 const combinations = (str, active = '') => str .length == 0 ? active .length == 0 ? [] : [active] : [ ... combinations (str .slice (1), active + str [0]), ... combinations (str .slice (1), active) ] console .log (combinations ('abc'))