try..catch: перехват ошибок

Обычный скрипт выполняется как список поручений: строка за строкой. Ошибка рвёт этот список — движок останавливается ровно там, где споткнулся, и остальное не выполняется. try..catch ставит на пути ошибки сеть: всё, что упало внутри try, попадает в catch, а программа идёт дальше.

try {
  console.log("шаг 1");
  null.length;
  console.log("шаг 2");
} catch (err) {
  console.log("поймали", err.name);
}

В catch приходит объект ошибки. У него есть name — тип поломки, message — человеческое описание и stack — путь, по которому движок дошёл до беды. Текст message пишут разработчики движка, поэтому в разных браузерах он может отличаться словами; name и тип — одинаковые везде.

try {
  JSON.parse("{ это не JSON }");
} catch (err) {
  console.log(err.name);
  console.log(typeof err.message);
  console.log(err instanceof Error);
}

Скобки у catch можно не писать вовсе: catch { ... }. Так делают, когда сам объект ошибки не нужен — важен только факт падения.

try..catch работает только с ошибками времени выполнения — теми, что случаются, когда код уже запущен. Если в файле забыта скобка, движок не сможет даже разобрать текст программы и не запустит из него ни строчки: ловить будет некому, потому что сам try не успеет появиться. Правило простое — сначала код должен уметь запуститься, и только потом его можно защищать.

try {
  const total = 10;
  total = 20;
} catch (err) {
  console.log(err.name);
}
console.log("скрипт живёт дальше");

Второе ограничение: «неправильный ответ» — это не ошибка. Number("двенадцать") вернёт NaN, обращение к несуществующему свойству вернёт undefined, и никакого исключения не будет. catch в таких местах просто не сработает — проверять значения приходится руками.

try {
  const n = Number("двенадцать");
  console.log(n);
  console.log("исключения не было");
} catch (err) {
  console.log("сюда не попадём");
}

Блок finally выполняется всегда: и когда всё прошло гладко, и когда сработал catch, и даже когда внутри try стоит return. Это место для уборки — снять флаг загрузки, остановить таймер, закрыть соединение. Уборка не должна зависеть от того, повезло нам или нет.

function getValue(raw) {
  try { return JSON.parse(raw).value; }
  catch (err) { return 0; }
  finally { console.log("finally сработал"); }
}
console.log(getValue("сломано"));

Обратите внимание на порядок: функция уже вычислила, что вернуть, но пока не отдала результат наружу — finally вклинивается ровно в этот момент. Поэтому «после return ничего не выполняется» — правило с исключением, и это исключение называется finally.

function f() {
  try { return "из try"; }
  finally { return "из finally"; }
}
console.log(f());

Ошибки бросает не только движок — их можно бросать самому оператором throw. Технически бросить разрешено что угодно, хоть строку, хоть число, но так делать не стоит: у объекта Error есть name, message и стек вызовов, а у строки — ничего. Пишите throw new Error("...") и выбирайте встроенный подтип по смыслу: TypeError для не того типа, RangeError для недопустимого значения.

function setAge(age) {
  if (typeof age !== "number") {
    throw new TypeError("возраст должен быть числом");
  }
  return age;
}
try { setAge("сорок"); }
catch (err) { console.log(err.message); }

Хорошее сообщение отвечает на вопрос «что именно пошло не так», а не «всё плохо». Сравните: «ошибка данных» и «возраст должен быть числом» — второе можно чинить, не заглядывая в исходники.

class ValidationError extends Error {
  constructor(message) {
    super(message);
    this.name = "ValidationError";
  }
}
try { throw new ValidationError("имя пустое"); }
catch (err) { console.log(err.name, err.message); }

try..catch — синхронный сторож. Он охраняет ровно тот отрезок времени, пока выполняются строки внутри блока. Колбэк setTimeout запускается позже, когда try давно закрыт, — поймать оттуда ошибку он уже не может, как зонт не спасает от дождя, который пойдёт завтра.

С промисами та же история. Вызов асинхронной функции без await просто возвращает промис и мгновенно идёт дальше; ошибка внутри превращается в отклонение промиса и пролетает мимо catch. Лечится это одним словом — await внутри try — или методом .catch() на самом промисе.

async function load() {
  throw new Error("сеть недоступна");
}
async function main() {
  try { await load(); }
  catch (err) { console.log("поймали:", err.message); }
}
main();

Проверка простая: если ошибка может случиться не сейчас, а «когда-нибудь потом», обычный try её не увидит. Нужно либо дождаться результата через await, либо ловить прямо в том месте, где код продолжится, — внутри самого колбэка.

Самый вредный catch — пустой. Он не чинит поломку, а прячет её: программа делает вид, что всё хорошо, и продолжает работать с несуществующими данными. Такой баг всплывёт через три экрана и на совсем другой строке.

try {
  JSON.parse("сломано");
} catch (err) {
}
console.log("данные загружены");

Правило одно: в catch вы либо действительно справляетесь с проблемой — подставляете запасное значение, показываете сообщение, пишете в лог, — либо честно пробрасываете ошибку дальше через throw err. И ловите только то, что умеете обработать: чужая ошибка должна лететь наверх, к тому, кто про неё знает.

try {
  JSON.parse("сломано");
} catch (err) {
  if (!(err instanceof SyntaxError)) throw err; // чужое пропускаем дальше
  console.log("не смог разобрать ответ:", err.name);
}