Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne

Obsługa błędów (try...catch)

17 min czytania ·
W tej lekcji9

W zarządzaniu Parkiem Jurajskim, gdzie dinozaury mogą uciec z wybiegów, systemy bezpieczeństwa mogą zawieść, a odwiedzający mogą znaleźć się w niebezpieczeństwie, właściwa obsługa błędów jest krytycznie ważna. W JavaScripcie, podobnie jak w procedurach bezpieczeństwa parku, musimy być przygotowani na nieoczekiwane sytuacje i wiedzieć, jak na nie reagować.

W tym ćwiczeniu skupimy się na strategiach obsługi błędów w kodzie asynchronicznym, co jest kluczowe dla tworzenia odpornych i niezawodnych aplikacji.

Dlaczego obsługa błędów jest ważna?

Wyobraź sobie, że tworzysz system monitorowania wybiegów dinozaurów. Co się stanie, jeśli czujnik temperatury przestanie działać? Albo jeśli połączenie z systemem zabezpieczeń zostanie przerwane? Bez odpowiedniej obsługi błędów, twoja aplikacja może "zawiesić się" lub, co gorsza, działać dalej na podstawie nieprawidłowych danych.

Dobra obsługa błędów:

  • Zapobiega "awariom kaskadowym" - jeden błąd nie powinien powodować awarii całego systemu
  • Dostarcza użytecznych informacji diagnostycznych - pomaga szybko zidentyfikować i naprawić problem
  • Umożliwia działania naprawcze - automatyczne próby ponowienia, przełączanie na systemy zapasowe
  • Zapewnia "graceful degradation" - nawet gdy część funkcji jest niedostępna, kluczowe systemy nadal działają

Typy błędów w JavaScript

Zanim zagłębimy się w strategie obsługi błędów, omówmy różne typy błędów, które możemy napotkać w JavaScripcie:

1. Błędy składniowe (SyntaxError)

Występują, gdy kod zawiera nieprawidłową składnię. Są wykrywane podczas kompilacji i uniemożliwiają uruchomienie kodu.

// Przykład błędu składniowego
function pobierzDaneDinozaura( {  // Brakuje zamykającego nawiasu
  // kod funkcji
}

2. Błędy referencyjne (ReferenceError)

Występują, gdy próbujemy uzyskać dostęp do zmiennej lub funkcji, która nie istnieje.

// Przykład błędu referencyjnego
function aktualizujStatusDinozaura(id) {
  // Zmienna 'statusy' nie została zdefiniowana
  statusy[id] = "Aktywny";
}

3. Błędy typu (TypeError)

Występują, gdy operacja jest wykonywana na wartości niewłaściwego typu.

// Przykład błędu typu
function zliczDinozaury(listaDinozaurów) {
  // Jeśli listaDinozaurów nie jest tablicą, wystąpi TypeError
  return listaDinozaurów.length;
}

4. Błędy zakresu (RangeError)

Występują, gdy wartość numeryczna lub parametr jest poza dopuszczalnym zakresem.

// Przykład błędu zakresu
function ustawTemperaturęWybiegu(temperatura) {
  // Jeśli temperatura jest zbyt wysoka, wystąpi RangeError
  if (temperatura > 50) {
    throw new RangeError("Temperatura wybiegu nie może przekraczać 50°C");
  }
  // reszta kodu
}

5. Błędy URI (URIError)

Występują w przypadku nieprawidłowego użycia funkcji kodowania/dekodowania URI.

// Przykład błędu URI
try {
  // Próba dekodowania nieprawidłowego URI
  decodeURIComponent('%');
} catch (error) {
  console.error("Nieprawidłowy URI:", error.message);
}

6. Błędy EvalError

Występowały historycznie w przypadku błędów związanych z funkcją eval(), choć we współczesnym JavaScripcie rzadko się pojawiają.

7. Błędy własne (niestandardowe)

Możemy tworzyć i wyrzucać własne błędy, aby obsługiwać specyficzne dla naszej aplikacji przypadki.

// Przykład własnego błędu
class DinosaurEscapeError extends Error {
  constructor(dinoId, paddockId, message) {
    super(message || `Dinozaur #${dinoId} uciekł z wybiegu #${paddockId}!`);
    this.name = "DinosaurEscapeError";
    this.dinoId = dinoId;
    this.paddockId = paddockId;
    this.timestamp = new Date();
  }
}

// Użycie
function sprawdźStatusWybiegu(wybiegId) {
  const status = pobierzStatusWybiegu(wybiegId);

  if (status.dinozaur && !status.bramyZamknięte) {
    throw new DinosaurEscapeError(
      status.dinozaur.id,
      wybiegId,
      `ALERT! Dinozaur ${status.dinozaur.name} uciekł z wybiegu #${wybiegId}!`
    );
  }

  return status;
}

Podstawowa obsługa błędów z try...catch

Podstawowy mechanizm obsługi błędów w JavaScripcie to blok try...catch:

try {
  // Kod, który może spowodować błąd
  const statusWybiegu = sprawdźStatusWybiegu(12);
  aktualizujPanelMonitoringu(statusWybiegu);
} catch (error) {
  // Kod obsługi błędu
  console.error("Błąd sprawdzania wybiegu:", error.message);
  aktywujAlarm("Błąd monitoringu wybiegu", error);
} finally {
  // Ten kod jest wykonywany zawsze, niezależnie od tego, czy wystąpił błąd
  zapiszLogSystemowy("Zakończono sprawdzanie wybiegu 12");
}

W powyższym przykładzie:

  • Blok try zawiera kod, który może spowodować błąd
  • Blok catch jest wykonywany, gdy wystąpi błąd w bloku try
  • Blok finally jest wykonywany zawsze, niezależnie od tego, czy wystąpił błąd czy nie

Właściwości obiektu Error

Obiekt błędu, który jest przekazywany do bloku catch, zawiera wiele przydatnych właściwości:

try {
  throw new Error("Coś poszło nie tak");
} catch (error) {
  console.error("Nazwa błędu:", error.name);        // "Error"
  console.error("Wiadomość:", error.message);       // "Coś poszło nie tak"
  console.error("Stos wywołań:", error.stack);      // Stos wywołań pokazujący, gdzie błąd wystąpił
}

Sprawdzanie typu błędu

Często chcemy różnie reagować na różne typy błędów:

try {
  const wynikOperacji = przeprowadźRyzykownąOperację();
  wyświetlWynik(wynikOperacji);
} catch (error) {
  if (error instanceof SyntaxError) {
    console.error("Błąd składni:", error.message);
  } else if (error instanceof ReferenceError) {
    console.error("Błąd referencji:", error.message);
  } else if (error instanceof DinosaurEscapeError) {
    // Uruchomienie procedury awaryjnej!
    aktywujProtokółBezpieczeństwa(error.dinoId, error.paddockId);
    ewakuujOdwiedzających();
    powiadomZespółBezpieczeństwa(error);
  } else {
    console.error("Wystąpił nieznany błąd:", error);
  }
}

Wyrzucanie błędów (throw)

Możemy sami wyrzucać błędy za pomocą słowa kluczowego throw:

function ustawTemperaturęWybiegu(wybiegId, temperatura) {
  // Sprawdzanie argumentów
  if (typeof wybiegId !== 'number' || wybiegId <= 0) {
    throw new TypeError("ID wybiegu musi być liczbą dodatnią");
  }

  if (temperatura < 10 || temperatura > 40) {
    throw new RangeError("Temperatura musi być między 10°C a 40°C");
  }

  // Reszta kodu, który ustawi temperaturę
  return aktualizujTemperaturęWybiegu(wybiegId, temperatura);
}

// Użycie
try {
  ustawTemperaturęWybiegu("nieprawidłowe-id", 25);
} catch (error) {
  if (error instanceof TypeError) {
    console.error("Nieprawidłowy typ argumentu:", error.message);
    // Logika obsługi błędu typu
  } else if (error instanceof RangeError) {
    console.error("Wartość poza zakresem:", error.message);
    // Logika obsługi błędu zakresu
  } else {
    console.error("Nieoczekiwany błąd:", error.message);
    // Ogólna obsługa błędu
  }
}

Tworzenie własnych klas błędów

Dla bardziej zaawansowanej obsługi błędów, możemy tworzyć własne klasy błędów dziedziczące po Error:

// Hierarchia błędów dla systemów parku
class ParkError extends Error {
  constructor(message) {
    super(message);
    this.name = this.constructor.name;
    // Zachowanie stack trace
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, this.constructor);
    }
  }
}

class SecuritySystemError extends ParkError {
  constructor(message, systemId) {
    super(message || `Błąd systemu bezpieczeństwa #${systemId}`);
    this.systemId = systemId;
  }
}

class FeedingSystemError extends ParkError {
  constructor(message, paddockId, foodType) {
    super(message || `Błąd systemu karmienia w wybiegu #${paddockId}`);
    this.paddockId = paddockId;
    this.foodType = foodType;
  }
}

class VisitorSystemError extends ParkError {
  constructor(message, areaId, visitorCount) {
    super(message || `Błąd systemu obsługi odwiedzających w strefie #${areaId}`);
    this.areaId = areaId;
    this.visitorCount = visitorCount;
  }
}

// Użycie
function uruchomSystemKarmienia(wybiegId, typPokarmu) {
  try {
    // Próba uruchomienia systemu karmienia
    if (!czyWybiegIstnieje(wybiegId)) {
      throw new FeedingSystemError(
        `Nie można uruchomić systemu karmienia: Wybieg #${wybiegId} nie istnieje`,
        wybiegId,
        typPokarmu
      );
    }

    // Więcej kodu...

  } catch (error) {
    if (error instanceof FeedingSystemError) {
      // Specyficzna obsługa błędu systemu karmienia
      powiadomPersonelKarmienia(error);
      return { success: false, error: error.message, systemType: "feeding" };
    } else {
      // Ogólna obsługa błędu
      console.error("Nieoczekiwany błąd:", error);
      return { success: false, error: "Nieznany błąd systemu", systemType: "unknown" };
    }
  }
}

Obsługa błędów w kodzie asynchronicznym

Obsługa błędów w kodzie asynchronicznym może być bardziej skomplikowana, szczególnie gdy mamy do czynienia z callbackami, Promise'ami i funkcjami async/await.

Obsługa błędów w callbackach

W starszych stylach programowania asynchronicznego, z callbackami, często stosowano wzorzec "error-first":

// Styl error-first
function pobierzDaneDinozaura(id, callback) {
  // Wykonanie asynchronicznej operacji
  setTimeout(() => {
    if (id <= 0) {
      // Pierwszy argument to błąd (jeśli wystąpił)
      callback(new Error(`Nieprawidłowe ID dinozaura: ${id}`), null);
    } else {
      // Pierwszy argument to null (brak błędu), drugi to wynik
      callback(null, { id, name: `Dino-${id}`, species: "Tyrannosaurus" });
    }
  }, 1000);
}

// Użycie
pobierzDaneDinozaura(0, (error, dino) => {
  if (error) {
    console.error("Nie udało się pobrać danych dinozaura:", error.message);
    return;
  }

  console.log("Pobrano dane dinozaura:", dino);
});

Obsługa błędów w Promise

W Promise'ach używamy metody .catch() do obsługi błędów:

function pobierzDaneDinozaura(id) {
  return new Promise((resolve, reject) => {
    // Wykonanie asynchronicznej operacji
    setTimeout(() => {
      if (id <= 0) {
        reject(new Error(`Nieprawidłowe ID dinozaura: ${id}`));
      } else {
        resolve({ id, name: `Dino-${id}`, species: "Tyrannosaurus" });
      }
    }, 1000);
  });
}

// Użycie
pobierzDaneDinozaura(0)
  .then(dino => {
    console.log("Pobrano dane dinozaura:", dino);
  })
  .catch(error => {
    console.error("Nie udało się pobrać danych dinozaura:", error.message);
  });

Promise'y pozwalają na łańcuchową obsługę błędów:

pobierzDaneDinozaura(42)
  .then(dino => {
    return aktualizujStatusDinozaura(dino.id, "active");
  })
  .then(status => {
    console.log("Status zaktualizowany:", status);
    return wyslijPowiadomienie("Dinozaur aktywowany");
  })
  .catch(error => {
    // Ten catch obsłuży błędy z wszystkich poprzednich operacji
    console.error("Wystąpił błąd w łańcuchu operacji:", error.message);
  });

Obsługa błędów z async/await

Funkcje async/await pozwalają na używanie tradycyjnej składni try...catch nawet dla kodu asynchronicznego:

async function aktywujDinozaura(id) {
  try {
    // Próba aktywacji dinozaura
    console.log(`Rozpoczynam procedurę aktywacji dinozaura #${id}...`);

    const dino = await pobierzDaneDinozaura(id);
    console.log(`Pobrano dane dinozaura: ${dino.name}`);

    const statusWybiegu = await sprawdźStatusWybiegu(dino.paddockId);
    console.log(`Status wybiegu #${dino.paddockId}: ${statusWybiegu.status}`);

    if (!statusWybiegu.isSecure) {
      throw new SecuritySystemError(
        `Nie można aktywować dinozaura: Wybieg #${dino.paddockId} nie jest bezpieczny`,
        "paddock-security"
      );
    }

    const wynik = await aktualizujStatusDinozaura(id, "active");
    console.log(`Status dinozaura zaktualizowany: ${wynik.status}`);

    return {
      success: true,
      message: `Dinozaur #${id} został pomyślnie aktywowany`,
      dino
    };
  } catch (error) {
    console.error(`Błąd podczas aktywacji dinozaura #${id}:`, error.message);

    // Możemy reagować różnie w zależności od typu błędu
    if (error instanceof SecuritySystemError) {
      await aktywujAlarmBezpieczeństwa(error.systemId, error.message);
    }

    return {
      success: false,
      message: `Nie udało się aktywować dinozaura #${id}`,
      error: error.message
    };
  }
}

Ta składnia jest znacznie czytelniejsza niż łańcuchy .then().catch() i pozwala na bardziej naturalne podejście do obsługi błędów.

Łączenie obsługi błędów w async/await z Promise.all()

Gdy używamy Promise.all() z async/await, możemy łatwo obsługiwać błędy dla wielu równoległych operacji:

async function aktywujWszystkieDinozauryWSektorze(sektorId) {
  try {
    // Pobierz listę dinozaurów w sektorze
    const dinozaury = await pobierzDinozauryWSektorze(sektorId);
    console.log(`Znaleziono ${dinozaury.length} dinozaurów w sektorze #${sektorId}`);

    // Uruchom procedurę aktywacji dla wszystkich dinozaurów równolegle
    const wyniki = await Promise.all(
      dinozaury.map(dino => aktywujDinozaura(dino.id))
    );

    // Sprawdź wyniki
    const udane = wyniki.filter(w => w.success);
    const nieudane = wyniki.filter(w => !w.success);

    console.log(`Aktywowano ${udane.length} z ${dinozaury.length} dinozaurów`);

    return {
      success: nieudane.length === 0,
      activated: udane.length,
      failed: nieudane.length,
      results: wyniki
    };
  } catch (error) {
    console.error(`Błąd krytyczny podczas aktywacji dinozaurów w sektorze #${sektorId}:`, error);
    return {
      success: false,
      message: "Nie udało się przetworzyć aktywacji dinozaurów",
      error: error.message
    };
  }
}

Zaawansowane strategie obsługi błędów

1. Retry Pattern (Wzorzec ponawiania prób)

Często w operacjach sieciowych lub komunikacji z zewnętrznymi systemami warto ponowić próbę, gdy wystąpi tymczasowy błąd:

async function zRetryPattern(operacja, options = {}) {
  const {
    maxPrób = 3,
    opóźnienie = 1000,
    mnożnikOpóźnienia = 2,
    logowanie = true
  } = options;

  let ostatniError;

  for (let próba = 1; próba <= maxPrób; próba++) {
    try {
      if (logowanie && próba > 1) {
        console.log(`Próba ${próba}/${maxPrób}...`);
      }

      return await operacja(próba);
    } catch (error) {
      ostatniError = error;

      if (logowanie) {
        console.warn(`Próba ${próba}/${maxPrób} nie powiodła się:`, error.message);
      }

      if (próba < maxPrób) {
        const czasOczekiwania = opóźnienie * Math.pow(mnożnikOpóźnienia, próba - 1);

        if (logowanie) {
          console.log(`Czekam ${czasOczekiwania}ms przed kolejną próbą...`);
        }

        await new Promise(resolve => setTimeout(resolve, czasOczekiwania));
      }
    }
  }

  throw ostatniError;
}

// Przykład użycia
async function pobierzDaneZWęzłaCzujnikowego(nodeId) {
  return zRetryPattern(
    async (próba) => {
      console.log(`Próba ${próba}: Pobieranie danych z węzła #${nodeId}...`);
      const response = await fetch(`https://sensor-api.jurassic-park.com/node/${nodeId}`);

      if (!response.ok) {
        throw new Error(`Odpowiedź HTTP: ${response.status}`);
      }

      return await response.json();
    },
    {
      maxPrób: 5,
      opóźnienie: 2000,
      mnożnikOpóźnienia: 1.5
    }
  );
}

2. Circuit Breaker Pattern (Wzorzec wyłącznika)

Ten wzorzec zapobiega powtarzającym się próbom operacji, które stale kończą się niepowodzeniem:

class CircuitBreaker {
  constructor(options = {}) {
    this.failureThreshold = options.failureThreshold || 3;
    this.resetTimeout = options.resetTimeout || 30000;
    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
    this.failureCount = 0;
    this.nextAttempt = Date.now();
    this.onStateChange = options.onStateChange || (() => {});
  }

  async wykonajFunkcję(fn) {
    if (this.state === 'OPEN') {
      if (Date.now() > this.nextAttempt) {
        this.zmieńStan('HALF_OPEN');
      } else {
        throw new Error('Circuit breaker is OPEN');
      }
    }

    try {
      const result = await fn();
      this.sukces();
      return result;
    } catch (error) {
      this.błąd(error);
      throw error;
    }
  }

  sukces() {
    this.failureCount = 0;
    if (this.state === 'HALF_OPEN') {
      this.zmieńStan('CLOSED');
    }
  }

  błąd(error) {
    this.failureCount += 1;
    if (this.state === 'HALF_OPEN' || this.failureCount >= this.failureThreshold) {
      this.zmieńStan('OPEN');
    }
  }

  zmieńStan(stan) {
    this.state = stan;
    this.onStateChange(stan);
    if (stan === 'OPEN') {
      this.nextAttempt = Date.now() + this.resetTimeout;
    }
  }
}

// Przykład użycia
const breaker = new CircuitBreaker({
  failureThreshold: 3,
  resetTimeout: 10000,
  onStateChange: (newState) => {
    console.log(`Circuit breaker zmienił stan na: ${newState}`);
    if (newState === 'OPEN') {
      // Powiadom zespół o problemie z systemem
      wyslijAlertSystemowy("System czujników jest niedostępny");
    }
  }
});

async function pobierzDaneZCzujnika(czujnikId) {
  try {
    return await breaker.wykonajFunkcję(async () => {
      const response = await fetch(`https://sensor-api.jurassic-park.com/sensor/${czujnikId}`);
      if (!response.ok) {
        throw new Error(`HTTP Error: ${response.status}`);
      }
      return response.json();
    });
  } catch (error) {
    if (error.message === 'Circuit breaker is OPEN') {
      console.log(`Czujnik #${czujnikId} jest niedostępny. Używam danych z cache.`);
      return pobierzDaneZCache(czujnikId);
    }
    throw error;
  }
}

3. Fallback Pattern (Wzorzec alternatywny)

Ten wzorzec zapewnia alternatywne źródło danych lub funkcjonalność, gdy główne źródło zawiedzie:

async function pobierzDaneDinozauraZFallbackiem(dinoId) {
  try {
    // Próba pobrania danych z głównej bazy danych
    return await pobierzDaneDinozauraZGłównejBazy(dinoId);
  } catch (error) {
    console.warn(`Nie udało się pobrać danych z głównej bazy: ${error.message}`);

    try {
      // Próba pobrania danych z bazy zapasowej
      console.log(`Próbuję pobrać dane z bazy zapasowej...`);
      return await pobierzDaneDinozauraZBazyZapasowej(dinoId);
    } catch (fallbackError) {
      console.warn(`Nie udało się pobrać danych z bazy zapasowej: ${fallbackError.message}`);

      try {
        // Próba pobrania danych z lokalnego cache
        console.log(`Próbuję pobrać dane z cache...`);
        return await pobierzDaneDinozauraZCache(dinoId);
      } catch (cacheError) {
        console.error(`Wszystkie źródła danych zawiodły!`);

        // Zwrócenie podstawowych danych, aby aplikacja mogła działać
        return {
          id: dinoId,
          name: `Unknown Dinosaur #${dinoId}`,
          species: "Unknown",
          warning: "Dane niepełne - wszystkie źródła danych zawiodły"
        };
      }
    }
  }
}

4. Bulkhead Pattern (Wzorzec grodzi)

Ten wzorzec izoluje zasoby do dedykowanych pul, aby awaria jednej części systemu nie wpływała na inne części:

class Bulkhead {
  constructor(options = {}) {
    this.maxConcurrent = options.maxConcurrent || 10;
    this.maxQueued = options.maxQueued || 20;
    this.active = 0;
    this.queue = [];
  }

  async wykonaj(fn) {
    if (this.active >= this.maxConcurrent) {
      if (this.queue.length >= this.maxQueued) {
        throw new Error('Bulkhead overflow: Too many requests queued');
      }

      // Dodaj do kolejki
      return new Promise((resolve, reject) => {
        this.queue.push({
          fn,
          resolve,
          reject
        });
      });
    }

    this.active += 1;

    try {
      const result = await fn();
      return result;
    } catch (error) {
      throw error;
    } finally {
      this.active -= 1;

      // Obsługuj zadania z kolejki, jeśli są dostępne
      if (this.queue.length > 0) {
        const request = this.queue.shift();
        this.wykonaj(request.fn).then(request.resolve).catch(request.reject);
      }
    }
  }
}

// Tworzenie oddzielnych bulkheadów dla różnych podsystemów
const securityBulkhead = new Bulkhead({ maxConcurrent: 5, maxQueued: 10 });
const feedingBulkhead = new Bulkhead({ maxConcurrent: 3, maxQueued: 5 });
const monitoringBulkhead = new Bulkhead({ maxConcurrent: 10, maxQueued: 30 });

// Użycie
async function monitorujWybieg(paddockId) {
  return monitoringBulkhead.wykonaj(async () => {
    // Operacje monitoringu
    return await pobierzDaneMonitoringu(paddockId);
  });
}

async function aktualizujZabezpieczenia(paddockId, settings) {
  return securityBulkhead.wykonaj(async () => {
    // Operacje związane z bezpieczeństwem
    return await aktualizujUstawieniaBezpieczeństwa(paddockId, settings);
  });
}

5. Error Middleware (Middleware do obsługi błędów)

W przypadku aplikacji Express/Node.js, możesz zaimplementować middleware do centralnego zarządzania błędami:

// Centralne middleware do obsługi błędów
function errorHandler(err, req, res, next) {
  // Logowanie błędu
  console.error("Wystąpił błąd:", err);

  // Sprawdzanie typu błędu
  if (err instanceof SecuritySystemError) {
    // Specjalne traktowanie błędów bezpieczeństwa
    aktywujProtokółBezpieczeństwa(err);
    return res.status(500).json({
      error: "Błąd systemu bezpieczeństwa",
      code: "SECURITY_FAILURE",
      message: err.message
    });
  } else if (err.name === "ValidationError") {
    // Błędy walidacji
    return res.status(400).json({
      error: "Błąd walidacji danych",
      details: err.details,
      message: err.message
    });
  } else if (err.name === "UnauthorizedError") {
    // Błędy autoryzacji
    return res.status(401).json({
      error: "Brak autoryzacji",
      message: "Nie masz uprawnień do wykonania tej operacji"
    });
  }

  // Domyślna obsługa błędu
  res.status(500).json({
    error: "Wystąpił błąd wewnętrzny serwera",
    message: process.env.NODE_ENV === "production" ?
      "Przepraszamy, coś poszło nie tak" : err.message
  });
}

// Użycie w Express
app.use(errorHandler);

Obsługa błędów w praktyce - przypadki użycia

1. Obsługa błędów sieci

Podczas komunikacji z zewnętrznymi API, mogą wystąpić różne błędy sieciowe:

async function pobierzDanePogodowe() {
  try {
    const response = await fetch('https://api.weather.jurassic-park.com/forecast');

    if (!response.ok) {
      // Obsługa błędów HTTP
      if (response.status === 404) {
        throw new Error('Endpoint API nie istnieje');
      } else if (response.status === 401 || response.status === 403) {
        throw new Error('Brak autoryzacji do API pogodowego');
      } else if (response.status >= 500) {
        throw new Error(`Błąd serwera API: ${response.status}`);
      } else {
        throw new Error(`Nieoczekiwany błąd HTTP: ${response.status}`);
      }
    }

    return await response.json();
  } catch (error) {
    // Obsługa błędów sieciowych (np. offline, timeout)
    if (error.name === 'TypeError' && error.message.includes('fetch')) {
      console.error('Błąd sieci:', error);

      // Spróbuj użyć danych z cache
      const cachedData = await pobierzDaneZCache('weather-forecast');
      if (cachedData) {
        console.log('Używam danych pogodowych z cache');
        return {
          ...cachedData,
          fromCache: true,
          cachedAt: cachedData.timestamp
        };
      }

      // Jeśli nie ma cache, zwróć podstawowe dane
      return {
        temperature: 25,
        conditions: "Unknown",
        warning: "Dane awaryjne - brak połączenia z API",
        fromFallback: true
      };
    }

    // Przekazanie innych błędów
    throw error;
  }
}

2. Obsługa błędów operacji na plikach

async function zapiszRaportDzienny(dane) {
  const nazwaPliku = `raport-${new Date().toISOString().split('T')[0]}.json`;
  const ścieżka = `/var/logs/jurassic-park/${nazwaPliku}`;

  try {
    // Sprawdź, czy katalog istnieje
    try {
      await fs.access('/var/logs/jurassic-park');
    } catch (dirError) {
      console.log('Katalog nie istnieje, tworzę...');
      await fs.mkdir('/var/logs/jurassic-park', { recursive: true });
    }

    // Zapisz plik
    await fs.writeFile(ścieżka, JSON.stringify(dane, null, 2));
    console.log(`Raport zapisany: ${ścieżka}`);

    return { success: true, path: ścieżka };
  } catch (error) {
    console.error(`Błąd zapisywania raportu:`, error);

    // Próba zapisu w lokalizacji alternatywnej
    try {
      const alternatywnŚcieżka = `./backup-logs/${nazwaPliku}`;
      await fs.writeFile(alternatywnŚcieżka, JSON.stringify(dane, null, 2));
      console.log(`Raport zapisany w lokalizacji alternatywnej: ${alternatywnŚcieżka}`);

      return {
        success: true,
        path: alternatywnŚcieżka,
        warning: "Użyto lokalizacji alternatywnej"
      };
    } catch (backupError) {
      console.error(`Nie udało się zapisać raportu nawet w lokalizacji alternatywnej:`, backupError);

      // Zapisz dane w pamięci aplikacji do późniejszego odzyskania
      globalThis.pendingReports = globalThis.pendingReports || [];
      globalThis.pendingReports.push({
        data: dane,
        timestamp: new Date(),
        filename: nazwaPliku
      });

      return {
        success: false,
        error: error.message,
        recoveryPlan: "Dane zostały zapisane w pamięci aplikacji do późniejszego odzyskania"
      };
    }
  }
}

3. Obsługa błędów w operacjach bazodanowych

async function aktualizujStatusDinozaura(dinoId, nowyStatus) {
  // Otwórz transakcję bazodanową
  const transakcja = await db.beginTransaction();

  try {
    // Pobierz aktualny status
    const dinozaur = await db.query(
      'SELECT * FROM dinozaury WHERE id = ? FOR UPDATE',
      [dinoId],
      { transaction: transakcja }
    );

    if (!dinozaur || dinozaur.length === 0) {
      throw new Error(`Dinozaur o ID ${dinoId} nie istnieje`);
    }

    // Zapisz historię zmian statusu
    await db.query(
      'INSERT INTO historia_statusów (dinozaur_id, stary_status, nowy_status, czas) VALUES (?, ?, ?, NOW())',
      [dinoId, dinozaur[0].status, nowyStatus],
      { transaction: transakcja }
    );

    // Aktualizuj status
    await db.query(
      'UPDATE dinozaury SET status = ?, aktualizacja = NOW() WHERE id = ?',
      [nowyStatus, dinoId],
      { transaction: transakcja }
    );

    // Zatwierdź transakcję
    await transakcja.commit();

    console.log(`Status dinozaura #${dinoId} zaktualizowany: ${dinozaur[0].status} -> ${nowyStatus}`);
    return { success: true, id: dinoId, previousStatus: dinozaur[0].status, newStatus: nowyStatus };
  } catch (error) {
    // Coś poszło nie tak, wycofaj transakcję
    console.error(`Błąd aktualizacji statusu dinozaura #${dinoId}:`, error);
    await transakcja.rollback();

    // Obsłuż różne typy błędów bazodanowych
    if (error.code === 'ER_DUP_ENTRY') {
      throw new Error('Próba zduplikowanego wpisu w historii statusów');
    } else if (error.code === 'ER_NO_REFERENCED_ROW') {
      throw new Error(`Referencja do nieistniejącego rekordu. Dinozaur #${dinoId} mógł zostać usunięty`);
    } else {
      throw new Error(`Błąd bazodanowy: ${error.message}`);
    }
  }
}

Dobre praktyki obsługi błędów

  1. Zawsze obsługuj błędy: Każda funkcja asynchroniczna powinna mieć jakąś formę obsługi błędów.

  2. Używaj specyficznych typów błędów: Twórz dedykowane klasy błędów dla różnych typów problemów.

  3. Dostarczaj użyteczne komunikaty: Błąd powinien zawierać informacje przydatne do diagnozy problemu.

  4. Loguj błędy centralnie: Użyj systemów logowania, które pozwalają na centralne zbieranie i analizowanie błędów.

  5. Nigdy nie ignoruj błędów: Jeśli łapiesz błąd i nie potrzebujesz go dalej obsługiwać, przynajmniej go zaloguj.

  6. Zachowaj stos wywołań: Przy rzucaniu nowych błędów, zachowuj oryginalne stosy wywołań.

try {
  await ryzykownaOperacja();
} catch (error) {
  // Zachowanie oryginalnego stosu wywołań
  throw new Error(`Nie udało się wykonać operacji: ${error.message}`, { cause: error });
}
  1. Obsługuj błędy na odpowiednim poziomie: Nie wszystkie błędy powinny być obsługiwane w tym samym miejscu.

  2. Korzystaj z try...finally: Używaj bloku finally do czyszczenia zasobów niezależnie od tego, czy wystąpił błąd.

  3. Nie przeciążaj informacjami: Nie pokazuj użytkownikom szczegółowych informacji o błędach, które ich nie dotyczą.

  4. Przygotuj się na nieoczekiwane: Zawsze miej plan awaryjny na wypadek nieoczekiwanych błędów.

Podsumowanie

Odpowiednia obsługa błędów jest kluczowym elementem tworzenia niezawodnych aplikacji. W kontekście Parku Jurajskiego, gdzie stawką może być bezpieczeństwo odwiedzających i cennych okazów, jest to jeszcze ważniejsze.

Dobra obsługa błędów:

  • Zapewnia, że system będzie działał nawet w przypadku problemów
  • Ułatwia diagnozowanie i naprawianie problemów
  • Poprawia doświadczenie użytkownika
  • Zapobiega kaskadowym awariom

Pamiętaj, że w świecie oprogramowania, podobnie jak w Parku Jurajskim, zawsze lepiej jest "spodziewać się niespodziewanego" i być na to przygotowanym.

Kod do tej lekcji: index.js
// Module Pattern - Wzorzec modułowy
console.log("MODULE PATTERN - SYSTEM ZARZĄDZANIA PARKIEM\n");

// Module Pattern - enkapsulacja danych i metod
const DinosaurPark = (function() {
  // Prywatne zmienne i funkcje
  let dinosaurs = [];
  let capacity = 20;
  let isOpen = false;

  function validateCapacity() {
    return dinosaurs.length < capacity;
  }

  function generateId() {
    return 'DINO-' + Date.now() + '-' + Math.floor(Math.random() * 1000);
  }

  // Publiczny interfejs (API)
  return {
    addDinosaur: function(species, name) {
      if (!validateCapacity()) {
        console.log(`Nie można dodać ${species}. Park pełny! (${dinosaurs.length}/${capacity})`);
        return false;
      }

      const dinosaur = {
        id: generateId(),
        species: species,
        name: name,
        addedAt: new Date().toLocaleTimeString()
      };

      dinosaurs.push(dinosaur);
      console.log(`Dodano: ${species} "${name}" (ID: ${dinosaur.id})`);
      return true;
    },

    removeDinosaur: function(id) {
      const index = dinosaurs.findIndex(d => d.id === id);

      if (index !== -1) {
        const removed = dinosaurs.splice(index, 1)[0];
        console.log(`Usunięto: ${removed.species} "${removed.name}"`);
        return true;
      }

      console.log(`Nie znaleziono dinozaura o ID: ${id}`);
      return false;
    },

    listDinosaurs: function() {
      console.log(`\n=== LISTA DINOZAURÓW (${dinosaurs.length}/${capacity}) ===`);

      if (dinosaurs.length === 0) {
        console.log("Park jest pusty");
        return;
      }

      dinosaurs.forEach((dino, index) => {
        console.log(`${index + 1}. ${dino.species} "${dino.name}" - ID: ${dino.id}`);
      });
    },

    openPark: function() {
      if (dinosaurs.length === 0) {
        console.log("Nie można otworzyć pustego parku!");
        return false;
      }

      isOpen = true;
      console.log(`Park otwarty! Witamy gości!`);
      return true;
    },

    closePark: function() {
      isOpen = false;
      console.log(`Park zamknięty.`);
    },

    getStatus: function() {
      return {
        isOpen: isOpen,
        dinosaurCount: dinosaurs.length,
        capacity: capacity,
        occupancy: ((dinosaurs.length / capacity) * 100).toFixed(1) + '%'
      };
    }
  };
})();

// Używanie modułu
console.log("=== DODAWANIE DINOZAURÓW ===\n");

DinosaurPark.addDinosaur('T-Rex', 'Rexy');
DinosaurPark.addDinosaur('Velociraptor', 'Blue');
DinosaurPark.addDinosaur('Triceratops', 'Trike');

DinosaurPark.listDinosaurs();

console.log("\n=== STATUS PARKU ===\n");
console.log(DinosaurPark.getStatus());

console.log("\n=== OTWIERANIE PARKU ===\n");
DinosaurPark.openPark();

// Próba dostępu do prywatnych zmiennych
// console.log(dinosaurs); // ERROR! dinosaurs jest prywatny
// console.log(capacity); // ERROR! capacity jest prywatny

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Jak obsłużyć błąd w funkcji async?

Zadania praktyczne w grze

  • Edytor kodu

    Napisz async function z blokiem try/catch, która próbuje pobrać dane z czujnika i gracefully obsługuje błędy połączenia.

  • Układanie w pionie

    Uporządkuj etapy cyklu życia Promise:

  1. Pytanietry/catch z async/await
  2. Zadanie z kodemPraktyka: Obsługa błędów try/catch w async
  3. Ułóż w kolejnościCykl życia Promise

Przydatne artykuły