Understanding try and catch in node.js

Question

I'm new to coding. Trying to understand why try...catch isn't supposed to work in node.js. I've created an example, but contrary to expectations, try...catch seems to be working. Where am I going wrong in my understanding ? Please help.

function callback(error) { console.log(error); }
function A() {
    var errorForCallback;
    var y = parseInt("hardnut");
    if (!y) {
        throw new Error("boycott parsley");
        errorForCallback = "boycott parsley for callback";
    }
    setTimeout(callback(errorForCallback),1000);
}

try {
    A();
}
catch (e) {
    console.log(e.message);
}
// Output: boycott parsley
// Synchronous behaviour, try...catch works

-----------Example re-framed to reflect my understanding after reading answer below----------

function callback(error) { console.log(error); }
function A() {
    var errorForCallback;
    setTimeout(function(){
        var y = parseInt("hardnut");
        if (!y) {
            // throw new Error("boycott parsley");
            errorForCallback = "boycott parsley for callback";
        }
        callback(errorForCallback);         
    }, 1000);

}
try {
    A();
}
catch (e) {
    console.log(e.message);
}
// Output: boycott parsley for callback
// Asynchronous behaviour
// And if "throw new Error" is uncommented, 
// then node.js stops

Why do you think it's not supposed to work in node.js? It just won't work for exceptions thrown from an asynchronous task. If you want to catch those kinds of errors, you could look into using domains. — mscdex
– mscdex, Commented Jun 14, 2014 at 0:15

Edwin Dalorzo · Accepted Answer · 2021-02-11 16:14:19Z

The try-catch approach is something that works perfectly with synchronous code. Not all the programming that you do in Node.js is asynchronous and so in those pieces of synchronous code that you write you can perfectly use a try-catch approach. Asynchronous code, on the other hand, does not work that way.

For instance, if you had two function executions like this

var x = fooSync();
var y = barSync();

You would expect three things, first that barSync() would be executed only after fooSync() has finished, and you would expect that x would contain whatever value is returned by the execution of fooSync before barSync() is executed. Also you would expect that if fooSync throws an exception, barSync is never executed.

If you would use a try-catch around fooSync() you could guarantee that if fooSync() fails you can catch that exception.

Now, the conditions completely change if you would have a code like this:

var x = fooAsync();
var y = barSync();

Now imagine that when fooAsync() is invoked in this scenario, it is not actually executed. It's just scheduled for execution later on. It is as if node would have a todo list, and at this moment it is too busy running your current module, and when it finds this function invocation, instead of running it, it simply adds it to the end of its todo list.

So, now you cannot guarantee that barSync() will run before fooAsync(), as a matter of fact, it probably won't. Now you don't control the context in which fooAsync() is executed.

So, after scheduling the fooAsync() function, it immediately moves to execution of barSync(). So, what can fooAsync() return? At this point nothing, because it has not run yet. So x above is probably undefined. If you would put try-catch around this piece of code it would be pointless, because the function will not be executed in the context of this code. It will be executed later on, when Node.js checks if there are any pending tasks in its todo list. It will be executed in the context of another routine that is constantly checking this todo list, and this only thread of execution is called an event loop.

If your function fooAsync() gets to fail, it will fail in the context of execution of this thread running the event loop and therefore it would not be caught by your try-catch statement, at that point, that module above may have probably finished execution.

So, that is why in asynchronous programing you cannot either get a return value, neither can you expect to do a try-catch, because you code is evaluated somewhere else, in another context different from the one where you think you invoked it. It is as if you could would have done something like this instead:

scheduleForExecutionLaterWhenYouHaveTime(foo);
var y = barSync();

And that's the reason why asynchronous programming requires other techniques to determine what happened to your code when it finally runs. Typically this is notified through a callback. You define a callback function which is called back with the details of what failed (if anything) or what your function produced and then you can react to that.

Thanks for the detailed explanation. I've re-framed my example based on this understanding. If I uncomment "throw new Error...", then node.js stops. Is it because it is trying to throw an error outside of try ?
'throw' is similar to 'return' in that no more code within the function will execute after it. When you throw here, you're preventing the callback from ever being invoked.
Great clear explanation. But I'm wondering about "not all the programming that you do in Node.js is asynchronous." When does node execute code synchronously, other than with callbacks/sync libraries?

Collectives™ on Stack Overflow

Understanding try and catch in node.js

1 Answer 1

3 Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Related