11. Errors and exceptions

A quiet wrong answer

In the last chapter you turned digit strings into numbers. Here’s that function again:

function toNumber(s) {
  let n = 0;
  for (let i = 0; i < s.length; i++) {
    n = n * 10 + (s.charCodeAt(i) - 48);
  }
  return n;
}

console.log(toNumber('42')); // 42
console.log(toNumber('4x')); // 112 (!)

'4x' isn’t a number at all, but the function happily answers 112, because 'x' has code 120, and 120 − 48 is 72. Nothing crashes. The nonsense value just flows on into the rest of the program, and the bug shows up somewhere far away, much later, looking like something else.

A quiet wrong answer is the worst kind of bug. What toNumber needs is a way to refuse: “I can’t do this, and here’s why.”

throw

function toNumber(s) {
  let n = 0;
  for (let i = 0; i < s.length; i++) {
    const c = s.charCodeAt(i);
    if (c < 48 || c > 57) {
      throw new Error(`bad digit at ${i}`);
    }
    n = n * 10 + (c - 48);
  }
  return n;
}

toNumber('4x');
// Error: bad digit at 1

(|| means “or”: true if either side is true.) throw stops the function on the spot. It doesn’t return anything, not even undefined. If nothing handles the error, the whole program stops and the error is reported, so you find out about the problem exactly where it happened.

try and catch

Sometimes a problem is expected, and you know what to do about it. Wrap the risky code in try, and say what to do if it throws in catch:

try {
  const n = toNumber('4x');
  console.log('got', n); // skipped
} catch (e) {
  console.log('oops: ' + e.message);
} finally {
  console.log('done');
}
// oops: bad digit at 1
// done

The moment toNumber throws, the rest of the try block is skipped and control jumps into catch. The thrown value arrives as e. If nothing throws, catch is skipped completely. And finally runs either way, which makes it the place for clean-up that must always happen.

function check(n) {
  if (n < 0) {
    throw new Error('negative: ' + n);
  }
  return n;
}

try {
  console.log(check(3));
  console.log(check(-1));
  console.log('not reached');
} catch (e) {
  console.log(e.name, e.message);
} finally {
  console.log('finally');
}
console.log('carrying on');

What’s inside an Error

An Error object is an ordinary object with two properties you’ll use constantly: message, the text you gave it, and name, the kind of error^[2]. JavaScript itself throws several kinds. You’ve already met some of them:

null.x;      // TypeError
missing + 1; // ReferenceError
forever(0);  // RangeError (chapter 9)
let 1x = 0;  // SyntaxError

You can make your own kinds of error with a class. A scanner, for example, wants to say where the problem is:

class ParseError extends Error {
  constructor(message, pos) {
    super(message);
    this.name = 'ParseError';
    this.pos = pos;
  }
}

Two new words here. extends Error makes ParseError a special kind of Error: it gets everything an Error has. And super(message) runs Error’s own constructor first, so the message is set up properly. Then instanceof lets a catch tell the kinds apart:

try {
  throw new ParseError('bad digit', 1);
} catch (e) {
  if (e instanceof ParseError) {
    console.log(`${e.message} at ${e.pos}`);
  } else {
    throw e; // not ours: pass it on
  }
}

That last line matters. A catch that doesn’t recognize an error can rethrow it, so it keeps travelling to code that does.

How an error travels

When something throws, where does it go? Not just to the function that called it. It goes back down the call stack, frame by frame, until it finds a try. Step through it:

function digit(c) {
  if (c < 48) {
    throw new Error('bad digit');
  }
  return c - 48;
}
function parse(s) {
  return digit(s.charCodeAt(0)) + 1;
}
 
try {
  console.log(parse('+'));
} catch (e) {
  console.log('caught: ' + e.message);
}

This is what makes exceptions so useful. The function that notices a problem (digit) is often deep in the stack, and has no idea what to do about it. The code that knows what to do (show a message, skip one line of input) is often far below. Throwing connects the two without every function in between having to check for and pass along error values.

Your turn

function parseDigits(s) {
  // your code here
}

console.log(parseDigits('42'));

function attempt(f) {
  // your code here
}

console.log(attempt(() => 42));

What you learned

• throw new Error(message) stops the code immediately. It’s far better than returning a quiet wrong answer.
• try/catch handles errors: if the try block throws, the rest of it is skipped and catch (e) runs. finally runs either way.
• An Error object has a name and a message. Custom error classes extends Error and carry extra details, like a position.
• A thrown error propagates: it unwinds the call stack, popping frames, until it reaches the nearest try. Unhandled, it stops the program.

Last chapter of the day: splitting a program across files.