Javascript嵌套的while循环中带有continue语句的行为不符合预期

Question

I'm trying to find all permutations of 3 arrays using nested while loops and the continue statement. It's almost working as I'd like, but is adding an extra element when control is given back to the outerloop. I'm going to rewrite it using recursion, but would like to know why it's doing this. Here's a link: http://jsbin.com/fuyup/15/edit

Thanks for any advice.

function findPermutations() {
    var g1 = ['a1', 'a2'],
        g2 = ['b1', 'b2', 'b3'];
        g3 = ['c1', 'c2', 'c3', 'c4'];

    var g1p = 0,
        g2p = 0, 
        g3p = 0,
        g1len = g1.length,
        g2len = g2.length,
        g3len = g3.length, 
        temp = [],
        result = [];

    outerloop: while (g1p < g1len) {
        temp.push(g1[g1p]);

        while (g2p < g2len) {
            temp.push(g2[g2p]);

            while (g3p < g3len) {
                temp.push(g3[g3p]);
                result.push(temp);
                temp = [];  
                g3p++;
                continue outerloop;
            }

            g3p = 0;
            g2p++;
        }

        g2p = 0;
        g1p++;
    }
    return result;
}

Answer 1

With that continue and the spare temp = [] reset your control flow is really messed up.

Before g3p = 0; is executed and the innermost loop (that pushes to result and resets temp ), the flow jumps back to temp.push(g2[g2p]); which is called twice on a the same temp array. I'm not going into detail here… If you need to know, use a debugger and step through the execution.

I've made a working version that uses continue , but I'm not really lucky with it:

outerloop: while (g1p < g1len) {
    temp.push(g1[g1p]);
    while (g2p < g2len) {
        temp.push(g2[g2p]);
        while (g3p < g3len) {
            temp.push(g3[g3p]);

            result.push(temp);

            temp = [];  
            g3p++;
            continue outerloop; 
        }
        g3p = 0;

        temp = [];
        g2p++;
        continue outerloop; 
    }
    g2p = 0;

    temp = [];
    g1p++;
    // continue outerloop; (implicit)
}

You can see the symmetric structure here, on every level the same things happen. And whenever we enter the outerloop to get the sequence

temp.push(g1[g1p]); temp.push(g2[g2p]); temp.push(g3[g3p]); result.push(temp);

executed, we reset temp before.

---

The usual idea to create permutations is to use no continue , but nest normal for loops that mutate an array, and take snapshots of each state to append to the result:

temp = [];
g1p = 0;
while (g1p < g1len) {
    temp[0] = g1[g1p];

    g2p = 0;
    while (g2p < g2len) {
        temp[1]= g2[g2p];

        g3p = 0;
        while (g3p < g3len) {
            temp[2] = g3[g3p];

            result.push(temp.slice());

            g3p++;
        }
        g2p++;
    }
    g1p++;
}