Обработка ошибок в JavaScript

Эта статья объясняет обработку ошибок в JavaScript.

YouTube Video

Обработка ошибок в JavaScript

Обработка ошибок в JavaScript — это важная функция для перехвата и адекватной обработки ошибок, когда программа сталкивается с неожиданными проблемами. Прежде всего, обычно используется синтаксис try...catch для перехвата и обработки ошибок. Кроме того, при работе с Промисами или асинхронными операциями обработка ошибок также может выполняться с использованием async/await или Promise.prototype.catch.

Синтаксис try...catch

try...catch используется для перехвата и обработки ошибок, когда они возникают внутри блока кода.

 1try {
 2    // Code that may throw an error
 3    let result = riskyFunction();
 4    console.log(result);
 5} catch (error) {
 6    // Catch and handle the error
 7    console.error("An error occurred:", error.message);
 8} finally {
 9    // Code that will always execute
10    console.log("Error handling has completed.");
11}

• Если ошибка возникает внутри блока try, выполнение программы прерывается, и выполняется блок catch.
• Блок finally всегда выполняется, независимо от наличия ошибки. Это полезно для освобождения ресурсов, завершительной обработки и других вещей.

Генерация ошибок (throw)

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

 1function checkAge(age) {
 2    if (age < 18) {
 3        throw new Error("You are under 18 years old.");
 4    }
 5    return "Age verification completed.";
 6}
 7
 8try {
 9    let result = checkAge(15);
10    console.log(result);
11} catch (error) {
12    console.error(error.message);  // Displays "You are under 18 years old."
13}

Обработка ошибок в асинхронных операциях (Promise и async/await)

При выполнении асинхронных операций обработка ошибок немного отличается. При использовании Промисов ошибки перехватываются методом catch.

1let promise = new Promise((resolve, reject) => {
2    // Asynchronous operation
3    setTimeout(() => reject(new Error("An issue has occurred!")), 1000);
4});
5
6promise
7    .then(result => console.log(result))
8    .catch(error => console.error(error.message));  // Displays "An issue has occurred!"

При выполнении асинхронных операций с использованием async/await вы можете обрабатывать ошибки с помощью try...catch.

 1async function fetchData() {
 2    try {
 3        let response = await fetch('https://api.example.com/data');
 4        let data = await response.json();
 5        console.log(data);
 6    } catch (error) {
 7        console.error("An error occurred while fetching data:", error.message);
 8    }
 9}
10
11fetchData();

Резюме

• Вы можете перехватывать синхронные ошибки с помощью синтаксиса try...catch.
• Вы можете генерировать собственные ошибки с помощью throw.
• Ошибки в асинхронных операциях могут быть обработаны с помощью метода catch у Promise, либо с использованием async/await и try...catch.

Используя эти методы, вы можете гарантировать корректное функционирование вашей программы даже при возникновении ошибок.

Error

Класс Error используется для обработки ошибок. Он предоставляет возможность создавать ошибки, а также предоставлять сообщения об ошибках и трассировки стека.

1try {
2    throw new Error("Something went wrong");
3} catch (e) {
4    console.log(e.message); // Something went wrong
5}

Основное использование

Объект Error может быть явно создан, когда возникает ошибка. Вы создаёте экземпляр с помощью new Error() и передаете сообщение об ошибке.

1const error = new Error("Something went wrong");
2console.log(error.message);  // "Something went wrong"
3console.log(error.name);     // "Error"
4
5// Stack trace (information about where the error occurred)
6console.log(error.stack);

Свойства объекта Error

Объект Error имеет следующие свойства.

• message: Это сообщение об ошибке.
• name: Наименование ошибки, которое по умолчанию равно "Error".
• stack: Трассировка стека, содержащая место возникновения ошибки, полезно для отладки.

Генерация ошибок с помощью throw

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

1function doSomething() {
2    throw new Error("This function is not yet implemented");
3}
4
5try {
6    doSomething();
7} catch (e) {
8    console.error(e.message);  // "This function is not yet implemented"
9}

Ошибки, вызванные с помощью throw, могут быть обработаны с использованием синтаксиса try...catch.

Создание пользовательских ошибок

В JavaScript вы можете создавать свои собственные ошибки, расширяя класс Error. Это позволяет создавать ошибки, адаптированные к конкретным ситуациям.

 1class CustomError extends Error {
 2    constructor(message) {
 3        super(message);  // Call the parent class constructor
 4        this.name = "CustomError";  // Set the error name
 5    }
 6}
 7
 8try {
 9    throw new CustomError("A custom error has occurred");
10} catch (e) {
11    console.error(e.name);    // "CustomError"
12    console.error(e.message); // "A custom error has occurred"
13}

Встроенные классы ошибок

В JavaScript есть несколько встроенных классов ошибок, которые наследуют класс Error. Они используются для представления определённых ошибок.

• ReferenceError: Возникает, когда вы ссылаетесь на переменную, которая не существует.
• TypeError: Возникает, когда тип значения отличается от ожидаемого типа.
• RangeError: Возникает, когда число выходит за допустимые пределы.
• SyntaxError: Возникает, когда выполняется код, который синтаксически некорректен.
• EvalError: Ошибки, связанные с использованием функции eval(). В настоящее время используется редко.
• URIError: Возникает, когда используется недопустимый URI (ошибки кодирования или декодирования).

Пример: ReferenceError

Вот пример ReferenceError.

1try {
2    console.log(undefinedVariable);  // Undefined variable
3} catch (e) {
4    console.error(e.name);    // "ReferenceError"
5    console.error(e.message); // "undefinedVariable is not defined"
6}

Пример: TypeError

Вот пример TypeError.

1try {
2    null.f();  // Attempting to call a function on null
3} catch (e) {
4    console.error(e.name);    // "TypeError"
5    console.error(e.message); // "Cannot read properties of null (reading 'f')"
6}

Блок finally

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

1try {
2    throw new Error("An issue has occurred");
3} catch (e) {
4    console.error(e.message);  // "An issue has occurred"
5} finally {
6    console.log("Performing cleanup");
7}

В этом примере операции в блоке finally выполняются, даже если была вызвана ошибка.

Преимущества обработки исключений

Правильная реализация обработки ошибок позволяет предотвратить сбой приложения при возникновении непредвиденного поведения. Корректное использование синтаксиса try...catch и объектов ошибок позволяет писать более надежный код.

 1function divide(a, b) {
 2    if (b === 0) {
 3        throw new Error("Cannot divide by zero");
 4    }
 5    return a / b;
 6}
 7
 8try {
 9    console.log(divide(4, 0));  // An error will occur
10} catch (e) {
11    console.error(e.message);   // "Cannot divide by zero"
12}

Резюме

• Класс Error используется для представления причины ошибки и выполнения обработки ошибок.
• Используйте синтаксис try...catch...finally для обработки ошибок и предотвращения внезапного завершения работы приложения.
• Класс Error можно также расширить для создания пользовательских ошибок.
• Вы можете обрабатывать различные типы ошибок, используя встроенные классы ошибок, такие как TypeError и ReferenceError.

Вы можете следовать этой статье, используя Visual Studio Code на нашем YouTube-канале. Пожалуйста, также посмотрите наш YouTube-канал.

YouTube Video