Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Własne klasy błędów

13 min czytania ·
W tej lekcji9

Witaj ponownie w Parku Jurajskim! W poprzednich ćwiczeniach poznaliśmy różne rodzaje błędów występujących w JavaScript oraz podstawy ich obsługi za pomocą try...catch...finally. Teraz zagłębimy się w tworzenie własnych, niestandardowych klas błędów, które są nieocenione w dużych aplikacjach - takich jak systemy zarządzania parkiem pełnym prehistorycznych gadów.

Dlaczego własne klasy błędów?

W złożonych systemach, takich jak Park Jurajski, potrzebujemy precyzyjnej kategoryzacji problemów. Nie wystarczy wiedzieć, że "coś poszło nie tak" - musimy wiedzieć dokładnie, co się stało, gdzie, i jak na to zareagować.

Własne klasy błędów pozwalają na:

  1. Precyzyjne kategoryzowanie różnych typów problemów
  2. Dołączanie dodatkowych danych kontekstowych do błędów
  3. Implementację własnych metod pomocniczych
  4. Łatwiejsze filtrowanie i obsługę specyficznych przypadków

To jak różnica między ogólnym alarmem w parku a precyzyjnym komunikatem: "Velociraptory wydostały się z wybiegu B6, ostatnio widziane zmierzające w kierunku centrum dla zwiedzających".

Podstawy tworzenia własnych klas błędów

W JavaScript wszystkie błędy dziedziczą z bazowej klasy Error. Nasze własne klasy błędów powinny również dziedziczyć z Error lub jednej z jej podklas.

Prosty przykład własnej klasy błędu

class DinosaurError extends Error {
  constructor(message) {
    super(message); // Wywołanie konstruktora klasy nadrzędnej
    this.name = 'DinosaurError'; // Nadpisanie nazwy błędu
  }
}

// Użycie
try {
  throw new DinosaurError('Nieoczekiwane zachowanie T-Rexa');
} catch (error) {
  console.log(error.name); // 'DinosaurError'
  console.log(error.message); // 'Nieoczekiwane zachowanie T-Rexa'
}

Dodawanie dodatkowych właściwości do błędów

Największą zaletą własnych klas błędów jest możliwość dodania dodatkowych właściwości z kontekstem:

class EnclosureBreachError extends Error {
  constructor(message, dinosaurSpecies, location, dangerLevel) {
    super(message);
    this.name = 'EnclosureBreachError';
    this.dinosaurSpecies = dinosaurSpecies;
    this.location = location;
    this.dangerLevel = dangerLevel;
    this.timestamp = new Date();
  }

  getEmergencyMessage() {
    return `UWAGA! ${this.dinosaurSpecies} wydostał się z wybiegu w lokalizacji ${this.location}.
    Poziom zagrożenia: ${this.dangerLevel}/10.
    Czas zdarzenia: ${this.timestamp.toLocaleTimeString()}`;
  }
}

// Użycie
try {
  throw new EnclosureBreachError(
    'Naruszenie zabezpieczeń wybiegu',
    'Velociraptor',
    'Sektor B6',
    9
  );
} catch (error) {
  if (error instanceof EnclosureBreachError) {
    console.error(error.getEmergencyMessage());

    // Uruchomienie odpowiednich procedur awaryjnych zależnie od poziomu zagrożenia
    if (error.dangerLevel >= 8) {
      evacuateSector(error.location);
      dispatchSecurityTeam(error.location, error.dinosaurSpecies);
    }
  }
}

Hierarchia klas błędów

W dużych aplikacjach, takich jak system zarządzania Parkiem Jurajskim, warto stworzyć hierarchię klas błędów:

// Bazowa klasa błędu specyficzna dla aplikacji
class JurassicParkError extends Error {
  constructor(message) {
    super(message);
    this.name = 'JurassicParkError';
    this.timestamp = new Date();
  }

  logError() {
    console.error(`[${this.timestamp.toISOString()}] ${this.name}: ${this.message}`);
  }
}

// Błędy związane z dinozaurami
class DinosaurError extends JurassicParkError {
  constructor(message, species) {
    super(message);
    this.name = 'DinosaurError';
    this.species = species;
  }
}

// Konkretne typy błędów związanych z dinozaurami
class DinosaurHealthError extends DinosaurError {
  constructor(message, species, healthIssue, severity) {
    super(message, species);
    this.name = 'DinosaurHealthError';
    this.healthIssue = healthIssue;
    this.severity = severity;
  }

  requiresVeterinarian() {
    return this.severity >= 7;
  }
}

class DinosaurBehaviorError extends DinosaurError {
  constructor(message, species, behavior, dangerLevel) {
    super(message, species);
    this.name = 'DinosaurBehaviorError';
    this.behavior = behavior;
    this.dangerLevel = dangerLevel;
  }

  requiresIntervention() {
    return this.dangerLevel >= 5;
  }
}

// Błędy związane z infrastrukturą parku
class ParkInfrastructureError extends JurassicParkError {
  constructor(message, systemName, location) {
    super(message);
    this.name = 'ParkInfrastructureError';
    this.systemName = systemName;
    this.location = location;
  }
}

// Konkretne typy błędów infrastruktury
class PowerSystemError extends ParkInfrastructureError {
  constructor(message, location, affectedSystems) {
    super(message, 'PowerSystem', location);
    this.name = 'PowerSystemError';
    this.affectedSystems = affectedSystems;
  }

  requiresBackupPower() {
    return this.affectedSystems.includes('SecurityFences');
  }
}

Taka hierarchia pozwala na precyzyjną obsługę różnych typów błędów:

async function monitorParkSystems() {
  try {
    await checkDinosaurHealth();
    await checkEnclosureSecurity();
    await checkPowerSystems();
  } catch (error) {
    // Logowanie wszystkich błędów
    console.error(`[${new Date().toISOString()}] Error:`, error);

    // Różne reakcje w zależności od typu błędu
    if (error instanceof DinosaurHealthError) {
      if (error.requiresVeterinarian()) {
        await dispatchVeterinarianTeam(error.species, error.healthIssue, error.severity);
      } else {
        await scheduleRoutineCheckup(error.species);
      }
    }
    else if (error instanceof DinosaurBehaviorError) {
      if (error.requiresIntervention()) {
        await dispatchBehavioralSpecialist(error.species, error.behavior);
        if (error.dangerLevel >= 8) {
          await prepareTransquilizers(error.species);
        }
      }
    }
    else if (error instanceof PowerSystemError) {
      await notifyMaintenanceTeam(error.location, error.message);
      if (error.requiresBackupPower()) {
        await activateBackupGenerators(error.location);
      }
    }
    else if (error instanceof JurassicParkError) {
      // Ogólna obsługa dla wszystkich błędów parku
      await logToSecuritySystem(error);
    }
    else {
      // Nieznany typ błędu
      console.error('Nieznany błąd:', error);
    }
  }
}

Serializacja błędów

Jeden z problemów z obiektami błędów w JavaScript to ich serializacja. Domyślnie, gdy próbujemy przekonwertować błąd do JSON, tracimy większość informacji:

const error = new Error('Test error');
console.log(JSON.stringify(error)); // {} - puste obiekty!

Własne klasy błędów mogą rozwiązać ten problem implementując metodę toJSON:

class SerializableError extends Error {
  constructor(message) {
    super(message);
    this.name = this.constructor.name;
  }

  toJSON() {
    return {
      name: this.name,
      message: this.message,
      stack: this.stack,
      // Dodatkowe właściwości specyficzne dla podklas
      ...Object.getOwnPropertyNames(this)
        .filter(prop => !['name', 'message', 'stack'].includes(prop))
        .reduce((obj, prop) => {
          obj[prop] = this[prop];
          return obj;
        }, {})
    };
  }
}

// Teraz możemy tworzyć serializowalne błędy
class DinosaurEscapeError extends SerializableError {
  constructor(message, species, location) {
    super(message);
    this.species = species;
    this.location = location;
    this.timestamp = new Date();
  }
}

const error = new DinosaurEscapeError(
  'Dinozaur uciekł z wybiegu',
  'Velociraptor',
  'Sektor B6'
);

// Teraz error można poprawnie serializować
console.log(JSON.stringify(error, null, 2));
/* Wynik:
{
  "name": "DinosaurEscapeError",
  "message": "Dinozaur uciekł z wybiegu",
  "stack": "DinosaurEscapeError: Dinozaur uciekł z wybiegu\n    at ...",
  "species": "Velociraptor",
  "location": "Sektor B6",
  "timestamp": "2023-05-15T10:30:45.123Z"
}
*/

Jest to szczególnie przydatne, gdy musimy przesyłać informacje o błędach przez API lub zapisywać je w logach.

Obsługa błędów asynchronicznych z niestandardowymi klasami

Własne klasy błędów świetnie współpracują z asynchronicznym kodem:

// Klasa błędu specyficzna dla API
class APIError extends Error {
  constructor(message, statusCode, endpoint) {
    super(message);
    this.name = 'APIError';
    this.statusCode = statusCode;
    this.endpoint = endpoint;
    this.timestamp = new Date();
  }

  isServerError() {
    return this.statusCode >= 500;
  }

  isClientError() {
    return this.statusCode >= 400 && this.statusCode < 500;
  }

  isAuthError() {
    return this.statusCode === 401 || this.statusCode === 403;
  }
}

// Funkcja pobierająca dane z API, która używa niestandardowej klasy błędu
async function fetchDinosaurData(dinoId) {
  try {
    const response = await fetch(`https://jurassic-park-api.com/dinosaurs/${dinoId}`);

    if (!response.ok) {
      throw new APIError(
        `Błąd podczas pobierania danych o dinozaurze #${dinoId}`,
        response.status,
        `/dinosaurs/${dinoId}`
      );
    }

    return await response.json();
  } catch (error) {
    if (error instanceof APIError) {
      // Obsługa błędów API
      if (error.isAuthError()) {
        await refreshAuthToken();
        return fetchDinosaurData(dinoId); // Ponowna próba po odświeżeniu tokenu
      } else if (error.isServerError()) {
        console.error('Błąd serwera, próba użycia zapasowego API...');
        return fetchDinosaurDataFromBackupAPI(dinoId);
      } else {
        console.error(`Błąd klienta: ${error.message} (statusCode: ${error.statusCode})`);
        throw error; // Przekazujemy błąd dalej
      }
    } else {
      // Inny rodzaj błędu (np. sieciowy)
      console.error('Nieoczekiwany błąd:', error);
      throw new Error(`Nie udało się pobrać danych o dinozaurze #${dinoId}: ${error.message}`);
    }
  }
}

Zaawansowany przykład: System raportowania incydentów

Zobaczmy, jak możemy wykorzystać własne klasy błędów w bardziej rozbudowanym przykładzie - systemie raportowania incydentów w Parku Jurajskim:

// Bazowa klasa błędu dla incydentów
class IncidentError extends Error {
  constructor(message, location, severity) {
    super(message);
    this.name = 'IncidentError';
    this.location = location;
    this.severity = severity; // 1-10
    this.timestamp = new Date();
    this.resolved = false;
    this.resolutionTime = null;
  }

  markAsResolved() {
    this.resolved = true;
    this.resolutionTime = new Date();
    return this;
  }

  getIncidentDuration() {
    if (!this.resolved) return null;
    return (this.resolutionTime - this.timestamp) / 1000; // w sekundach
  }

  requiresEvacuation() {
    return this.severity >= 7;
  }

  requiresNotification() {
    return this.severity >= 4;
  }

  getSummary() {
    return {
      type: this.name,
      message: this.message,
      location: this.location,
      severity: this.severity,
      timestamp: this.timestamp,
      status: this.resolved ? 'Rozwiązany' : 'Aktywny',
      resolutionTime: this.resolutionTime
    };
  }

  toJSON() {
    return this.getSummary();
  }
}

// Klasy dla różnych typów incydentów
class DinosaurEscapeIncident extends IncidentError {
  constructor(message, location, species, count, dangerLevel) {
    super(message, location, dangerLevel);
    this.name = 'DinosaurEscapeIncident';
    this.species = species;
    this.count = count;
    this.lastSighting = location;
  }

  updateSighting(newLocation) {
    this.lastSighting = newLocation;
    return this;
  }

  getSummary() {
    return {
      ...super.getSummary(),
      species: this.species,
      count: this.count,
      lastSighting: this.lastSighting
    };
  }
}

class SystemFailureIncident extends IncidentError {
  constructor(message, location, system, affectedAreas, backupStatus) {
    // Obliczenie poziomu krytyczności na podstawie systemu i dostępności backupu
    const severity = SystemFailureIncident.calculateSeverity(system, backupStatus);

    super(message, location, severity);
    this.name = 'SystemFailureIncident';
    this.system = system;
    this.affectedAreas = affectedAreas;
    this.backupStatus = backupStatus;
  }

  static calculateSeverity(system, backupStatus) {
    const systemCriticality = {
      'electric_fences': 10,
      'security_doors': 9,
      'surveillance': 7,
      'climate_control': 6,
      'guest_services': 3
    };

    // Jeśli backup działa, zmniejsz poziom krytyczności
    const baseSeverity = systemCriticality[system] || 5;
    return backupStatus === 'operational' ? Math.max(3, baseSeverity - 3) : baseSeverity;
  }

  requiresMaintenanceTeam() {
    return true;
  }

  requiresEmergencyPower() {
    return this.system === 'electric_fences' || this.system === 'security_doors';
  }

  getSummary() {
    return {
      ...super.getSummary(),
      system: this.system,
      affectedAreas: this.affectedAreas,
      backupStatus: this.backupStatus,
      requiresEmergencyPower: this.requiresEmergencyPower()
    };
  }
}

class VisitorIncident extends IncidentError {
  constructor(message, location, visitorCount, injuryLevel, medicalStatus) {
    // Obliczenie poziomu krytyczności na podstawie liczby gości i poziomu obrażeń
    const severity = VisitorIncident.calculateSeverity(visitorCount, injuryLevel);

    super(message, location, severity);
    this.name = 'VisitorIncident';
    this.visitorCount = visitorCount;
    this.injuryLevel = injuryLevel; // 'none', 'minor', 'moderate', 'severe'
    this.medicalStatus = medicalStatus; // 'not_required', 'dispatched', 'on_scene', 'evacuating'
  }

  static calculateSeverity(visitorCount, injuryLevel) {
    const injurySeverity = {
      'none': 1,
      'minor': 3,
      'moderate': 6,
      'severe': 9
    };

    // Zwiększ poziom krytyczności dla większej liczby gości
    const baseSeverity = injurySeverity[injuryLevel] || 5;
    const visitorFactor = visitorCount > 10 ? 2 : visitorCount > 3 ? 1 : 0;

    return Math.min(10, baseSeverity + visitorFactor);
  }

  requiresMedicalTeam() {
    return this.injuryLevel !== 'none';
  }

  updateMedicalStatus(newStatus) {
    this.medicalStatus = newStatus;

    // Jeśli pomoc medyczna jest na miejscu i sytuacja nie jest krytyczna,
    // możemy zmniejszyć poziom krytyczności
    if (newStatus === 'on_scene' && this.injuryLevel !== 'severe') {
      this.severity = Math.max(2, this.severity - 2);
    }

    return this;
  }

  getSummary() {
    return {
      ...super.getSummary(),
      visitorCount: this.visitorCount,
      injuryLevel: this.injuryLevel,
      medicalStatus: this.medicalStatus,
      requiresMedicalTeam: this.requiresMedicalTeam()
    };
  }
}

// System zarządzania incydentami
class IncidentManagementSystem {
  constructor() {
    this.activeIncidents = new Map();
    this.resolvedIncidents = [];
    this.eventListeners = {
      'new': [],
      'update': [],
      'resolve': []
    };
  }

  reportIncident(incident) {
    if (!(incident instanceof IncidentError)) {
      throw new TypeError('Można raportować tylko obiekty typu IncidentError');
    }

    const incidentId = `INC-${Date.now()}-${Math.floor(Math.random() * 1000)}`;
    this.activeIncidents.set(incidentId, incident);

    // Powiadomienie wszystkich słuchaczy o nowym incydencie
    this._notifyListeners('new', { id: incidentId, incident });

    // Automatyczne reakcje na incydent
    this._triggerAutomatedResponses(incidentId, incident);

    return incidentId;
  }

  updateIncident(incidentId, updateFn) {
    if (!this.activeIncidents.has(incidentId)) {
      throw new Error(`Incydent o ID ${incidentId} nie istnieje lub został już rozwiązany`);
    }

    const incident = this.activeIncidents.get(incidentId);
    updateFn(incident);

    // Powiadomienie wszystkich słuchaczy o aktualizacji incydentu
    this._notifyListeners('update', { id: incidentId, incident });

    return incident;
  }

  resolveIncident(incidentId, resolutionNotes = '') {
    if (!this.activeIncidents.has(incidentId)) {
      throw new Error(`Incydent o ID ${incidentId} nie istnieje lub został już rozwiązany`);
    }

    const incident = this.activeIncidents.get(incidentId);
    incident.markAsResolved();
    incident.resolutionNotes = resolutionNotes;

    // Przenieś incydent z aktywnych do rozwiązanych
    this.activeIncidents.delete(incidentId);
    this.resolvedIncidents.push({ id: incidentId, incident });

    // Powiadomienie wszystkich słuchaczy o rozwiązaniu incydentu
    this._notifyListeners('resolve', { id: incidentId, incident });

    return incident;
  }

  getActiveIncidents() {
    return Array.from(this.activeIncidents.entries()).map(([id, incident]) => ({
      id,
      ...incident.getSummary()
    }));
  }

  getIncidentById(incidentId) {
    if (this.activeIncidents.has(incidentId)) {
      return {
        id: incidentId,
        status: 'active',
        ...this.activeIncidents.get(incidentId).getSummary()
      };
    }

    const resolvedIncident = this.resolvedIncidents.find(inc => inc.id === incidentId);
    if (resolvedIncident) {
      return {
        id: incidentId,
        status: 'resolved',
        ...resolvedIncident.incident.getSummary()
      };
    }

    return null;
  }

  addEventListener(event, callback) {
    if (!this.eventListeners[event]) {
      throw new Error(`Nieznany typ zdarzenia: ${event}`);
    }

    this.eventListeners[event].push(callback);
    return () => this.removeEventListener(event, callback); // Funkcja do usunięcia listenera
  }

  removeEventListener(event, callback) {
    if (!this.eventListeners[event]) return false;

    const index = this.eventListeners[event].indexOf(callback);
    if (index !== -1) {
      this.eventListeners[event].splice(index, 1);
      return true;
    }
    return false;
  }

  _notifyListeners(event, data) {
    if (!this.eventListeners[event]) return;

    for (const listener of this.eventListeners[event]) {
      try {
        listener(data);
      } catch (error) {
        console.error(`Błąd w listenerze zdarzenia ${event}:`, error);
      }
    }
  }

  _triggerAutomatedResponses(incidentId, incident) {
    console.log(`Automatyczna reakcja na incydent ${incidentId}:`, incident.name);

    // Różne reakcje w zależności od typu incydentu
    if (incident instanceof DinosaurEscapeIncident) {
      if (incident.requiresEvacuation()) {
        console.log(`EWAKUACJA! Uruchamianie protokołu ewakuacji dla: ${incident.location}`);
        // evacuateSector(incident.location);
      }

      console.log(`Wysyłanie zespołu ACU (Asset Containment Unit) do lokalizacji: ${incident.lastSighting}`);
      // dispatchACUTeam(incident.lastSighting, incident.species, incident.count);
    }

    else if (incident instanceof SystemFailureIncident) {
      console.log(`Powiadomienie zespołu technicznego o awarii systemu: ${incident.system}`);
      // notifyMaintenanceTeam(incident.system, incident.location);

      if (incident.requiresEmergencyPower()) {
          console.log('Uruchamianie systemu zasilania awaryjnego!');
        // activateEmergencyPower(incident.affectedAreas);
      }
    }

    else if (incident instanceof VisitorIncident) {
      if (incident.requiresMedicalTeam()) {
        console.log(`Wysyłanie zespołu medycznego do lokalizacji: ${incident.location}`);
        // dispatchMedicalTeam(incident.location, incident.injuryLevel, incident.visitorCount);

        // Aktualizacja statusu medycznego
        this.updateIncident(incidentId, inc => inc.updateMedicalStatus('dispatched'));
      }

      if (incident.requiresEvacuation()) {
        console.log(`Rozpoczynam ewakuację gości z: ${incident.location}`);
        // evacuateVisitors(incident.location);
      }
    }

    // Wspólne reakcje dla wszystkich incydentów
    if (incident.requiresNotification()) {
      console.log('Powiadamianie kierownictwa parku...');
      // notifyParkManagement(incident.getSummary());
    }
  }
}

// Przykład użycia systemu incydentów
function demoParkIncidentSystem() {
  const incidentSystem = new IncidentManagementSystem();

  // Dodajemy słuchacza dla nowych incydentów
  incidentSystem.addEventListener('new', ({ id, incident }) => {
    console.log(`NOWY INCYDENT [${id}]: ${incident.name} w lokalizacji ${incident.location}`);
  });

  // Raportowanie incydentu z dinozaurem
  const raptorIncidentId = incidentSystem.reportIncident(
    new DinosaurEscapeIncident(
      'Ucieczka Velociraptorów z zagrody',
      'Sektor C4',
      'Velociraptor',
      3,
      9 // Wysoki poziom zagrożenia
    )
  );

  // Aktualizacja incydentu - zmiana ostatniego spostrzeżenia
  setTimeout(() => {
    incidentSystem.updateIncident(raptorIncidentId, incident => {
      incident.updateSighting('Sektor C5 - w pobliżu centrum odwiedzających');
      console.log(`Aktualizacja: Raptory zauważono w ${incident.lastSighting}`);
    });
  }, 2000);

  // Raportowanie incydentu systemowego
  const powerIncidentId = incidentSystem.reportIncident(
    new SystemFailureIncident(
      'Awaria zasilania ogrodzeń elektrycznych',
      'Sektor B1-B3',
      'electric_fences',
      ['TRex Paddock', 'Raptor Containment'],
      'offline' // Backup nie działa
    )
  );

  // Raportowanie incydentu z gośćmi
  const visitorIncidentId = incidentSystem.reportIncident(
    new VisitorIncident(
      'Goście poza wyznaczoną trasą zwiedzania',
      'Sektor D2',
      4, // Liczba gości
      'minor', // Drobne obrażenia
      'not_required' // Status medyczny
    )
  );

  // Wyświetlanie aktywnych incydentów
  setTimeout(() => {
    console.log('\n--- AKTYWNE INCYDENTY ---');
    console.table(incidentSystem.getActiveIncidents());
  }, 3000);

  // Rozwiązanie incydentu z gośćmi
  setTimeout(() => {
    incidentSystem.resolveIncident(
      visitorIncidentId,
      'Goście zostali bezpiecznie eskortowani z powrotem na wyznaczoną trasę zwiedzania.'
    );
    console.log(`Incydent ${visitorIncidentId} został oznaczony jako rozwiązany.`);
  }, 4000);

  // Rozwiązanie incydentu z zasilaniem
  setTimeout(() => {
    incidentSystem.resolveIncident(
      powerIncidentId,
      'Zasilanie przywrócone, ogrodzenia ponownie aktywne.'
    );
    console.log(`Incydent ${powerIncidentId} został oznaczony jako rozwiązany.`);
  }, 5000);

  // Rozwiązanie incydentu z raptorami
  setTimeout(() => {
    incidentSystem.resolveIncident(
      raptorIncidentId,
      'Wszystkie 3 Velociraptory złapane i bezpiecznie przetransportowane z powrotem do zagrody.'
    );
    console.log(`Incydent ${raptorIncidentId} został oznaczony jako rozwiązany.`);

    // Wyświetlenie podsumowania incydentu
    const incidentDetails = incidentSystem.getIncidentById(raptorIncidentId);
    console.log('\n--- SZCZEGÓŁY ROZWIĄZANEGO INCYDENTU ---');
    console.log(JSON.stringify(incidentDetails, null, 2));
  }, 6000);
}

// Uruchomienie demonstracji
// demoParkIncidentSystem();

Dobre praktyki tworzenia własnych klas błędów

  1. Nazywaj błędy znacząco - nazwa powinna jasno wskazywać, co poszło nie tak
  2. Twórz hierarchię błędów - używaj dziedziczenia, aby stworzyć logiczną hierarchię klas błędów
  3. Dodawaj kontekst - zawsze dołączaj dodatkowe informacje, które pomogą w diagnozie i obsłudze błędu
  4. Implementuj metody pomocnicze - dodawaj metody, które ułatwią kategorizację i obsługę błędów
  5. Dbaj o serializację - dodaj metodę toJSON(), aby błędy można było łatwo logować i przesyłać
  6. Zachowaj ślad stosu - upewnij się, że wywołujesz super(message) w konstruktorze, aby zachować ślad stosu
  7. Dokumentuj swoje klasy błędów - inni programiści (i przyszły ty) powinni wiedzieć, kiedy i jak używać twoich klas błędów

Wnioski

Własne klasy błędów to potężne narzędzie w arsenale programisty JavaScript. W złożonych aplikacjach, takich jak system zarządzania Parkiem Jurajskim, precyzyjna kategoryzacja i obsługa różnych typów błędów jest kluczowa dla utrzymania bezpieczeństwa i stabilności.

Pamiętaj, że jak powiedział Dr. Ian Malcolm: "Życie... uh... znajdzie sposób." To samo dotyczy błędów w kodzie. Najlepszym podejściem jest nie udawać, że błędy nie istnieją, ale spodziewać się ich i być przygotowanym na ich obsługę w jak najbardziej elegancki i skuteczny sposób.

W następnym ćwiczeniu wykorzystamy wszystkie poznane techniki do implementacji pełnej aplikacji, która będzie demonstrować moduły, asynchroniczność i obsługę błędów w praktyce.

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 prawidłowo stworzyć własną klasę błędu w JavaScript?

  2. 2. Do czego służy operator instanceof w obsłudze błędów?

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj klasy ParkError, FenceBreachError i PowerFailureError z metodami pomocniczymi.

  • Klikanie w kolejności

    Ułóż elementy definicji własnej klasy błędu w poprawnej kolejności:

  1. PytanieTworzenie własnej klasy błędu
  2. PytanieOperator instanceof z błędami
  3. Zadanie z kodemPraktyka: Hierarchia klas błędów
  4. Kliknij w kolejnościSkładnia własnej klasy błędu

Przydatne artykuły