Apologies about the formatting, blogs are the worst at that.

The point isn’t about “where it came from”. I get with try/catch it’s “it’s this try/catch block _here_ that is the problem”. That’s a start, sure, but generally at runtime, none of it matters. What you should be doing is:

Step 1: promise chain to catch all or try/catch all.
Step 2: return errors from functions vs. raising & explaining them vs. “where did things go wrong”. Like Go/Lua.
Step 3: If more than 1 possible failure, return union type / discriminated union.
Step 4: If you continue to use JavaScript without types, still keep 1 single catch or try/catch.

Step 2 and 3 aren’t what people usually think about. In JavaScript, the attitude typically is “anything can fail, keep running as fast as possible the code over and over until we figure out all possible errors”. Instead, if you focus on an individual function’s ability to either work or not. Pure functions like “getting todays date”, you’re ok, but things like “make an HTTP call” are insanely complex. At first, you can only return 2 things; it worked, or didn’t. Later, once you learn the HTTP status codes, what their values mean with the API you’re interacting with, and the response JSON/XML/HTML/whatever format, you can further add more helpful return values or error values.

In short, don’t use throw, don’t use catch. Make all functions pure, and only return errors at first that verbose. Later, you can return multiple types of errors, and either chain them using Promises (since catch is built-in) or their native bind functionality.

You can have interleave different then/catches exactly as you can interleave different try/catches.


someFn()
.then(anotherFn)
.catch(thatFn)
.then(anotherFn)
.then(anotherFn)
.catch(thatFn)

async wrapper() => {
try {
await someFn();
} catch(e) {
thatFn()
}
try {
...
etc


I really see no difference, except that you can debug the async/await much more easily.

Another thing that you can do, of course, is to create different types of errors, and catch them all at the end


try {
await someFn()
if (something) {
throw ErrorX()
}
await anotherFn() || throw ErrorY();
...
}
catch (e) {
if (e instaceof ErrorX)
...