Руководство для начинающих по обработке ошибок TypeScript

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

Понимание ошибок в TypeScript

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

Базовая обработка ошибок с помощью try и catch

В TypeScript вы обрабатываете ошибки времени выполнения с помощью блоков try и catch. Такой подход позволяет вам выполнять код, который может выдать ошибку, и обрабатывать эту ошибку, если она возникает.

Пример try и catch

function divide(a: number, b: number): number {
  try {
    if (b === 0) {
      throw new Error("Cannot divide by zero");
    }
    return a / b;
  } catch (error) {
    console.error(error.message);
    return NaN; // Return NaN to indicate an error
  }
}

console.log(divide(10, 2)); // Output: 5
console.log(divide(10, 0)); // Output: Cannot divide by zero

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

Пользовательские типы ошибок

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

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

class DivisionError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "DivisionError";
  }
}

function divide(a: number, b: number): number {
  try {
    if (b === 0) {
      throw new DivisionError("Cannot divide by zero");
    }
    return a / b;
  } catch (error) {
    if (error instanceof DivisionError) {
      console.error(`Custom Error: ${error.message}`);
    } else {
      console.error("An unexpected error occurred");
    }
    return NaN; // Return NaN to indicate an error
  }
}

console.log(divide(10, 2)); // Output: 5
console.log(divide(10, 0)); // Output: Custom Error: Cannot divide by zero

Здесь мы определяем пользовательский класс ошибок DivisionError, который расширяет встроенный класс Error. Мы используем эту пользовательскую ошибку в функции divide, чтобы обеспечить более конкретную обработку ошибок.

Защита типов с помощью instanceof

Защитники типа, такие как instanceof, помогают сузить тип объекта ошибки в блоке catch, позволяя по-разному обрабатывать различные типы ошибок.

Пример защиты типа

function processInput(input: string | number) {
  try {
    if (typeof input === "string") {
      console.log(input.toUpperCase());
    } else {
      throw new Error("Input must be a string");
    }
  } catch (error) {
    if (error instanceof Error) {
      console.error(`Error: ${error.message}`);
    } else {
      console.error("An unknown error occurred");
    }
  }
}

processInput("hello"); // Output: HELLO
processInput(42); // Output: Error: Input must be a string

В этом примере демонстрируется защита типов в блоке catch, гарантирующая, что объект ошибки является экземпляром Error, что позволяет выполнять точную обработку ошибок.

Использование finally для очистки

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

Пример с finally

function readFile(filePath: string): string {
  try {
    // Simulate reading a file
    if (filePath === "") {
      throw new Error("File path cannot be empty");
    }
    return "File content";
  } catch (error) {
    console.error(`Error: ${error.message}`);
    return "";
  } finally {
    console.log("Cleanup: Closing file");
  }
}

console.log(readFile("path/to/file")); // Output: File content
console.log(readFile("")); // Output: Error: File path cannot be empty
                            //         Cleanup: Closing file

В этом примере блок finally гарантирует, что сообщение об очистке будет зарегистрировано независимо от того, произошла ли ошибка.

Заключение

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

С помощью этих методов вы можете изящно обрабатывать ошибки и повышать надежность вашего кода TypeScript. Практикуйте эти концепции, чтобы стать экспертом в обработке ошибок TypeScript и писать более устойчивые приложения.