In Javascript, what's better than try/catch for exiting an outer scope?

Question

In Javascript, I sometimes want to return a value from a scope that isn't the current function. It might be a block of code within the function, or it might be an enclosing function as in the following example, which uses a local function to recursively search for something. As soon as it finds a solution, the search is done and the outer function should just exit. Unfortunately, I can't think of a simpler way to do this than by hacking try/catch for the purpose:

function solve(searchSpace) {
    var search = function (stuff) {
        var solution = isItSolved(stuff);
        if (solution) {
            throw solution;
        } else {
            search(narrowThisWay(stuff));
            search(narrowThatWay(stuff));
        };
    };
    try {
        return search(searchSpace);
    } catch (solution) {
        return solution;
    };
};

I realize one could assign the solution to a local variable and then check it before making another recursive call, but my question is specifically about transfer of control. Is there a better way than the above? Perhaps involving label/break?

Edit: since the answers to date are variations of "ew that's bad you're not supposed to do that", let me add some necessary context. I'm hacking on an open-source compiler that targets Javascript. No one is going to write this code by hand, so please don't tell me "this is a bad programming technique". What I want is a better code generation technique. The question is whether anyone has any clever hack for exploiting Javascript to get more flexible control transfer.

The reason assigning the result to a local variable and checking it is ruled out is because that requires understanding the code in a way that is hard for a compiler to do.

Answer 1

It seems I stand corrected on the intent of the question. If statements are are a useful and readable way to structure code and make it flow however you want to. There's a reason goto was taken out of so many languages, because you don't need it. And it seems like, based on your example code, you're using a try-catch block as a form of goto. If you don't want certain things to run then use if statements or equivalents:

function solve(searchSpace) {
    function search = function (stuff) {
        //|| will only return the first value if that value is truthy, subsequent values will be ignored
        return isItSolved(stuff) || (search(narrowThisWay(stuff)) || search(narrowThatWay(stuff)));
    };
    return search(searchSpace);
};

I know of no way to break out of function calls like you want. You can break out of loops using labels, but it doesn't seem that's much help to your situation. Other than that, I don't think JavaScript has any such ability beyond your use of exceptions

Answer 2

It looks like you're doing a fairly straightforward recursive search in your example. Why not just use "return"?

function solve(searchSpace) {
    var search = function (stuff) {
        var solution = isItSolved(stuff);
        if (solution) {
            return solution;
        } else {
            solution = search(narrowThisWay(stuff));
            if (solution) {
              return solution;
            }
            return search(narrowThatWay(stuff));
        };
    };
    return search(searchSpace);
};

I suppose it could be that there are other constraints you haven't mentioned, but it's in general possible to turn any control flow into a set of nested (or recursive) functions, with appropriate return values.

Answer 3

function solve(stuff) {
    return isItSolved(stuff) || solve(narrowThisWay(stuff)) ||     solve(narrowThatWay(stuff));
}

Bob's way is good... exept that he uses twice the function statement (and that he uses ; after a function delaration without an assignment)... and that as we can do it that way, function solve actually is function search.

PS : This code will epically fail if the isItSolved, narrowThisWay or narrowThatWay functions can return a value evaluated to false as a positive result. In this cas, you would have to use ? : statement in order to check if all responses are !== undefined.

PS2: And of ourse, if these function can send an error, you have to catch it...

Answer 4

The cleanest way would be to use a continuation, but you don't have that efficiently in JS (a few JS engines support continuations, but for the rest there's only CPS, which cries out for tail calls). In C, you could use setjmp/longjmp. In Common Lisp, you could use conditions (which include the functionality of exceptions plus much more). In JS, exceptions are the only non-local control flow option you have available.

You can programmatically transform a program into another that uses CPS.

function solve(searchSpace, isItSolved, isBase, narrowThisWay, narrowThatWay) {
    function search(stuff, k) {
        solution = isItSolved(stuff);
        if (solution) {
            return solution;
        } else if (isBase(stuff)) {
            return k();
        } else {
            return search(narrowThisWay(stuff), function() {
                    return search(narrowThatWay(stuff), k);
                });
        };
    };
    return search(searchSpace, function(val) {return val});
};


var arr=[1, 2,9,72,0,34,5,33,24,62,89,90,30,54,590,23,59,62,73];

solve(arr, function(a) {return (a.length==1 && a[0] == 5) ? a[0] : false;},
      function (a) {return a.length < 2; },
      function (a) {return a.slice(0, a.length / 2);}, 
      function (a) {return a.slice(a.length / 2);}
    );