Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Typy błędów w JavaScript

6 min czytania ·
W tej lekcji13

W Parku Jurajskim, klasyfikacja dinozaurów jest kluczowa dla bezpieczeństwa - musisz wiedzieć, czy masz do czynienia z łagodnym Brachiozaurem czy niebezpiecznym Velociraptorem. Podobnie w JavaScript, rozpoznawanie różnych typów błędów pomaga skutecznie diagnozować i rozwiązywać problemy w kodzie.

Dr. Ian Malcolm powiedziałby: "Błędy... uh... znajdą sposób." I rzeczywiście, nawet w najbardziej starannie napisanym kodzie błędy mogą się pojawić. Dlatego zrozumienie ich typów jest tak ważne.

Błędy składniowe (SyntaxError)

SyntaxError to najbardziej podstawowy typ błędu - występuje, gdy kod zawiera konstrukcję naruszającą zasady składniowe języka JavaScript. To jak próba komunikacji z dinozaurem w niewłaściwym języku - nie zadziała!

// Przykłady błędów składniowych
function checkDinosaurEnclosure( {  // Brak zamknięcia nawiasu
  return isSecure;
}

const velociraptorCount = 3;
if (velociraptorCount > 2) {
  console.log("Zbyt wiele raptorów!") // Brak średnika (może być akceptowalne w niektórych kontekstach)
} else {
  console.log("Poziom bezpieczeństwa akceptowalny");
}

JavaScript zgłosi SyntaxError natychmiast podczas analizy kodu, jeszcze przed jego wykonaniem. Taki błąd całkowicie uniemożliwia uruchomienie programu.

Błędy referencji (ReferenceError)

ReferenceError pojawia się, gdy próbujesz uzyskać dostęp do zmiennej lub funkcji, która nie istnieje lub jest niedostępna w bieżącym zakresie. To jak szukanie dinozaura, który uciekł z wybiegu - nie ma go tam, gdzie powinien być!

// Przykłady ReferenceError
function alertSecurityTeam() {
  // tyrannosaurus nie jest zdefiniowany w tym zakresie
  if (tyrannosaurus.isLoose) {
    sendEmergencyAlert();
  }
}

// Użycie zmiennej przed jej deklaracją
console.log(securityCode); // ReferenceError
const securityCode = "1234";

Błędy typu (TypeError)

TypeError występuje, gdy operacja jest wykonywana na wartości niewłaściwego typu, lub gdy próbujesz wywołać właściwość lub metodę, która nie istnieje. To jak próba traktowania roślinożernego Triceratopsa jak drapieżnika.

// Przykłady TypeError
const dinosaurSpecies = ["Tyrannosaurus", "Velociraptor", "Triceratops"];

// Próba wywołania metody na nieprawidłowym typie
dinosaurSpecies.toUpperCase(); // TypeError: dinosaurSpecies.toUpperCase is not a function

// Próba dostępu do właściwości undefined
const securitySystem = null;
console.log(securitySystem.isActive); // TypeError: Cannot read property 'isActive' of null

// Próba wywołania wartości, która nie jest funkcją
const dinoCount = 5;
dinoCount(); // TypeError: dinoCount is not a function

Błędy zakresu (RangeError)

RangeError pojawia się, gdy wartość numeryczna jest poza dopuszczalnym zakresem. To jak próba utrzymania więcej dinozaurów w zagrodzie, niż może ona bezpiecznie pomieścić.

// Przykłady RangeError
function setDinosaurFeedingSchedule(intervalMs) {
  // Przekazanie negatywnej wartości do setTimeout spowoduje RangeError
  setTimeout(feedDinosaurs, intervalMs);
}

setDinosaurFeedingSchedule(-1000); // RangeError

// Inny przykład - przekroczenie maksymalnej głębokości rekurencji
function countdownToParkopenning(n) {
  console.log(n);
  // Brak warunku bazowego powoduje RangeError: Maximum call stack size exceeded
  countdownToParkopenning(n - 1);
}

countdownToParkopenning(10);

Błędy URI (URIError)

URIError występuje, gdy niepoprawne parametry są przekazywane do funkcji kodujących lub dekodujących URI. To rzadszy typ błędu, ale może wystąpić np. przy przetwarzaniu danych z API.

// Przykład URIError
try {
  // Próba dekodowania nieprawidłowej sekwencji URI
  decodeURIComponent('%'); // URIError: Invalid URI
} catch (error) {
  console.error("Błąd podczas dekodowania identyfikatora wybiegu:", error.message);
}

Błędy ewaluacji (EvalError)

EvalError był historycznie zgłaszany dla problemów związanych z funkcją eval(), ale we współczesnym JavaScript jest rzadko używany, podobnie jak funkcja eval() powinna być rzadko używana ze względów bezpieczeństwa.

Błędy agregacji (AggregateError)

AggregateError to nowszy typ błędu wprowadzony w ES2020, który grupuje wiele błędów w jeden. Jest używany np. przez Promise.any() gdy wszystkie obietnice są odrzucone.

// Przykład AggregateError
const dinosaurHealthChecks = [
  Promise.reject(new Error("Raptor 1: Podwyższona temperatura")),
  Promise.reject(new Error("Raptor 2: Nieprawidłowe parametry krwi")),
  Promise.reject(new Error("Raptor 3: Odmowa współpracy"))
];

Promise.any(dinosaurHealthChecks).catch(errors => {
  console.log(errors instanceof AggregateError); // true
  console.log(errors.message); // "All promises were rejected"
  console.log(errors.errors); // Tablica zawierająca wszystkie błędy
});

Błędy internacjonalizacji (InternalError)

InternalError jest zgłaszany, gdy błąd wewnętrzny występuje w silniku JavaScript, np. zbyt duża rekurencja. Nie jest to część specyfikacji ECMA, ale jest dostępny w niektórych implementacjach (np. Firefox).

Tworzenie własnych typów błędów

Możemy tworzyć własne, spersonalizowane błędy, rozszerzając klasę Error. W Parku Jurajskim mogłoby to być użyteczne dla specyficznych problemów związanych z zarządzaniem parkiem.

// Własna klasa błędu dla problemów z dinozaurami
class DinosaurEscapeError extends Error {
  constructor(species, location, message) {
    super(message);
    this.name = "DinosaurEscapeError";
    this.species = species;
    this.location = location;
    this.timestamp = new Date();
  }
}

function checkEnclosure(enclosureData) {
  if (!enclosureData.isSecure && enclosureData.containsPredators) {
    throw new DinosaurEscapeError(
      enclosureData.species,
      enclosureData.sector,
      `NIEBEZPIECZEŃSTWO! ${enclosureData.species} wydostał się z wybiegu w sektorze ${enclosureData.sector}!`
    );
  }
}

try {
  checkEnclosure({
    species: "Velociraptor",
    sector: "B4",
    isSecure: false,
    containsPredators: true
  });
} catch (error) {
  if (error instanceof DinosaurEscapeError) {
    console.error(`${error.name}: ${error.message}`);
    console.error(`Gatunek: ${error.species}, Lokalizacja: ${error.location}`);
    console.error(`Czas zdarzenia: ${error.timestamp}`);

    // Uruchom procedury bezpieczeństwa
    activateEmergencyProtocols(error.location);
    evacuateVisitors(error.location);
    alertSecurityTeam(error);
  }
}

Identyfikacja typów błędów

Aby skutecznie obsługiwać błędy, musimy umieć je identyfikować. W bloku catch możemy sprawdzić typ błędu za pomocą operatora instanceof lub właściwości name.

try {
  // Kod, który może generować różne typy błędów
  const parkSystems = null;
  console.log(parkSystems.securityStatus); // TypeError
} catch (error) {
  if (error instanceof TypeError) {
    console.error("Błąd typu:", error.message);
    // Odzyskiwanie po błędzie typu
    initializeParkSystems();
  } else if (error instanceof ReferenceError) {
    console.error("Błąd referencji:", error.message);
    // Odzyskiwanie po błędzie referencji
  } else {
    console.error("Nieznany błąd:", error.message);
    // Ogólna procedura odzyskiwania
  }
}

Właściwości obiektów błędów

Każdy obiekt błędu w JavaScript ma standardowe właściwości:

  1. name: Nazwa typu błędu (np. "TypeError", "SyntaxError")
  2. message: Opis błędu
  3. stack: Ślad stosu (informacja gdzie w kodzie wystąpił błąd)
try {
  const securityCameras = undefined;
  securityCameras.forEach(camera => camera.activate());
} catch (error) {
  console.error("Nazwa błędu:", error.name); // "TypeError"
  console.error("Wiadomość:", error.message); // "Cannot read property 'forEach' of undefined"
  console.error("Stos wywołań:", error.stack); // Pełny ślad stosu z informacją o linii kodu
}

Błędy asynchroniczne

Obsługa błędów w kodzie asynchronicznym wymaga specjalnego podejścia. W przypadku obietnic (Promises) używamy metody catch() lub bloku catch w konstrukcji async/await.

// Obsługa błędów w obietnicach
fetchDinosaurData()
  .then(data => processDinosaurData(data))
  .catch(error => {
    console.error("Błąd podczas pobierania danych o dinozaurach:", error);
    return getBackupDinosaurData(); // Plan awaryjny
  });

// Obsługa błędów w async/await
async function monitorDinosaurs() {
  try {
    const data = await fetchDinosaurData();
    processDinosaurData(data);
  } catch (error) {
    console.error("Błąd monitorowania:", error);

    // Różne procedury odzyskiwania w zależności od błędu
    if (error instanceof NetworkError) {
      await switchToOfflineMode();
    } else if (error instanceof AuthenticationError) {
      await refreshSecurityCredentials();
      return monitorDinosaurs(); // Spróbuj ponownie
    } else {
      notifyAdministrator(error);
    }
  }
}

Wnioski

Jak powiedział Dr. Alan Grant: "Najlepszą obroną jest wiedza". Rozumienie różnych typów błędów w JavaScript pozwala ci lepiej diagnozować problemy, pisać bardziej odporne aplikacje i skuteczniej obsługiwać nieoczekiwane sytuacje - zarówno w Parku Jurajskim, jak i w twoim kodzie.

W następnym ćwiczeniu przyjrzymy się dokładniej jak zgłaszać własne błędy za pomocą instrukcji throw oraz jak obsługiwać błędy za pomocą bloku try...catch...finally - niezbędnych narzędzi dla każdego programisty, podobnie jak solidna klatka jest niezbędna dla każdego tresera raptorów!

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. Który błąd JavaScript występuje, gdy próbujesz użyć niezadeklarowanej zmiennej?

  1. PytanieTypy błędów JavaScript

Przydatne artykuły