Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty
Obsługa błędów w JavaScript
W tej lekcji7
W Parku Jurajskim nawet najstaranniej zaplanowane systemy w końcu zawodzą - dinozaur wyłamuje się z wybiegu, czujnik przestaje raportować, automatyczny karmnik dostaje uszkodzone dane. Właśnie dlatego każdy system bezpieczeństwa parku ma swoje protokoły awaryjne: pierwsza usterka nie zamyka parku, tylko uruchamia procedurę. W JavaScript tą procedurą jest mechanizm try/catch/finally.
Blok try/catch - protokół bezpieczeństwa
Wyobraź sobie, że każda operacja w parku to potencjalne zagrożenie. Blok try jest strefą, w której wykonujemy ryzykowną operację, a catch ekipą ratunkową, która wkracza, gdy coś pójdzie nie tak. Podręcznikowym przykładem takiej ryzykownej operacji jest parsowanie JSON, bo transmisja z czujnika potrafi dotrzeć uszkodzona.
try {
// Strefa ryzykowna - parsowanie danych z czujnika
const dinoData = JSON.parse('{ niepoprawny JSON }');
console.log(dinoData.species);
} catch (error) {
// Ekipa ratunkowa - obsługa błędu
console.log("ALARM! Awaria systemu:", error.message);
}
console.log("System działa dalej - park nie został zamknięty!");Bez try/catch program zatrzymałby się na tym błędzie na dobre - tak jakby cały park trzeba było ewakuować z powodu jednego wadliwego czujnika. Tutaj błąd trafia do obiektu error, blok catch zapisuje jego komunikat w konsoli, a program kontynuuje działanie tuż za całą konstrukcją. Dlatego ostatnia linia mimo wszystko się wypisuje.
Przyjrzyj się temu, jaką drogą błąd w ogóle do nas dociera. JSON.parse nie zwraca żadnej wartości błędu, którą dałoby się porównać przez ===, więc zapis w rodzaju if (JSON.parse(data) === error) nie ma szans zadziałać. Nie ma tu też callbacku .onError(), który można by zarejestrować, a wynik parsowania nie jest obietnicą (promise) - nie doczepisz do niego .catch(), a tym bardziej nie odwrócisz tego zapisu do postaci error.catch(JSON.parse(data)). Rzucony błąd potrafi przechwycić wyłącznie blok catch. Jedyny prawidłowy sposób obsługi błędu podczas parsowania JSON wygląda więc tak: try { JSON.parse(data); } catch (error) { handleError(error); }.
Sama konstrukcja zawsze ma ten sam kształt i składa się z pięciu części, wpisywanych dokładnie w tej kolejności: słowo kluczowe try, blok w klamrach z ryzykownym kodem { riskyCode(); }, słowo kluczowe catch, parametr (error) w nawiasach, a na końcu blok obsługi { handleError(error); }. Nawias z parametrem należy do catch, nigdy do try - to najczęstsza pomyłka przy pierwszych próbach. Zapamiętaj ten pięcioelementowy szkielet raz, a potem odtworzysz go z pamięci przy każdym ryzykownym wywołaniu.
Blok finally - protokół końcowy
finally to blok, który wykonuje się zawsze - niezależnie od tego, czy błąd wystąpił, czy nie. To procedura domknięcia ogrodzenia: obowiązuje bez względu na wynik misji, a w kodzie odpowiada jej wszystko, o czym nie wolno zapomnieć nawet w panice.
function feedDinosaur(dinoName, food) {
console.log("Otwieranie karmnika dla " + dinoName + "...");
try {
if (!food) {
throw new Error("Brak pożywienia w systemie!");
}
console.log("Podaję " + food + " dla " + dinoName);
} catch (error) {
console.log("ALARM: " + error.message);
} finally {
// ZAWSZE zamykamy karmnik - czy udało się nakarmić, czy nie
console.log("Zamykanie karmnika - bezpieczeństwo przede wszystkim!");
}
}
feedDinosaur("Rex", "mięso"); // Sukces + zamknięcie
feedDinosaur("Rex", null); // Błąd + zamknięcie (finally działa zawsze!)Porównaj oba wywołania. Pierwsze karmienie kończy się sukcesem, więc catch w ogóle nie wchodzi do gry - a karmnik i tak zostaje zamknięty. Drugie rzuca błąd, catch ogłasza alarm - i karmnik znowu zostaje zamknięty. Tutaj rodzi się najczęstsze nieporozumienie: finally nie jest blokiem, który wykonuje się tylko gdy wystąpi błąd w bloku try, ani takim, który wykonuje się tylko gdy nie wystąpi żaden błąd, ani takim, który zależy od tego, czy blok catch pomyślnie obsłużył błąd. On przechodzi za każdym razem, również wtedy, gdy w try pojawi się return.
Cały cykl obsługi błędu przebiega przez pięć etapów:
- Kod w bloku
trynapotyka błąd - Wykonanie przechodzi do bloku
catchz obiektemerror - Blok
catchobsługuje błąd (logowanie, naprawa) - Blok
finallywykonuje operacje końcowe (czyszczenie zasobów) - Program kontynuuje działanie po bloku try/catch/finally
W czwartym etapie umieszczamy więc wszystko, co trzeba zwolnić bez względu na przebieg misji: połączenia, pliki i karmniki, które ktoś zostawił otwarte.
Klasy błędów w JavaScript
JavaScript ma wbudowaną hierarchię błędów, podobnie jak park ma różne poziomy alertów dla różnych zagrożeń.
Główne typy błędów
- Error - ogólny błąd (alert ogólny w parku)
- TypeError - operacja na niewłaściwym typie danych (karmienie roślinożercy mięsem)
- RangeError - wartość poza dozwolonym zakresem (temperatura inkubatora poza skalą)
- ReferenceError - odwołanie do nieistniejącej zmiennej (dinozaur, którego nie ma w bazie)
- SyntaxError - błąd składni kodu (uszkodzony plan DNA)
Każdą z tych klas rozpoznasz wewnątrz catch operatorem instanceof i to właśnie ten test decyduje, którą procedurę awaryjną uruchomić - park musi wiedzieć, jaki alarm się włączył, zanim wyśle ekipę.
// TypeError - operacja na niewłaściwym typie
try {
const dino = null;
dino.roar(); // null nie ma metod!
} catch (error) {
console.log(error instanceof TypeError); // true
console.log(error.message); // "Cannot read properties of null"
}
// RangeError - wartość poza zakresem
try {
const dinoArray = new Array(-5); // Ujemna długość tablicy!
} catch (error) {
console.log(error instanceof RangeError); // true
}
// ReferenceError - nieistniejąca zmienna
try {
console.log(missingDinosaur);
} catch (error) {
console.log(error instanceof ReferenceError); // true
}Trzy różne awarie, trzy różne klasy, a obsługuje je ten sam kształt catch. Właściwość message niesie opis czytelny dla człowieka, natomiast instanceof daje kategorię, na której program potrafi się rozgałęzić. Wszystkie trzy powstają w trakcie działania programu i dlatego try/catch w ogóle ma szansę je przechwycić.
SyntaxError wyłamuje się z tej reguły, bo popsutą składnię we własnym pliku silnik wychwytuje jeszcze zanim program wystartuje. W czasie działania spotkasz ją w dwóch miejscach: wewnątrz eval oraz - znacznie częściej - przy parsowaniu uszkodzonego JSON.
// SyntaxError - uszkodzony kod, zwykle wychwycony przed startem programu
try {
eval("function(");
} catch (error) {
console.log(error instanceof SyntaxError); // true
}
// Ta sama klasa wraca z uszkodzonego JSON
try {
JSON.parse("{ niepoprawny JSON }");
} catch (error) {
console.log(error instanceof SyntaxError); // true
}Drugi przykład domyka klamrę z naszym pierwszym fragmentem: alarm podniesiony przez JSON.parse to SyntaxError. Dzięki temu odróżnisz w kodzie transmisję, która przyszła uszkodzona, od transmisji, która dotarła w całości, ale zawiera bzdurne wartości. To dwie zupełnie różne awarie i wymagają dwóch różnych reakcji dyżurnego.
Throw - aktywacja alarmu
Słowo kluczowe throw pozwala celowo wywołać błąd - jak ręczne włączenie alarmu w parku w chwili, gdy zauważymy problem, zanim zdążą go wykryć systemy automatyczne. Towarzyszy mu jedna żelazna zasada: rzucaj obiekt Error albo jego podklasę, nigdy zwykły napis, bo tylko obiekt błędu niesie ze sobą komunikat, nazwę i ślad stosu wywołań.
function checkEnclosureFence(voltage) {
if (voltage < 0) {
throw new RangeError("Napięcie nie może być ujemne: " + voltage);
}
if (voltage < 5000) {
throw new Error("ALARM: Napięcie ogrodzenia poniżej minimum! (" + voltage + "V)");
}
console.log("Ogrodzenie sprawne: " + voltage + "V");
}
try {
checkEnclosureFence(10000); // OK
checkEnclosureFence(3000); // Rzuca Error
} catch (error) {
console.log("Wykryto problem:", error.message);
}Dwa zabezpieczenia, dwie różne klasy: ujemny odczyt jest fizycznie niemożliwy, więc dostaje RangeError, a ogrodzenie tylko zbyt słabe - zwykły Error. W chwili, gdy throw zadziała, reszta funkcji zostaje porzucona: drugie wywołanie nigdy nie wypisze komunikatu o sprawnym ogrodzeniu, sterowanie skacze prosto do catch, a ewentualna trzecia instrukcja w bloku try też się nie wykona. Funkcja niczego nie rozstrzyga - ona tylko sygnalizuje, a decyzję podejmuje wywołujący. Ten sam mechanizm wykorzystasz przy walidacji danych: gdy funkcja wyszukująca nie znajdzie dinozaura, rzucenie Error jest znacznie bezpieczniejsze niż ciche zwrócenie undefined, a przy karmieniu każda złamana reguła - nieznana dieta, niemożliwy poziom zdrowia, pusty magazyn pożywienia - podnosi własny alarm.
Re-throw - przekazanie alarmu wyżej
Bywa, że catch przechwyci błąd, z którym sam nie potrafi nic zrobić. Wtedy wyrzuca go ponownie (re-throw), żeby zareagował ktoś wyżej w łańcuchu dowodzenia. Złapanie błędu tylko po to, by po cichu zniknął, jest najgorszym z możliwych rozwiązań: alarm milknie, ale dinozaur nadal biega na wolności.
function processEnclosureData(data) {
try {
const parsed = JSON.parse(data);
if (!parsed.species) {
throw new Error("Brak gatunku w danych wybiegu");
}
return parsed;
} catch (error) {
if (error instanceof SyntaxError) {
// Ten przypadek umiemy obsłużyć - dane są uszkodzone
console.log("Uszkodzone dane, używam wartości domyślnych");
return { species: "Unknown", status: "error" };
}
// Każdy inny błąd - przekazujemy wyżej
throw error;
}
}Ta funkcja jest wybredna z premedytacją. Uszkodzony JSON daje SyntaxError, z którego potrafi się podnieść, podstawiając bezpieczny rekord zastępczy. Brak gatunku to zupełnie inna historia: dane sparsowały się poprawnie, więc zgadywanie zamiotłoby pod dywan prawdziwą usterkę w bazie parku - i dlatego ten błąd wędruje wyżej, do kodu, który ma dość kontekstu, by podjąć decyzję. try/catch ma filtrować błędy, a nie je pochłaniać. Połykanie wszystkiego w jednym pustym catch to przepis na usterki niewidoczne przez wiele miesięcy.
Własne klasy błędów
W Parku Jurajskim różne sytuacje wymagają wyspecjalizowanych procedur awaryjnych. W JavaScript dostajemy je, pisząc własne klasy błędów, które rozszerzają wbudowaną klasę Error.
class DinosaurEscapeError extends Error {
constructor(species, enclosure) {
super("ALARM: " + species + " uciekł z wybiegu " + enclosure + "!");
this.name = "DinosaurEscapeError";
this.species = species;
this.enclosure = enclosure;
}
}
class FeedingError extends Error {
constructor(dinoName, reason) {
super("Błąd karmienia " + dinoName + ": " + reason);
this.name = "FeedingError";
this.dinoName = dinoName;
}
}
class EnclosureVoltageError extends Error {
constructor(enclosure, voltage) {
super("Napięcie w wybiegu " + enclosure + ": " + voltage + "V (minimum 5000V)");
this.name = "EnclosureVoltageError";
this.enclosure = enclosure;
this.voltage = voltage;
}
}Przepis jest za każdym razem ten sam: konstruktor przekazuje gotowy komunikat do super(...), ustawia czytelną nazwę w name, a potem zapisuje dodatkowe fakty potrzebne ekipie interwencyjnej - gatunek, numer wybiegu, zmierzone napięcie. Tą samą metodą dopiszesz SensorError dla czujnika, który przestał odpowiadać. Nic nie stoi też na przeszkodzie, żeby postawić nad nimi wspólną klasę nadrzędną, na przykład ParkError extends Error z polem code - wtedy pojedyncze sprawdzenie instanceof ParkError złapie całą rodzinę błędów parku naraz.
Gdy klasy są gotowe, obchód ochrony może reagować na każde zagrożenie inaczej:
// Użycie z selektywnym catch
function parkSecurityCheck(enclosures) {
for (const enc of enclosures) {
try {
if (enc.voltage < 5000) {
throw new EnclosureVoltageError(enc.name, enc.voltage);
}
if (enc.dinoEscaped) {
throw new DinosaurEscapeError(enc.species, enc.name);
}
console.log("Wybieg " + enc.name + " - status OK");
} catch (error) {
if (error instanceof DinosaurEscapeError) {
console.log("CZERWONY ALERT: " + error.message);
console.log("Gatunek: " + error.species);
} else if (error instanceof EnclosureVoltageError) {
console.log("ŻÓŁTY ALERT: " + error.message);
} else {
throw error; // Nieznany błąd - re-throw
}
}
}
}Blok catch czytaj jak stanowisko dyspozytora: ucieczka dostaje czerwony alert razem z gatunkiem odczytanym prosto z obiektu błędu, słabe ogrodzenie żółty alert, a wszystko, czego dyspozytor nie rozpoznaje, wraca w górę zamiast być obsłużone na oślep. Ponieważ try siedzi w środku pętli, jeden felerny wybieg nie przerywa kontroli pozostałych - skaner idzie dalej. Właśnie własne klasy błędów umożliwiają taką precyzyjną obsługę: różne zagrożenia zasługują na różne procedury, dokładnie tak, jak w prawdziwym parku różne alarmy uruchamiają różne protokoły.
Optional chaining (?.) i Nullish coalescing (??)
Te dwa operatory to inteligentne czujniki parku. Pozwalają bezpiecznie poruszać się po danych, które bywają niekompletne, zamiast wysypywać centrum kontroli przy pierwszym brakującym polu.
Optional chaining (?.)
Operator ?. sięga po zagnieżdżone właściwości bez ryzyka. Jeśli którakolwiek wartość po drodze okaże się null albo undefined, całe wyrażenie zatrzymuje się w tym miejscu i oddaje wynik, zamiast wywalić program.
const dinoRecord = {
species: "Velociraptor",
tracker: {
lastLocation: "Sektor C",
gps: { lat: 23.5, lng: -80.2 }
}
};
// Bez optional chaining - ryzyko TypeError
// const lat = dinoRecord.medical.lastCheckup.date; // TypeError!
// Z optional chaining - bezpieczny dostęp
const lat = dinoRecord.medical?.lastCheckup?.date; // undefined (bez błędu!)
const gpsLat = dinoRecord.tracker?.gps?.lat; // 23.5
// Działa też z metodami i indeksami
const dinoCall = dinoRecord.sounds?.roar?.(); // undefined (metoda nie istnieje)
const firstTag = dinoRecord.tags?.[0]; // undefined (brak tablicy)Zatrzymaj się na linii dinoRecord.medical?.lastCheckup?.date. Nasz rekord nie ma właściwości medical, a mimo to wyrażenie zwróci undefined bez wyrzucenia błędu: łańcuch urywa się na pierwszym brakującym ogniwie. Nie dostaniesz null, nie dostaniesz pustego stringa "" i nie zobaczysz TypeError, choć medical faktycznie nie istnieje - dokładnie przed tym wyjątkiem chroni cię zakomentowana linia powyżej. Zapamiętaj też dwa warianty operatora: ?.() wywoła metodę tylko wtedy, gdy ona istnieje, a ?.[0] sięgnie po indeks tylko wtedy, gdy tablica naprawdę jest na miejscu. Miej przy tym świadomość, że ?. ukrywa brak danych, ale go nie naprawia - milczący czujnik nadal milczy.
Nullish coalescing (??)
Operator ?? podstawia wartość domyślną, gdy lewa strona to null albo undefined. W odróżnieniu od || nie reaguje na 0, "" ani false - w odczytach parku to wartości najzupełniej prawidłowe.
// Problem z || - traktuje 0 i "" jako puste
const dinoWeight = 0;
console.log(dinoWeight || "Brak danych"); // "Brak danych" (źle! 0 to prawidłowa waga)
console.log(dinoWeight ?? "Brak danych"); // 0 (poprawnie!)
// Praktyczny przykład z danymi dinozaurów
function getDinoInfo(dino) {
const name = dino?.name ?? "Nieznany dinozaur";
const weight = dino?.weight ?? "brak danych";
const isHealthy = dino?.isHealthy ?? false;
const speed = dino?.speed ?? 0;
return name + " | Waga [kg]: " + weight + " | Zdrowy: " + isHealthy + " | Prędkość: " + speed;
}
console.log(getDinoInfo({ name: "Rex", weight: 8000 }));
console.log(getDinoInfo(null)); // Bezpieczne - nie wyrzuci błęduPierwsza para linii streszcza całą sprawę: świeżo wyklute pisklę dinozaura naprawdę może mieć zmierzoną wagę 0, a || wyrzuciłoby ten pomiar do kosza i wypisało "Brak danych". Popatrz również na wywołanie getDinoInfo(null) - ono się nie wywala, bo dino?.name zwiera obwód jeszcze przed odczytem właściwości. Razem ?. i ?? zamieniają awarię w sensowny raport zastępczy.
Ta sama ochrona liczy się przy konfiguracji czujników, gdzie świadomie wyłączona wartość jest pełnoprawną informacją, a nie luką do zasypania.
const sensorConfig = {
voltage: 0, // celowe zero
active: false, // celowo wyłączony
label: "" // celowo pusta nazwa
};
console.log(sensorConfig.voltage ?? 10000); // 0 (jawne zero zostaje)
console.log(sensorConfig.active ?? true); // false (jawne false zostaje)
console.log(sensorConfig.label ?? "bez nazwy"); // "" (jawny pusty string zostaje)
console.log(sensorConfig.missing ?? "N/A"); // "N/A" (undefined, więc wchodzi domyślna)Tylko ostatnia linia sięga po wartość domyślną, bo tylko ostatniej właściwości naprawdę brakuje. Wyłączony czujnik zostaje wyłączony, ogrodzenie odcięte od prądu na czas przeglądu zostaje na zerze, a nienazwana sonda zachowuje pustą etykietę. Dokładnie tego oczekujesz od centrum kontroli, które nie ma prawa zmyślać odczytów - gdyby w tych czterech linijkach stało ||, dyżurny zobaczyłby napięcie 10000V na ogrodzeniu, przez które spokojnie da się przejść.
Kombinacja ?. i ??
W praktyce oba operatory chodzą parami: ?. bezpiecznie prowadzi do wartości, a ?? decyduje, co pokazać, gdy ta wartość nigdy nie dotrze.
const parkData = {
enclosures: {
"A-1": { species: "T-Rex", voltage: 10000 }
}
};
// Bezpieczne odczytanie danych z wartością domyślną
const voltage = parkData.enclosures?.["B-2"]?.voltage ?? "Brak czujnika";
console.log("Napięcie B-2:", voltage); // "Brak czujnika"
const rexVoltage = parkData.enclosures?.["A-1"]?.voltage ?? 0;
console.log("Napięcie A-1:", rexVoltage); // 10000Wybieg B-2 nie ma jeszcze wpisu w danych, więc łańcuch daje undefined, a ?? podstawia komunikat "Brak czujnika" - tablica dyżurnego melduje lukę w pokryciu, zamiast się zawiesić. Wybieg A-1 odpowiada prawdziwym odczytem i skoro 10000 nie jest ani null, ani undefined, wartość domyślna w ogóle nie wchodzi do gry. Jedna linia zastępuje tu całą kaskadę instrukcji if, a monitoring nie przerywa pracy przez jeden brakujący rekord.
Strategia obsługi błędów
Dobra strategia obsługi błędów w aplikacji działa jak wielopoziomowy system bezpieczeństwa Parku Jurajskiego:
- Waliduj dane wejściowe - sprawdzaj je, ZANIM staną się problemem (jak kontrola na bramce parku)
- Używaj konkretnych typów błędów - twórz własne klasy dla różnych sytuacji (inny alarm dla innego zagrożenia)
- Obsługuj błędy na właściwym poziomie - łap je tam, gdzie faktycznie umiesz je naprawić (zaciętego karmnika nie zgłasza się dyrektorowi parku)
- Przekazuj wyżej nieznane błędy - jeśli nie wiesz, jak obsłużyć błąd, oddaj go w górę łańcucha
- Zwalniaj zasoby w
finally- zamykaj połączenia, pliki i ogrodzenia, cokolwiek się wydarzy
"Włączony alarm to nie katastrofa, tylko informacja" - powtarza Dr. Rex, zamykając panel kontrolny. Trzymaj się tych pięciu zasad i zapamiętaj sedno: try/catch/finally jest awaryjnym protokołem parku, własne klasy błędów są konkretnymi alarmami, które mówią ekipie, którą procedurę uruchomić, a ?. i ?? to czujniki, dzięki którym nie wszczynasz alarmu bez powodu.
Kod do tej lekcji: index.js
// Obsluga bledow w JavaScript - Park Jurajski Edition
console.log("=== SYSTEM BEZPIECZENSTWA PARKU JURAJSKIEGO ===\n");
// ================================================
// 1. TRY/CATCH - protokol awaryjny
// ================================================
console.log("--- 1. try/catch ---");
try {
const dinoData = JSON.parse('{ "species": "T-Rex", "weight": 8500 }');
console.log("Dane dinozaura:", dinoData.species, "-", dinoData.weight + "kg");
} catch (error) {
console.log("ALARM! Blad parsowania danych:", error.message);
}
// Blad w parsowaniu - catch lapiie blad
try {
const brokenData = JSON.parse("{ zly format }");
} catch (error) {
console.log("\nZlapany blad:", error.message);
console.log("Typ bledu:", error.constructor.name);
}
// ================================================
// 2. FINALLY - zawsze sie wykonuje
// ================================================
console.log("\n--- 2. try/catch/finally ---");
function feedDinosaur(dinoName, food) {
console.log("\nOtwieranie karmnika dla " + dinoName + "...");
try {
if (!food) {
throw new Error("Brak pozywienia w systemie!");
}
if (food === "trawa" && dinoName === "Rex") {
throw new TypeError("T-Rex nie jest roslinozerca!");
}
console.log("Podaje " + food + " dla " + dinoName + " - sukces!");
} catch (error) {
console.log("ALARM: " + error.message);
} finally {
console.log("Zamykanie karmnika - bezpieczenstwo!");
}
}
feedDinosaur("Rex", "mieso");
feedDinosaur("Rex", null);
feedDinosaur("Rex", "trawa");
// ================================================
// 3. TYPY BLEDOW
// ================================================
console.log("\n--- 3. Typy bledow ---");
// TypeError
try {
const dino = null;
dino.roar();
} catch (e) {
console.log("TypeError:", e.message);
}
// RangeError
try {
const arr = new Array(-1);
} catch (e) {
console.log("RangeError:", e.message);
}
// ReferenceError
try {
console.log(nieistniejacyDinozaur);
} catch (e) {
console.log("ReferenceError:", e.message);
}
// ================================================
// 4. WLASNE KLASY BLEDOW
// ================================================
console.log("\n--- 4. Wlasne klasy bledow ---");
class DinosaurEscapeError extends Error {
constructor(species, enclosure) {
super("ALARM: " + species + " uciekl z wybiegu " + enclosure + "!");
this.name = "DinosaurEscapeError";
this.species = species;
this.enclosure = enclosure;
}
}
class EnclosureVoltageError extends Error {
constructor(enclosure, voltage) {
super("Napiecie w " + enclosure + ": " + voltage + "V (min 5000V)");
this.name = "EnclosureVoltageError";
this.enclosure = enclosure;
this.voltage = voltage;
}
}
const enclosures = [
{ name: "A-1", species: "T-Rex", voltage: 10000, dinoEscaped: false },
{ name: "B-3", species: "Raptor", voltage: 3000, dinoEscaped: false },
{ name: "C-2", species: "Dilophosaurus", voltage: 8000, dinoEscaped: true },
];
for (const enc of enclosures) {
try {
if (enc.dinoEscaped) {
throw new DinosaurEscapeError(enc.species, enc.name);
}
if (enc.voltage < 5000) {
throw new EnclosureVoltageError(enc.name, enc.voltage);
}
console.log("Wybieg " + enc.name + " - OK");
} catch (error) {
if (error instanceof DinosaurEscapeError) {
console.log("CZERWONY ALERT: " + error.message);
} else if (error instanceof EnclosureVoltageError) {
console.log("ZOLTY ALERT: " + error.message);
}
}
}
// ================================================
// 5. OPTIONAL CHAINING i NULLISH COALESCING
// ================================================
console.log("\n--- 5. ?. i ?? ---");
const dinoRecord = {
species: "Velociraptor",
tracker: { lastLocation: "Sektor C", gps: { lat: 23.5 } }
};
// Optional chaining - bezpieczny dostep
console.log("GPS:", dinoRecord.tracker?.gps?.lat); // 23.5
console.log("Medical:", dinoRecord.medical?.lastCheckup); // undefined
// Nullish coalescing - wartosc domyslna
const weight = 0;
console.log("|| :", weight || "Brak danych"); // "Brak danych" (zle!)
console.log("??:", weight ?? "Brak danych"); // 0 (poprawnie!)
// Kombinacja
const voltage = dinoRecord.tracker?.voltage ?? "Brak czujnika";
console.log("Napiecie:", voltage);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. Jaki jest prawidłowy sposób obsługi błędu, który może wystąpić podczas parsowania JSON w JavaScript?
2. Kiedy wykonuje się blok finally w konstrukcji try/catch/finally?
3. Co zwróci wyrażenie: dinoRecord.medical?.lastCheckup?.date, jeśli obiekt dinoRecord nie posiada właściwości medical?
Zadania praktyczne w grze
- Edytor kodu
Napisz funkcję findDinosaur(dinosaurs, id), która zwraca z tablicy dinozaura o podanym id, a gdy go nie ma, rzuca new Error('Nie ma dinozaura o ID ' + id). Napisz funkcję feedDinosaur(dinosaurs, id, food): w bloku try znajdź dinozaura przez findDinosaur, rzuć TypeError, gdy pokarm nie pasuje do diety (carnivore je 'meat', herbivore je 'plants'), a w przeciwnym razie zwróć true; w catch wyświetl error.message i zwróć false; w finally wyświetl 'Zamykanie karmnika'. Napisz też readVoltage(record), która bezpiecznie odczytuje record.sensors.voltage operatorem ?. i zwraca 'Brak czujnika', gdy tej wartości nie ma (użyj ??).
- Układanie w pionie
Uporządkuj etapy obsługi błędu w JavaScript od momentu wystąpienia problemu:
- Klikanie w kolejności
Ułóż elementy w prawidłowej kolejności, aby zbudować blok try/catch w JavaScript:
- Edytor kodu
Stwórz klasy DinosaurEscapeError(species, enclosure), FeedingError(dinoName, reason) i SensorError(sensorType, enclosure), które rozszerzają Error, przekazują komunikat do super(), ustawiają this.name na nazwę klasy i zapisują parametry we właściwościach o tych samych nazwach. Napisz funkcję securityScan(enclosures), która dla każdego wybiegu { name, species, voltage, dinoEscaped } w bloku try rzuca DinosaurEscapeError, gdy dinoEscaped jest true, albo SensorError('voltage', name), gdy voltage < 5000. W catch rozpoznaj błąd przez instanceof i wyświetl 'CZERWONY ALERT: ' + message albo 'ŻÓŁTY ALERT: ' + message, a błąd innego typu rzuć dalej. Funkcja zwraca obiekt z liczbą alertów { red, yellow }.
Zadania po tej lekcji
- PytaniePodstawy błędów - składnia try/catch
- PytaniePodstawy błędów - blok finally
- Zadanie z kodemPodstawy błędów - system bezpieczeństwa parku
- Ułóż w kolejnościPodstawy błędów - kolejność obsługi
- Kliknij w kolejnościPodstawy błędów - budowanie bloku try/catch
- Zadanie z kodemPodstawy błędów - własne klasy błędów
- PytaniePodstawy błędów - optional chaining (?.)