Узнайте, как обрабатывать ошибки в программировании на JavaScript и уменьшать количество ошибок и проблем в вашем коде.

В мире программирования ошибки неизбежны. Разработчику JavaScript важно понимать, как эффективно обрабатывать ошибки. В этой статье мы рассмотрим различные способы управления ошибками в JavaScript, включая синхронные ошибки, асинхронные ошибки, необработанную глобальную синхронизацию и асинхронные ошибки.

Синхронная обработка ошибок

Синхронные ошибки возникают, когда операция выполняется в линейной последовательности, и ошибка возникает во время выполнения кода. Есть два основных способа обработки синхронных ошибок в JavaScript: использование оператора try...catch и оператора throw.

Утверждение try…catch

Оператор try...catch позволяет вам выполнить блок кода и отловить любые ошибки, которые могут возникнуть. Если возникает ошибка, код внутри блока catch будет выполнен. Вот пример:

try {
  // Code that may throw an error
  const result = someFunction();
  console.log(result);
} catch (error) {
  // Handle the error
  console.error("An error occurred:", error.message);
}

Утверждение о броске

Оператор throw позволяет создавать собственные ошибки и выдавать их вручную. Это полезно, когда вы хотите явно обработать определенные условия ошибки. Вот пример:

function divide(a, b) {
  if (b === 0) {
    throw new Error("Division by zero is not allowed.");
  }
  return a / b;
}

try {
  const result = divide(10, 0);
  console.log(result);
} catch (error) {
  console.error("An error occurred:", error.message);
}

Асинхронная обработка ошибок

Асинхронные ошибки возникают, когда операция выполняется асинхронно, например чтение файла, выполнение HTTP-запроса или использование таймера. Обработка асинхронных ошибок может быть более сложной, чем синхронных ошибок, из-за их характера. Существует несколько способов обработки асинхронных ошибок в JavaScript, включая обратные вызовы, промисы и синтаксис async/await.

Обратные вызовы

На заре JavaScript асинхронная обработка ошибок в основном выполнялась с помощью обратных вызовов. Функция обратного вызова передается в качестве аргумента асинхронной функции и вызывается после завершения операции. Первый параметр функции обратного вызова обычно зарезервирован для обработки ошибок. Вот пример использования функции fs.readFile в Node.js:

const fs = require('fs');

fs.readFile('example.txt', 'utf8', 'utf8', (error, data) => {
  if (error) {
    // Handle the error console.error("An error occurred:", error.message);
    return;
  } // Continue with the data
  console.log(data);
});

Обещания

Промисы — это более современный подход к обработке асинхронных ошибок в JavaScript. Они обеспечивают более элегантный и понятный способ управления асинхронными операциями и их ошибками.

Метод catch

Метод catch позволяет обрабатывать любые ошибки, которые могут возникнуть во время выполнения промиса. Вот пример:

fetch("https://api.example.com/data")
 .then(response => response.json())
 .then(data => console.log(data))
 .catch(error => console.error("An error occurred:", error.message));

Метод finally

Метод finally позволяет вам выполнить блок кода после того, как Promise либо разрешен, либо отклонен, независимо от того, произошла ли ошибка. Это полезно для операций очистки или освобождения ресурсов.

fetch("https://api.example.com/data")
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error("An error occurred:", error.message))
  .finally(() => console.log("Finished processing the request."));

Обработка ошибок обещаний с помощью async/await

Синтаксис async/await, представленный в ES2017, обеспечивает более читаемый способ работы с промисами и обработкой ошибок. С помощью async/await вы можете использовать оператор try...catch для обработки ошибок, возникающих в асинхронной функции. Вот пример:

async function fetchData() {
  try {
    const response = await fetch("https://api.example.com/data");
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error("An error occurred:", error.message);
  }
}

fetchData();

Обработка неперехваченных глобальных ошибок

Неперехваченные глобальные ошибки — это ошибки, которые не перехватываются каким-либо механизмом обработки ошибок в вашем коде. Чтобы справиться с этими ошибками, вы можете использовать следующие методы:

window.onerror

Обработчик событий window.onerror позволяет перехватывать необработанные ошибки, возникающие в глобальной области. Вот пример:

window.onerror = function (message, source, lineno, colno, error) {
  console.error("An unhandled error occurred:", error.message);
  // Prevent the default error handling
  return true;
};

window.addEventListener('ошибка', …)

Вы также можете использовать метод window.addEventListener для обработки неперехваченных глобальных ошибок. Этот подход позволяет при необходимости добавить несколько обработчиков ошибок.

window.addEventListener('error', (event) => {
  console.error("An unhandled error occurred:", event.error.message);
  // Prevent the default error handling
  event.preventDefault();
});

window.addEventListener(‘unhandledrejection’, …)

Событие unhandledrejection генерируется, когда обещание отклонено, и к нему не привязан обработчик ошибок. Это событие можно использовать для перехвата необработанных асинхронных ошибок.

window.addEventListener('unhandledrejection', (event) => {
  console.error("An unhandled Promise rejection occurred:", event.reason);
  // Prevent the default error handling
  event.preventDefault();
});

Лучшие практики обработки ошибок в JavaScript

  • Используйте соответствующие методы обработки ошибок в зависимости от того, является ли код синхронным или асинхронным.
  • Всегда обрабатывайте ошибки последовательно во всем приложении.
  • Используйте настраиваемые типы ошибок, чтобы предоставить более подробную информацию об ошибке и упростить отладку.
  • Рассмотрите возможность использования сторонних библиотек, таких как средства мониторинга и ведения журнала ошибок, чтобы улучшить обработку ошибок и наглядность.
  • Напишите модульные тесты для проверки как ожидаемых, так и непредвиденных ошибок.
  • Предоставляйте содержательные сообщения об ошибках, чтобы помочь разработчикам понять причину ошибки и способы ее исправления.
  • Регистрируйте ошибки в стандартном формате, включая соответствующую контекстную информацию, чтобы упростить анализ и отладку проблем.
  • Не подавляйте ошибки без уважительной причины. Если ошибка обнаружена и не обработана, это может привести к неожиданному поведению вашего приложения.

Заключение

Обработка ошибок является критическим аспектом разработки. Понимая различные методы обработки синхронных и асинхронных ошибок, а также необработанных глобальных ошибок, вы можете сделать свои приложения более надежными и удобными в сопровождении.

Спасибо за чтение, надеюсь поймать вас в следующей статье.

Не являетесь участником Medium? Поддержите меня здесь, став одним из них.

Дополнительные материалы на PlainEnglish.io.

Подпишитесь на нашу бесплатную еженедельную рассылку новостей. Подпишитесь на нас в Twitter, LinkedIn, YouTube и Discord .