Обработка ошибок: try/catch

try/catch позволяет перехватывать ошибки, не останавливая всю программу. Код в try выполняется. Если происходит ошибка — выполняется catch. finally выполняется всегда, независимо от ошибки.

Без try/catch: JSON.parse('невалидный JSON'); // Ошибка! Весь скрипт останавливается.

С try/catch: try { JSON.parse('невалидный JSON'); } catch (error) { console.log('Ошибка:', error.message); } // Программа продолжает работу!

Синтаксис: try { // код, который может вызвать ошибку } catch (error) { // выполняется при ошибке // error.message — описание ошибки // error.name — тип ошибки } finally { // выполняется ВСЕГДА }

Типы ошибок:

• Error — базовый тип
• TypeError — неправильный тип
• ReferenceError — необъявленная переменная
• SyntaxError — синтаксическая ошибка
• RangeError — значение вне диапазона

Throw — создание собственных ошибок: throw new Error('Что-то пошло не так'); throw new TypeError('Ожидается число');

Когда использовать try/catch:

• Работа с JSON.parse()
• Доступ к неизвестным данным (API, пользовательский ввод)
• Операции с файлами
• Когда ошибка — ожидаемая ситуация

try/catch — как подушка безопасности. Вы прыгаете с высоты (рискованный код), но если что-то пойдёт не так — подушка поймает вас (catch) и не даст разбиться.

**Самый простой:**

try {
  console.log('Начало');
  JSON.parse('не JSON');
  console.log('Конец'); // Не выполнится!
} catch (error) {
  console.log('Ошибка:', error.message);
}
// Начало
// Ошибка: Unexpected token... 

catch перехватывает ошибку, и программа продолжает работу.

**Простой:**

function parseData(jsonString) {
  try {
    return JSON.parse(jsonString);
  } catch (error) {
    console.error('Невалидный JSON:', error.message);
    return null;
  }
}

parseData('{"name": "Анна"}'); // { name: 'Анна' }
parseData('не JSON');           // null

Функция безопасно обрабатывает ошибку и возвращает null вместо падения.

**Реальный пример:**

function divide(a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new TypeError('Аргументы должны быть числами');
  }
  if (b === 0) {
    throw new Error('Деление на ноль');
  }
  return a / b;
}

try {
  console.log(divide(10, 2)); // 5
  console.log(divide(10, 0)); // Ошибка!
} catch (error) {
  console.error(error.message); // 'Деление на ноль'
}

throw создаёт собственные ошибки. Это полезно для валидации входных данных.

**Неправильно:** Использовать try/catch для всех ошибок

**Почему:** try/catch — для ожидаемых ошибок (невалидный JSON, сетевые запросы). Не для программных ошибок.

**Правильно:** Исправляйте ошибки в коде, а не перехватывайте их.

**Неправильно:** Забывать, что catch ловит только ошибки в try

**Почему:** Ошибка в catch НЕ ловится этим же catch. Нужен вложеный try/catch.

**Правильно:** Каждый try/catch ловит ошибки только в своём try-блоке.

**Неправильно:** Пустой catch

**Почему:** catch (error) {} — игнорирует ошибку. Проблема остаётся невидимой.

**Правильно:** Всегда логируйте ошибку: console.error(error).

• try/catch перехватывает ошибки, не останавливая программу
• catch(error) — получает объект ошибки
• finally — выполняется всегда
• throw new Error() — создание собственных ошибок
• Используйте для ожидаемых ошибок, не для программных

Назад: Вы знаете методы строк и чисел (J21-J22) — теперь вы умеете обрабатывать их сбои.

Вперёд: Следующий урок (J24) — пользовательские ошибки: создание собственных типов ошибок.