Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne
Obsługa błędów (try...catch)
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
tryzawiera kod, który może spowodować błąd - Blok
catchjest wykonywany, gdy wystąpi błąd w blokutry - Blok
finallyjest 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
Zawsze obsługuj błędy: Każda funkcja asynchroniczna powinna mieć jakąś formę obsługi błędów.
Używaj specyficznych typów błędów: Twórz dedykowane klasy błędów dla różnych typów problemów.
Dostarczaj użyteczne komunikaty: Błąd powinien zawierać informacje przydatne do diagnozy problemu.
Loguj błędy centralnie: Użyj systemów logowania, które pozwalają na centralne zbieranie i analizowanie błędów.
Nigdy nie ignoruj błędów: Jeśli łapiesz błąd i nie potrzebujesz go dalej obsługiwać, przynajmniej go zaloguj.
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 });
}Obsługuj błędy na odpowiednim poziomie: Nie wszystkie błędy powinny być obsługiwane w tym samym miejscu.
Korzystaj z try...finally: Używaj bloku
finallydo czyszczenia zasobów niezależnie od tego, czy wystąpił błąd.Nie przeciążaj informacjami: Nie pokazuj użytkownikom szczegółowych informacji o błędach, które ich nie dotyczą.
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 prywatnyHasł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. 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: