Obsługa wyjątków

10.1 Blok try...catch

Obsługa wyjątków to istotny aspekt programowania, który pomaga poprawić stabilność i niezawodność kodu. W JavaScript do obsługi wyjątków używa się słów kluczowych try, catch, finally i throw. Na wykładzie omówimy te słowa kluczowe, ich składnię i przykłady zastosowania.

1. Blok try...catch

Konstrukcja try...catch jest używana do obsługi błędów, które występują w bloku kodu try. Jeśli w bloku try wystąpi błąd, sterowanie jest przekazywane do bloku catch, gdzie błąd może być obsłużony.

Składnia:

    
      try {
        // Kod, który może wywołać wyjątek
      } catch (error) {
        // Kod do obsługi wyjątku
      }
    
  

W tym przykładzie, mimo że dzielenie przez zero nie powoduje błędu w JavaScript, gdyby był to inny błąd (na przykład dostęp do niezdefiniowanej zmiennej), blok catch by go obsłużył:

    
      try {
        let result = 10 / 0;

        console.log(result);

      } catch (error) {
        console.error('An error occurred:', error);
      }
    
  

10.2. Blok finally

Blok finally jest używany do wykonania kodu, który powinien być wykonany bez względu na to, czy wystąpił wyjątek w bloku try czy nie. Blok finally następuje po bloku catch.

Składnia:

    
      try {
        // Kod, który może wywołać wyjątek
      } catch (error) {
        // Kod do obsługi wyjątku
      } finally {
        // Kod, który wykonuje się zawsze
      }
    
  

W tym przykładzie komunikat This will always execute. zostanie wyświetlony niezależnie od tego, czy wystąpił błąd, czy nie:

    
      try {
        let result = 10 / 0;
        console.log(result);
      } catch (error) {
        console.error('An error occurred:', error);
      } finally {
        console.log('This will always execute.');
      }
    
  

10.3. Operator throw

Operator throw jest używany do ręcznego wyrzucania wyjątków. Dzięki niemu można wyrzucać własne błędy.

Składnia:

    
      throw expression;
    
  

Gdzie:

• expression: dowolne wyrażenie lub obiekt, który będzie wyrzucony jako wyjątek

Przykład zastosowania

W tym przykładzie jest wyrzucany błąd, jeśli próbujemy dzielić przez zero, a blok catch obsługuje ten błąd:

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

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

10.4 Rozszerzone przykłady i zastosowanie

Przykład 1: Wiele wyjątków

Czasami w bloku try mogą występować różne typy błędów. Możesz je obsługiwać na różne sposoby, używając właściwości obiektu błędu.

W tym przykładzie obsługujemy błąd składniowy JSON oddzielnie od innych możliwych błędów:

    
      try {
        JSON.parse('{ malformed JSON string }');
      } catch (error) {
        if (error instanceof SyntaxError) {
          console.error('JSON Syntax Error:', error.message);
        } else {
          console.error('Unexpected Error:', error);
        }
      } finally {
        console.log('Parsing attempt finished.');
      }
    
  

Przykład 2: Zagnieżdżone bloki try...catch

Można używać zagnieżdżonych bloków try...catch do bardziej szczegółowej obsługi błędów.

W tym przykładzie błąd występujący w pierwszym bloku try jest obsługiwany przez wewnętrzny blok catch, który należy następnie ponownie wyrzucić do obsługi przez zewnętrzny blok catch:

    
      try {
        try {
          let result = divide(10, 0);
          console.log(result);
        } catch (innerError) {
          console.error('Inner catch:', innerError.message);
          throw innerError;
        }
      } catch (outerError) {
        console.error('Outer catch:', outerError.message);
      } finally {
        console.log('Nested try...catch finished.');
      }

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

Przykład 3: Użycie finally do uwalniania zasobów

Blok finally przydaje się do uwolnienia zasobów, takich jak zamykanie plików czy kończenie połączeń sieciowych.

W tym przykładzie plik zawsze będzie zamknięty, niezależnie od tego, czy wystąpił błąd przy jego odczycie czy nie:

    
      function readFile(filePath) {
        let file;
        try {
          file = openFile(filePath); // Funkcja otwierająca plik
          // Praca z plikiem
        } catch (error) {
          console.error('Error reading file:', error.message);
        } finally {
          if (file) {
            closeFile(file); // Funkcja zamykająca plik
          }
          console.log('File processing finished.');
        }
      }

      function openFile(path) {
        // Logika otwierania pliku
      }

      function closeFile(file) {
        // Logika zamykania pliku
      }

      readFile('path/to/file.txt');
    
  

Obsługa wyjątków w JavaScript przy użyciu try, catch, finally i throw pozwala na tworzenie bardziej niezawodnych i stabilnych aplikacji. Zrozumienie i poprawne użycie tych konstrukcji pomaga efektywnie zarządzać błędami, uwalniać zasoby i poprawiać doświadczenie użytkownika.

1

Опрос

Obiekty,  36 уровень,  4 лекция

недоступен

Obiekty

Obiekty

Открыть