Eloquent JavaScript

Selective catching
When an exception makes it all the way to the bottom of the stack without
being caught, it gets handled by the environment. What this means differs
between environments. In browsers, a description of the error typically gets
written to the JavaScript console (reachable through the browser’s Tools or
Developer menu). Node.js, the browserless JavaScript environment we will
discuss in
Chapter 20
, is more careful about data corruption. It aborts the
whole process when an unhandled exception occurs.
For programmer mistakes, just letting the error go through is often the best
you can do. An unhandled exception is a reasonable way to signal a broken
program, and the JavaScript console will, on modern browsers, provide you
with some information about which function calls were on the stack when the
problem occurred.
For problems that are
expected
to happen during routine use, crashing with
an unhandled exception is a terrible strategy.
138

---

Invalid uses of the language, such as referencing a nonexistent binding, look-
ing up a property on
null
, or calling something that’s not a function, will also
result in exceptions being raised. Such exceptions can also be caught.
When a
catch
body is entered, all we know is that
something
in our
try
body caused an exception. But we don’t know
what
did or
which
exception it
caused.
JavaScript (in a rather glaring omission) doesn’t provide direct support for
selectively catching exceptions: either you catch them all or you don’t catch
any. This makes it tempting to
assume
that the exception you get is the one
you were thinking about when you wrote the
catch
block.
But it might not be. Some other assumption might be violated, or you might
have introduced a bug that is causing an exception. Here is an example that
attempts
to keep on calling
promptDirection
until it gets a valid answer:
for (;;) {
try {
let dir = promtDirection("Where?"); // ← typo!
console.log("You chose ", dir);
break;
} catch (e) {
console.log("Not a valid direction. Try again.");
}
}
The
for (;;)
construct is a way to intentionally create a loop that doesn’t
terminate on its own. We break out of the loop only when a valid direction is
given.
But
we misspelled
promptDirection
, which will result in an “undefined
variable” error. Because the
catch
block completely ignores its exception value
(
e
), assuming it knows what the problem is, it wrongly treats the binding error
as indicating bad input. Not only does this cause an infinite loop, it “buries”
the useful error message about the misspelled binding.
As a general rule, don’t blanket-catch exceptions unless it is for the purpose
of “routing” them somewhere—for example, over the network to tell another
system that our program crashed. And even then, think carefully about how
you might be hiding information.
So we want to catch a
specific
kind of exception. We can do this by checking
in the
catch
block whether the exception we got is the one we are interested
in and rethrowing it otherwise. But how do we recognize an exception?
We could compare its
message
property against the error message we happen
to expect. But that’s a shaky way to write code—we’d be using information
that’s intended for human consumption (the message) to make a programmatic
139

---

decision. As soon as someone changes (or translates) the message, the code will
stop working.
Rather, let’s define a new type of error and use
instanceof
to identify it.
class InputError extends Error {}
function promptDirection(question) {
let result = prompt(question);
if (result.toLowerCase() == "left") return "L";
if (result.toLowerCase() == "right") return "R";
throw new InputError("Invalid direction: " + result);
}
The new error class extends
Error
. It doesn’t define its own constructor,
which means that it inherits the
Error
constructor, which expects a string
message as argument. In fact, it doesn’t define anything at all—the class is
empty.
InputError
objects behave like
Error
objects, except that they have a
different class by which we can recognize them.
Now the loop can catch these more carefully.
for (;;) {
try {
let dir = promptDirection("Where?");
console.log("You chose ", dir);
break;
} catch (e) {
if (e instanceof InputError) {
console.log("Not a valid direction. Try again.");
} else {
throw e;
}
}
}
This will catch only instances of
InputError
and let unrelated exceptions
through. If you reintroduce the typo, the undefined binding error will be prop-
erly reported.