Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Implementacja aplikacji z wykorzystaniem poznanych technik

25 min czytania ·
W tej lekcji6

Witaj w końcowej fazie naszej przygody w Parku Jurajskim! W tym ćwiczeniu połączymy wszystkie poznane dotychczas techniki, aby stworzyć kompletną aplikację do monitorowania i zarządzania ekosystemem Parku Jurajskiego. To nasz "wielki finał" przed przejściem do strukturyzacji większych projektów.

Cel projektu

Stworzymy aplikację "JurassicTracker" - system do monitorowania, śledzenia i zarządzania dinozaurami w parku. Nasza aplikacja będzie wykorzystywać:

  1. Modularny kod (ES Modules)
  2. Asynchroniczne operacje (Promises, async/await)
  3. Obsługę błędów (try/catch, własne klasy błędów)
  4. Serwisy działające w tle (setInterval)
  5. Zarządzanie stanem aplikacji

Struktura projektu

Zanim przejdziemy do implementacji, zaplanujmy strukturę naszego projektu:

jurassic-tracker/
├── index.js               # Główny plik aplikacji
├── modules/
│   ├── api.js             # Moduł komunikacji z API
│   ├── dinosaurs.js       # Moduł zarządzania dinozaurami
│   ├── enclosures.js      # Moduł zarządzania wybiegami
│   ├── security.js        # Moduł systemów bezpieczeństwa
│   ├── monitoring.js      # Moduł monitorowania parku
│   ├── utils.js           # Narzędzia pomocnicze
│   └── errors/            # Katalog z klasami błędów
│       ├── index.js       # Eksportuje wszystkie błędy
│       ├── APIError.js    # Błędy związane z API
│       ├── DinoError.js   # Błędy związane z dinozaurami
│       └── SecurityError.js # Błędy związane z bezpieczeństwem
└── data/
    └── config.js          # Konfiguracja aplikacji

Implementacja modułów

Zacznijmy od zaimplementowania każdego z modułów. Pamiętaj, że w praktyce te pliki znalazłyby się w oddzielnych plikach zgodnie z powyższą strukturą.

1. Moduł błędów (errors/index.js)

Najpierw zdefiniujmy nasze niestandardowe klasy błędów:

// errors/APIError.js
export 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;
  }
}

// errors/DinoError.js
export class DinoError extends Error {
  constructor(message, dinoId, species) {
    super(message);
    this.name = 'DinoError';
    this.dinoId = dinoId;
    this.species = species;
    this.timestamp = new Date();
  }
}

export class DinoNotFoundError extends DinoError {
  constructor(dinoId) {
    super(`Dinozaur o ID ${dinoId} nie został znaleziony`, dinoId, null);
    this.name = 'DinoNotFoundError';
  }
}

export class DinoBehaviorError extends DinoError {
  constructor(message, dinoId, species, behaviorType, dangerLevel) {
    super(message, dinoId, species);
    this.name = 'DinoBehaviorError';
    this.behaviorType = behaviorType;
    this.dangerLevel = dangerLevel; // 1-10
  }

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

// errors/SecurityError.js
export class SecurityError extends Error {
  constructor(message, sector, systemType) {
    super(message);
    this.name = 'SecurityError';
    this.sector = sector;
    this.systemType = systemType;
    this.timestamp = new Date();
  }
}

export class EnclosureBreachError extends SecurityError {
  constructor(sector, dinoSpecies, count) {
    super(`Naruszenie wybiegu w sektorze ${sector}: ${count} okazów ${dinoSpecies}`, sector, 'enclosure');
    this.name = 'EnclosureBreachError';
    this.dinoSpecies = dinoSpecies;
    this.count = count;
  }
}

// errors/index.js
export * from './APIError.js';
export * from './DinoError.js';
export * from './SecurityError.js';

2. Moduł API (api.js)

Nasz moduł API będzie odpowiedzialny za komunikację z (hipotetycznym) serwerem Parku Jurajskiego:

// modules/api.js
import { APIError } from '../errors/index.js';

// Symulacja bazy danych (w rzeczywistości byłoby to API)
const API_DELAY = 500; // ms - symulacja opóźnienia sieciowego
const API_ERROR_RATE = 0.1; // 10% szans na błąd API dla realizmu

// Symulowane dane dinozaurów
let dinosaursData = [
  { id: 'trx1', name: 'Rex', species: 'Tyrannosaurus', enclosureId: 'enc1', health: 98, lastFed: new Date(Date.now() - 3600000), behavior: 'calm' },
  { id: 'rap1', name: 'Blue', species: 'Velociraptor', enclosureId: 'enc2', health: 95, lastFed: new Date(Date.now() - 7200000), behavior: 'agitated' },
  { id: 'rap2', name: 'Delta', species: 'Velociraptor', enclosureId: 'enc2', health: 92, lastFed: new Date(Date.now() - 7200000), behavior: 'hunting' },
  { id: 'tri1', name: 'Sarah', species: 'Triceratops', enclosureId: 'enc3', health: 88, lastFed: new Date(Date.now() - 1800000), behavior: 'sleeping' },
  { id: 'bro1', name: 'Bronty', species: 'Brontosaurus', enclosureId: 'enc4', health: 100, lastFed: new Date(Date.now() - 900000), behavior: 'grazing' },
];

// Symulowane dane wybiegów
let enclosuresData = [
  { id: 'enc1', name: 'T-Rex Paddock', sector: 'A1', powerStatus: 'active', securityLevel: 10, lastInspection: new Date(Date.now() - 86400000) },
  { id: 'enc2', name: 'Raptor Containment', sector: 'B2', powerStatus: 'active', securityLevel: 9, lastInspection: new Date(Date.now() - 129600000) },
  { id: 'enc3', name: 'Triceratops Territory', sector: 'C3', powerStatus: 'active', securityLevel: 6, lastInspection: new Date(Date.now() - 172800000) },
  { id: 'enc4', name: 'Herbivore Valley', sector: 'D4', powerStatus: 'active', securityLevel: 4, lastInspection: new Date(Date.now() - 259200000) },
];

// Funkcja pomocnicza symulująca opóźnienie sieciowe
const simulateNetworkDelay = () => {
  return new Promise(resolve => setTimeout(resolve, API_DELAY * (0.5 + Math.random())));
};

// Funkcja pomocnicza symulująca błędy API
const simulateApiError = (endpoint) => {
  if (Math.random() < API_ERROR_RATE) {
    const errorTypes = [
      { statusCode: 500, message: 'Internal Server Error' },
      { statusCode: 503, message: 'Service Unavailable' },
      { statusCode: 429, message: 'Too Many Requests' },
      { statusCode: 403, message: 'Forbidden - Insufficient permissions' }
    ];
    const errorType = errorTypes[Math.floor(Math.random() * errorTypes.length)];
    throw new APIError(`API Error: ${errorType.message}`, errorType.statusCode, endpoint);
  }
};

// API do pobierania danych o dinozaurach
export async function getDinosaurs() {
  const endpoint = '/api/dinosaurs';
  try {
    await simulateNetworkDelay();
    simulateApiError(endpoint);
    return [...dinosaursData]; // Zwracamy kopię, aby uniknąć mutacji
  } catch (error) {
    if (error instanceof APIError) {
      throw error;
    }
    throw new APIError('Błąd podczas pobierania danych o dinozaurach', 500, endpoint);
  }
}

export async function getDinosaurById(id) {
  const endpoint = `/api/dinosaurs/${id}`;
  try {
    await simulateNetworkDelay();
    simulateApiError(endpoint);
    const dino = dinosaursData.find(d => d.id === id);
    if (!dino) {
      throw new APIError(`Dinozaur o ID ${id} nie został znaleziony`, 404, endpoint);
    }
    return { ...dino }; // Zwracamy kopię
  } catch (error) {
    if (error instanceof APIError) {
      throw error;
    }
    throw new APIError(`Błąd podczas pobierania dinozaura ${id}`, 500, endpoint);
  }
}

export async function updateDinosaur(id, updates) {
  const endpoint = `/api/dinosaurs/${id}`;
  try {
    await simulateNetworkDelay();
    simulateApiError(endpoint);
    const dinoIndex = dinosaursData.findIndex(d => d.id === id);
    if (dinoIndex === -1) {
      throw new APIError(`Dinozaur o ID ${id} nie został znaleziony`, 404, endpoint);
    }

    // Aktualizacja danych
    dinosaursData[dinoIndex] = {
      ...dinosaursData[dinoIndex],
      ...updates,
      id // Upewniamy się, że ID się nie zmienia
    };

    return { ...dinosaursData[dinoIndex] };
  } catch (error) {
    if (error instanceof APIError) {
      throw error;
    }
    throw new APIError(`Błąd podczas aktualizacji dinozaura ${id}`, 500, endpoint);
  }
}

// API do pobierania danych o wybiegach
export async function getEnclosures() {
  const endpoint = '/api/enclosures';
  try {
    await simulateNetworkDelay();
    simulateApiError(endpoint);
    return [...enclosuresData];
  } catch (error) {
    if (error instanceof APIError) {
      throw error;
    }
    throw new APIError('Błąd podczas pobierania danych o wybiegach', 500, endpoint);
  }
}

export async function getEnclosureById(id) {
  const endpoint = `/api/enclosures/${id}`;
  try {
    await simulateNetworkDelay();
    simulateApiError(endpoint);
    const enclosure = enclosuresData.find(e => e.id === id);
    if (!enclosure) {
      throw new APIError(`Wybieg o ID ${id} nie został znaleziony`, 404, endpoint);
    }
    return { ...enclosure };
  } catch (error) {
    if (error instanceof APIError) {
      throw error;
    }
    throw new APIError(`Błąd podczas pobierania wybiegu ${id}`, 500, endpoint);
  }
}

export async function updateEnclosure(id, updates) {
  const endpoint = `/api/enclosures/${id}`;
  try {
    await simulateNetworkDelay();
    simulateApiError(endpoint);
    const enclosureIndex = enclosuresData.findIndex(e => e.id === id);
    if (enclosureIndex === -1) {
      throw new APIError(`Wybieg o ID ${id} nie został znaleziony`, 404, endpoint);
    }

    // Aktualizacja danych
    enclosuresData[enclosureIndex] = {
      ...enclosuresData[enclosureIndex],
      ...updates,
      id
    };

    return { ...enclosuresData[enclosureIndex] };
  } catch (error) {
    if (error instanceof APIError) {
      throw error;
    }
    throw new APIError(`Błąd podczas aktualizacji wybiegu ${id}`, 500, endpoint);
  }
}

// API do logowania zdarzeń
export async function logEvent(eventType, details) {
  const endpoint = '/api/events';
  try {
    await simulateNetworkDelay();
    simulateApiError(endpoint);

    // W rzeczywistości wysłalibyśmy zdarzenie do serwera
    console.log(`[EVENT] ${eventType}:`, details);

    return { success: true, timestamp: new Date() };
  } catch (error) {
    if (error instanceof APIError) {
      throw error;
    }
    throw new APIError('Błąd podczas logowania zdarzenia', 500, endpoint);
  }
}

3. Moduł dinozaurów (dinosaurs.js)

Ten moduł będzie odpowiedzialny za zarządzanie danymi o dinozaurach i ich zachowaniami:

// modules/dinosaurs.js
import { getDinosaurs, getDinosaurById, updateDinosaur, logEvent } from './api.js';
import { DinoNotFoundError, DinoBehaviorError } from '../errors/index.js';

// Ocena ryzyka zachowania dinozaura
function assessBehaviorRisk(dino) {
  const dangerousSpecies = ['Tyrannosaurus', 'Velociraptor', 'Spinosaurus'];
  const riskBehaviors = {
    'calm': 1,
    'grazing': 1,
    'sleeping': 2,
    'exploring': 4,
    'agitated': 6,
    'hunting': 7,
    'aggressive': 9
  };

  // Bazowy poziom ryzyka zależy od gatunku
  let baseRisk = dangerousSpecies.includes(dino.species) ? 5 : 2;

  // Modyfikacja ryzyka w zależności od zachowania
  const behaviorRisk = riskBehaviors[dino.behavior] || 3;

  // Modyfikacja ryzyka w zależności od czasu od ostatniego karmienia
  const hoursSinceLastFed = (Date.now() - new Date(dino.lastFed).getTime()) / 3600000;
  const hungerRisk = Math.min(5, Math.floor(hoursSinceLastFed / 3));

  // Całkowity poziom ryzyka (1-10)
  const totalRisk = Math.min(10, baseRisk + behaviorRisk + hungerRisk);

  return {
    risk: totalRisk,
    factors: {
      species: baseRisk,
      behavior: behaviorRisk,
      hunger: hungerRisk
    }
  };
}

// Pobieranie wszystkich dinozaurów
export async function getAllDinosaurs() {
  try {
    const dinosaurs = await getDinosaurs();

    // Wzbogacamy dane o ocenę ryzyka
    return dinosaurs.map(dino => ({
      ...dino,
      riskAssessment: assessBehaviorRisk(dino)
    }));
  } catch (error) {
    console.error('Błąd podczas pobierania listy dinozaurów:', error);
    throw error;
  }
}

// Pobieranie konkretnego dinozaura po ID
export async function getDinosaur(id) {
  try {
    const dino = await getDinosaurById(id);
    return {
      ...dino,
      riskAssessment: assessBehaviorRisk(dino)
    };
  } catch (error) {
    if (error.statusCode === 404) {
      throw new DinoNotFoundError(id);
    }
    console.error(`Błąd podczas pobierania dinozaura ${id}:`, error);
    throw error;
  }
}

// Karmienie dinozaura
export async function feedDinosaur(id) {
  try {
    const dino = await getDinosaur(id);

    // Aktualizacja stanu dinozaura
    const updatedDino = await updateDinosaur(id, {
      lastFed: new Date(),
      health: Math.min(100, dino.health + 5),
      behavior: 'calm' // Dinozaury są spokojniejsze po karmieniu
    });

    // Logowanie zdarzenia
    await logEvent('FEEDING', {
      dinoId: id,
      species: dino.species,
      name: dino.name,
      previousFeedingTime: dino.lastFed
    });

    return {
      ...updatedDino,
      riskAssessment: assessBehaviorRisk(updatedDino)
    };
  } catch (error) {
    console.error(`Błąd podczas karmienia dinozaura ${id}:`, error);
    throw error;
  }
}

// Monitorowanie zachowania dinozaura
export async function monitorBehavior(id) {
  try {
    const dino = await getDinosaur(id);
    const { risk, factors } = assessBehaviorRisk(dino);

    // Sprawdzamy, czy zachowanie wymaga interwencji
    if (risk >= 8) {
      const error = new DinoBehaviorError(
        `Niebezpieczne zachowanie dinozaura ${dino.name}`,
        id,
        dino.species,
        dino.behavior,
        risk
      );

      // Logowanie zdarzenia wysokiego ryzyka
      await logEvent('HIGH_RISK_BEHAVIOR', {
        dinoId: id,
        species: dino.species,
        name: dino.name,
        behavior: dino.behavior,
        risk,
        factors
      });

      throw error;
    }

    // Dla średniego ryzyka tylko logujemy
    if (risk >= 5) {
      await logEvent('MEDIUM_RISK_BEHAVIOR', {
        dinoId: id,
        species: dino.species,
        name: dino.name,
        behavior: dino.behavior,
        risk,
        factors
      });
    }

    return { dino, risk, factors };
  } catch (error) {
    if (error instanceof DinoBehaviorError) {
      throw error; // Przekazujemy dalej nasz własny błąd
    }
    console.error(`Błąd podczas monitorowania dinozaura ${id}:`, error);
    throw error;
  }
}

// Symulacja zmiany zachowania (używana przez moduł monitorowania)
export async function simulateBehaviorChange() {
  try {
    const allDinos = await getAllDinosaurs();
    const randomIndex = Math.floor(Math.random() * allDinos.length);
    const targetDino = allDinos[randomIndex];

    // Możliwe zachowania zależne od gatunku i ostatniego karmienia
    const possibleBehaviors = ['calm', 'grazing', 'sleeping', 'exploring', 'agitated', 'hunting', 'aggressive'];
    const carnivores = ['Tyrannosaurus', 'Velociraptor', 'Spinosaurus'];

    let behaviorPool;
    if (carnivores.includes(targetDino.species)) {
      // Drapieżniki mają większe szanse na agresywne zachowania
      behaviorPool = ['calm', 'sleeping', 'exploring', 'agitated', 'hunting', 'aggressive'];
    } else {
      // Roślinożercy są generalnie spokojniejsi
      behaviorPool = ['calm', 'grazing', 'sleeping', 'exploring', 'agitated'];
    }

    // Głodne dinozaury są bardziej agresywne
    const hoursSinceLastFed = (Date.now() - new Date(targetDino.lastFed).getTime()) / 3600000;
    if (hoursSinceLastFed > 8) {
      if (carnivores.includes(targetDino.species)) {
        behaviorPool = ['agitated', 'hunting', 'aggressive'];
      } else {
        behaviorPool = ['agitated', 'exploring'];
      }
    }

    // Losowy wybór nowego zachowania
    const newBehavior = behaviorPool[Math.floor(Math.random() * behaviorPool.length)];

    // Aktualizacja stanu dinozaura
    const updatedDino = await updateDinosaur(targetDino.id, {
      behavior: newBehavior
    });

    await logEvent('BEHAVIOR_CHANGE', {
      dinoId: targetDino.id,
      species: targetDino.species,
      name: targetDino.name,
      previousBehavior: targetDino.behavior,
      newBehavior
    });

    return {
      ...updatedDino,
      riskAssessment: assessBehaviorRisk(updatedDino)
    };
  } catch (error) {
    console.error('Błąd podczas symulacji zmiany zachowania:', error);
    throw error;
  }
}

4. Moduł wybiegów (enclosures.js)

Ten moduł będzie zarządzał wybiegami i ich stanem bezpieczeństwa:

// modules/enclosures.js
import { getEnclosures, getEnclosureById, updateEnclosure, logEvent } from './api.js';
import { SecurityError, EnclosureBreachError } from '../errors/index.js';
import { getAllDinosaurs } from './dinosaurs.js';

// Ocena stanu bezpieczeństwa wybiegu
function assessSecurityStatus(enclosure, dinosaurs) {
  // Sprawdzamy, ile dinozaurów jest w wybiegu
  const enclosureDinosaurs = dinosaurs.filter(dino => dino.enclosureId === enclosure.id);

  // Sprawdzamy, czy są drapieżniki
  const carnivores = enclosureDinosaurs.filter(dino =>
    ['Tyrannosaurus', 'Velociraptor', 'Spinosaurus'].includes(dino.species)
  );

  // Sprawdzamy łączne ryzyko
  const totalRisk = enclosureDinosaurs.reduce((sum, dino) =>
    sum + (dino.riskAssessment ? dino.riskAssessment.risk : 3), 0);

  // Stan zasilania
  const powerStatus = enclosure.powerStatus === 'active' ? 10 :
                       enclosure.powerStatus === 'backup' ? 5 : 0;

  // Czas od ostatniej inspekcji (w dniach)
  const daysSinceInspection = (Date.now() - new Date(enclosure.lastInspection).getTime()) / (24 * 3600000);
  const inspectionScore = daysSinceInspection < 1 ? 10 :
                          daysSinceInspection < 3 ? 7 :
                          daysSinceInspection < 7 ? 4 : 1;

  // Obliczenie ogólnego wskaźnika bezpieczeństwa (0-100)
  const securityScore = Math.max(0, Math.min(100,
    enclosure.securityLevel * 10 - totalRisk + powerStatus + inspectionScore
  ));

  return {
    id: enclosure.id,
    name: enclosure.name,
    sector: enclosure.sector,
    dinosaurCount: enclosureDinosaurs.length,
    carnivoreCount: carnivores.length,
    securityLevel: enclosure.securityLevel,
    powerStatus: enclosure.powerStatus,
    securityScore,
    status: securityScore >= 80 ? 'secure' :
            securityScore >= 60 ? 'normal' :
            securityScore >= 40 ? 'warning' : 'danger',
    dinosaurs: enclosureDinosaurs.map(d => ({
      id: d.id,
      name: d.name,
      species: d.species,
      risk: d.riskAssessment ? d.riskAssessment.risk : 3
    }))
  };
}

// Pobieranie wszystkich wybiegów z oceną bezpieczeństwa
export async function getAllEnclosures() {
  try {
    const [enclosures, dinosaurs] = await Promise.all([
      getEnclosures(),
      getAllDinosaurs()
    ]);

    // Wzbogacamy dane o ocenę bezpieczeństwa
    return enclosures.map(enclosure =>
      assessSecurityStatus(enclosure, dinosaurs)
    );
  } catch (error) {
    console.error('Błąd podczas pobierania listy wybiegów:', error);
    throw error;
  }
}

// Pobieranie konkretnego wybiegu po ID
export async function getEnclosure(id) {
  try {
    const [enclosure, dinosaurs] = await Promise.all([
      getEnclosureById(id),
      getAllDinosaurs()
    ]);

    return assessSecurityStatus(enclosure, dinosaurs);
  } catch (error) {
    console.error(`Błąd podczas pobierania wybiegu ${id}:`, error);
    throw error;
  }
}

// Przeprowadzenie inspekcji wybiegu
export async function inspectEnclosure(id) {
  try {
    const enclosure = await getEnclosureById(id);

    // Aktualizacja daty ostatniej inspekcji
    const updatedEnclosure = await updateEnclosure(id, {
      lastInspection: new Date()
    });

    // Logowanie zdarzenia
    await logEvent('ENCLOSURE_INSPECTION', {
      enclosureId: id,
      name: enclosure.name,
      sector: enclosure.sector,
      previousInspection: enclosure.lastInspection
    });

    // Pobieramy dinozaury, aby zaktualizować ocenę bezpieczeństwa
    const dinosaurs = await getAllDinosaurs();

    return assessSecurityStatus(updatedEnclosure, dinosaurs);
  } catch (error) {
    console.error(`Błąd podczas inspekcji wybiegu ${id}:`, error);
    throw error;
  }
}

// Symulacja awarii systemu zasilania
export async function simulatePowerFailure() {
  try {
    const enclosures = await getEnclosures();

    // Wybieramy losowy wybieg
    const randomIndex = Math.floor(Math.random() * enclosures.length);
    const targetEnclosure = enclosures[randomIndex];

    if (targetEnclosure.powerStatus !== 'active') {
      // Wybieg już ma problem z zasilaniem
      return;
    }

    // 70% szans na przejście na zasilanie awaryjne, 30% na całkowitą awarię
    const newPowerStatus = Math.random() < 0.7 ? 'backup' : 'failure';

    // Aktualizacja stanu wybiegu
    const updatedEnclosure = await updateEnclosure(targetEnclosure.id, {
      powerStatus: newPowerStatus
    });

    // Logowanie zdarzenia
    await logEvent('POWER_FAILURE', {
      enclosureId: targetEnclosure.id,
      name: targetEnclosure.name,
      sector: targetEnclosure.sector,
      powerStatus: newPowerStatus
    });

    // Sprawdzenie, czy awaria może prowadzić do naruszenia wybiegu
    if (newPowerStatus === 'failure') {
      const dinosaurs = await getAllDinosaurs();
      const enclosureDinos = dinosaurs.filter(dino => dino.enclosureId === targetEnclosure.id);

      // Ocena ryzyka naruszenia (zależy od gatunków dinozaurów)
      const dangerousSpecies = ['Tyrannosaurus', 'Velociraptor', 'Spinosaurus'];
      const hasDangerousDinos = enclosureDinos.some(dino =>
        dangerousSpecies.includes(dino.species)
      );

      if (hasDangerousDinos && targetEnclosure.securityLevel >= 8) {
        // Wysokie ryzyko naruszenia wybiegu
        const breachingSpecies = enclosureDinos.find(dino =>
          dangerousSpecies.includes(dino.species)
        ).species;

        const breachingCount = enclosureDinos.filter(dino =>
          dino.species === breachingSpecies
        ).length;

        throw new EnclosureBreachError(
          targetEnclosure.sector,
          breachingSpecies,
          breachingCount
        );
      }
    }

    const dinosaurs = await getAllDinosaurs();
    return assessSecurityStatus(updatedEnclosure, dinosaurs);
  } catch (error) {
    if (error instanceof EnclosureBreachError) {
      // Logujemy zdarzenie naruszenia wybiegu
      await logEvent('ENCLOSURE_BREACH', {
        sector: error.sector,
        species: error.dinoSpecies,
        count: error.count,
        timestamp: error.timestamp
      });
      throw error; // Przekazujemy błąd dalej
    }

    console.error('Błąd podczas symulacji awarii zasilania:', error);
    throw error;
  }
}

// Naprawa systemu zasilania
export async function repairPowerSystem(id) {
  try {
    const enclosure = await getEnclosureById(id);

    if (enclosure.powerStatus === 'active') {
      throw new SecurityError(
        'System zasilania jest już aktywny',
        enclosure.sector,
        'power'
      );
    }

    // Aktualizacja stanu zasilania
    const updatedEnclosure = await updateEnclosure(id, {
      powerStatus: 'active'
    });

    // Logowanie zdarzenia
    await logEvent('POWER_RESTORED', {
      enclosureId: id,
      name: enclosure.name,
      sector: enclosure.sector,
      previousStatus: enclosure.powerStatus
    });

    // Pobieramy dinozaury, aby zaktualizować ocenę bezpieczeństwa
    const dinosaurs = await getAllDinosaurs();

    return assessSecurityStatus(updatedEnclosure, dinosaurs);
  } catch (error) {
    console.error(`Błąd podczas naprawy systemu zasilania wybiegu ${id}:`, error);
    throw error;
  }
}

5. Moduł monitorowania (monitoring.js)

Ten moduł będzie odpowiedzialny za ciągłe monitorowanie parku w tle:

// modules/monitoring.js
import { getAllDinosaurs, monitorBehavior, simulateBehaviorChange } from './dinosaurs.js';
import { getAllEnclosures, simulatePowerFailure } from './enclosures.js';
import { logEvent } from './api.js';
import { DinoBehaviorError, EnclosureBreachError } from '../errors/index.js';

// Przechowujemy identyfikatory interwałów, aby móc je później zatrzymać
const intervals = new Map();

// Aktywne alarmy
const activeAlerts = new Map();

// Rejestratory dla alertów
const alertListeners = [];

// Status systemu monitorowania
let monitoringStatus = 'idle'; // 'idle', 'running', 'error'

// Dodawanie listenera dla alertów
export function addAlertListener(callback) {
  alertListeners.push(callback);
  return function removeListener() {
    const index = alertListeners.indexOf(callback);
    if (index !== -1) {
      alertListeners.splice(index, 1);
      return true;
    }
    return false;
  };
}

// Generowanie alertu
function triggerAlert(alertType, data) {
  const alertId = `${alertType}-${Date.now()}`;
  const alert = {
    id: alertId,
    type: alertType,
    timestamp: new Date(),
    data,
    resolved: false
  };

  // Dodajemy do aktywnych alertów
  activeAlerts.set(alertId, alert);

  // Powiadamiamy wszystkich słuchaczy
  alertListeners.forEach(listener => {
    try {
      listener(alert);
    } catch (error) {
      console.error('Błąd w listenerze alertów:', error);
    }
  });

  return alertId;
}

// Oznaczanie alertu jako rozwiązanego
export function resolveAlert(alertId) {
  if (!activeAlerts.has(alertId)) {
    throw new Error(`Alert o ID ${alertId} nie istnieje`);
  }

  const alert = activeAlerts.get(alertId);
  alert.resolved = true;
  alert.resolutionTime = new Date();

  // Powiadamiamy wszystkich słuchaczy
  alertListeners.forEach(listener => {
    try {
      listener({ ...alert, status: 'resolved' });
    } catch (error) {
      console.error('Błąd w listenerze alertów:', error);
    }
  });

  // Po 5 minutach usuwamy rozwiązany alert z pamięci
  setTimeout(() => {
    activeAlerts.delete(alertId);
  }, 5 * 60 * 1000);

  return alert;
}

// Pobieranie wszystkich aktywnych alertów
export function getActiveAlerts() {
  return Array.from(activeAlerts.values())
    .filter(alert => !alert.resolved)
    .sort((a, b) => b.timestamp - a.timestamp);
}

// Uruchomienie monitorowania zachowań dinozaurów
function startDinoBehaviorMonitoring(interval = 60000) {
  if (intervals.has('dinoBehavior')) {
    clearInterval(intervals.get('dinoBehavior'));
  }

  // Funkcja monitorująca wszystkie dinozaury
  async function monitorAllDinosaurs() {
    try {
      const allDinos = await getAllDinosaurs();

      // Monitorujemy każdego dinozaura
      const monitorPromises = allDinos.map(dino =>
        monitorBehavior(dino.id).catch(error => {
          if (error instanceof DinoBehaviorError && error.requiresIntervention()) {
            // Generujemy alert dla niebezpiecznego zachowania
            triggerAlert('DANGEROUS_BEHAVIOR', {
              dinoId: error.dinoId,
              species: error.species,
              behavior: error.behaviorType,
              dangerLevel: error.dangerLevel,
              message: error.message
            });
          }
          return { error, dino };
        })
      );

      await Promise.all(monitorPromises);

      // Symulujemy losową zmianę zachowania (dla jednego dinozaura)
      if (Math.random() < 0.3) { // 30% szans na zmianę w każdym cyklu
        await simulateBehaviorChange();
      }

    } catch (error) {
      console.error('Błąd podczas monitorowania dinozaurów:', error);
      monitoringStatus = 'error';

      // Automatyczne ponowne uruchomienie po błędzie
      setTimeout(() => {
        if (monitoringStatus === 'error') {
          monitoringStatus = 'running';
        }
      }, 5000);
    }
  }

  // Pierwsze uruchomienie natychmiast
  monitorAllDinosaurs();

  // Następnie uruchamiamy cyklicznie
  const intervalId = setInterval(monitorAllDinosaurs, interval);
  intervals.set('dinoBehavior', intervalId);

  return intervalId;
}

// Uruchomienie monitorowania zabezpieczeń wybiegów
function startEnclosureMonitoring(interval = 90000) {
  if (intervals.has('enclosureSecurity')) {
    clearInterval(intervals.get('enclosureSecurity'));
  }

  // Funkcja monitorująca stan wybiegów
  async function monitorAllEnclosures() {
    try {
      const allEnclosures = await getAllEnclosures();

      // Sprawdzamy stan bezpieczeństwa każdego wybiegu
      for (const enclosure of allEnclosures) {
        if (enclosure.status === 'danger') {
          // Generujemy alert dla niebezpiecznego stanu wybiegu
          triggerAlert('ENCLOSURE_SECURITY', {
            enclosureId: enclosure.id,
            name: enclosure.name,
            sector: enclosure.sector,
            securityScore: enclosure.securityScore,
            powerStatus: enclosure.powerStatus,
            dinosaurCount: enclosure.dinosaurCount
          });
        }
      }

      // Symulujemy losowe awarie zasilania
      if (Math.random() < 0.2) { // 20% szans na awarię w każdym cyklu
        try {
          await simulatePowerFailure();
        } catch (error) {
          if (error instanceof EnclosureBreachError) {
            // Generujemy alert dla naruszenia wybiegu
            triggerAlert('ENCLOSURE_BREACH', {
              sector: error.sector,
              species: error.dinoSpecies,
              count: error.count,
              timestamp: error.timestamp,
              message: error.message
            });
          }
          throw error;
        }
      }

    } catch (error) {
      if (!(error instanceof EnclosureBreachError)) {
        console.error('Błąd podczas monitorowania wybiegów:', error);
        monitoringStatus = 'error';

        // Automatyczne ponowne uruchomienie po błędzie
        setTimeout(() => {
          if (monitoringStatus === 'error') {
            monitoringStatus = 'running';
          }
        }, 5000);
      }
    }
  }

  // Pierwsze uruchomienie po 10 sekundach (aby nie nakładało się z monitorowaniem dinozaurów)
  setTimeout(() => {
    monitorAllEnclosures();
  }, 10000);

  // Następnie uruchamiamy cyklicznie
  const intervalId = setInterval(monitorAllEnclosures, interval);
  intervals.set('enclosureSecurity', intervalId);

  return intervalId;
}

// Uruchomienie systemu monitorowania
export function startMonitoring(options = {}) {
  if (monitoringStatus === 'running') {
    console.log('System monitorowania jest już uruchomiony.');
    return;
  }

  monitoringStatus = 'running';

  // Ustawienia domyślne
  const settings = {
    dinoBehaviorInterval: 60000, // 1 minuta
    enclosureSecurityInterval: 90000, // 1.5 minuty
    ...options
  };

  // Uruchamiamy monitorowanie dinozaurów
  startDinoBehaviorMonitoring(settings.dinoBehaviorInterval);

  // Uruchamiamy monitorowanie wybiegów
  startEnclosureMonitoring(settings.enclosureSecurityInterval);

  // Logujemy uruchomienie
  logEvent('MONITORING_STARTED', {
    timestamp: new Date(),
    settings
  }).catch(error => console.error('Błąd podczas logowania zdarzenia:', error));

  return monitoringStatus;
}

// Zatrzymanie systemu monitorowania
export function stopMonitoring() {
  if (monitoringStatus !== 'running') {
    console.log('System monitorowania nie jest uruchomiony.');
    return;
  }

  // Zatrzymujemy wszystkie interwały
  for (const [name, intervalId] of intervals.entries()) {
    clearInterval(intervalId);
    intervals.delete(name);
  }

  monitoringStatus = 'idle';

  // Logujemy zatrzymanie
  logEvent('MONITORING_STOPPED', {
    timestamp: new Date()
  }).catch(error => console.error('Błąd podczas logowania zdarzenia:', error));

  return monitoringStatus;
}

// Zwracanie statusu systemu monitorowania
export function getMonitoringStatus() {
  return {
    status: monitoringStatus,
    activeMonitors: Array.from(intervals.keys()),
    alertsCount: getActiveAlerts().length
  };
}

6. Moduł pomocniczy (utils.js)

Ten moduł będzie zawierał przydatne funkcje pomocnicze:

// modules/utils.js

// Formatowanie daty
export function formatDate(date) {
  if (!date) return 'N/A';

  const d = new Date(date);
  if (isNaN(d.getTime())) return 'Invalid Date';

  return d.toLocaleString('pl-PL', {
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
    hour: '2-digit',
    minute: '2-digit',
    second: '2-digit'
  });
}

// Formatowanie czasu, który upłynął
export function formatTimeAgo(date) {
  if (!date) return 'N/A';

  const d = new Date(date);
  if (isNaN(d.getTime())) return 'Invalid Date';

  const now = new Date();
  const diffMs = now - d;

  if (diffMs < 0) return 'w przyszłości';

  const diffSec = Math.floor(diffMs / 1000);
  if (diffSec < 60) return `${diffSec} sek. temu`;

  const diffMin = Math.floor(diffSec / 60);
  if (diffMin < 60) return `${diffMin} min. temu`;

  const diffHour = Math.floor(diffMin / 60);
  if (diffHour < 24) return `${diffHour} godz. temu`;

  const diffDay = Math.floor(diffHour / 24);
  if (diffDay < 30) return `${diffDay} dni temu`;

  const diffMonth = Math.floor(diffDay / 30);
  if (diffMonth < 12) return `${diffMonth} mies. temu`;

  const diffYear = Math.floor(diffMonth / 12);
  return `${diffYear} lat temu`;
}

// Kolorowanie poziomu zagrożenia
export function getDangerLevelColor(level) {
  if (level <= 3) return 'green';
  if (level <= 5) return 'yellow';
  if (level <= 7) return 'orange';
  return 'red';
}

// Formatowanie poziomu zagrożenia jako tekst
export function formatDangerLevel(level) {
  if (level <= 2) return 'Niski';
  if (level <= 5) return 'Umiarkowany';
  if (level <= 7) return 'Podwyższony';
  if (level <= 9) return 'Wysoki';
  return 'Krytyczny';
}

// Retry utility - ponowne próby wykonania funkcji w przypadku awarii
export async function retry(fn, options = {}) {
  const {
    maxRetries = 3,
    delay = 1000,
    backoffFactor = 2,
    retryCondition = error => true
  } = options;

  let lastError;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      // Sprawdzamy, czy ten błąd kwalifikuje się do ponownej próby
      if (!retryCondition(error)) {
        throw error;
      }

      lastError = error;
      console.log(`Próba ${attempt}/${maxRetries} nie powiodła się. Powód: ${error.message}`);

      // Jeśli to była ostatnia próba, nie czekamy
      if (attempt === maxRetries) break;

      // Czekamy z opóźnieniem eksponencjalnym
      const waitTime = delay * Math.pow(backoffFactor, attempt - 1);
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }
  }

  throw lastError;
}

// Memoizacja funkcji (buforowanie wyników)
export function memoize(fn, { maxSize = 100, ttl = 60000 } = {}) {
  const cache = new Map();
  const timestamps = new Map();

  return async function(...args) {
    // Tworzymy klucz z argumentów
    const key = JSON.stringify(args);

    // Sprawdzamy, czy wynik jest w pamięci podręcznej i czy nie wygasł
    const now = Date.now();
    if (cache.has(key)) {
      const timestamp = timestamps.get(key);
      if (now - timestamp < ttl) {
        return cache.get(key);
      }
    }

    // Jeśli pamięć podręczna jest za duża, usuwamy najstarszy element
    if (cache.size >= maxSize) {
      let oldestKey = null;
      let oldestTime = now;

      for (const [key, time] of timestamps.entries()) {
        if (time < oldestTime) {
          oldestKey = key;
          oldestTime = time;
        }
      }

      if (oldestKey) {
        cache.delete(oldestKey);
        timestamps.delete(oldestKey);
      }
    }

    // Pobieramy wynik, dodajemy do pamięci podręcznej i zwracamy
    const result = await fn(...args);
    cache.set(key, result);
    timestamps.set(key, now);

    return result;
  };
}

7. Konfiguracja (config.js)

Plik konfiguracyjny dla naszej aplikacji:

// data/config.js

export const appConfig = {
  // Ogólne ustawienia aplikacji
  appName: 'Jurassic Tracker',
  version: '1.0.0',

  // Ustawienia monitorowania
  monitoring: {
    dinoBehaviorInterval: 60000, // Interwał monitorowania zachowań dinozaurów (ms)
    enclosureSecurityInterval: 90000, // Interwał monitorowania bezpieczeństwa wybiegów (ms)
    autoStart: true // Automatyczne uruchamianie monitorowania przy starcie
  },

  // Ustawienia API
  api: {
    baseUrl: 'https://jurassic-park-api.example.com', // W rzeczywistości używalibyśmy prawdziwego URL
    timeout: 10000, // Timeout dla żądań API (ms)
    retryCount: 3 // Liczba prób ponownego wykonania nieudanego żądania
  },

  // Ocena ryzyka dinozaurów
  dinorisk: {
    dangerousSpecies: ['Tyrannosaurus', 'Velociraptor', 'Spinosaurus', 'Allosaurus', 'Dilophosaurus'],
    behaviorRiskMatrix: {
      'calm': { base: 1, factor: 0.8 },
      'grazing': { base: 1, factor: 0.9 },
      'sleeping': { base: 2, factor: 0.7 },
      'exploring': { base: 4, factor: 1.0 },
      'agitated': { base: 6, factor: 1.2 },
      'hunting': { base: 7, factor: 1.5 },
      'aggressive': { base: 9, factor: 2.0 }
    },
    hungerRiskHours: 3, // Liczba godzin, po których głód zaczyna wpływać na ryzyko
    hungerRiskFactor: 0.5 // Współczynnik wpływu głodu na ryzyko
  },

  // Poziomy bezpieczeństwa dla powiadomień
  security: {
    alertThresholds: {
      low: 3,
      medium: 5,
      high: 7,
      critical: 9
    },
    autoResolveAlerts: false // Czy automatycznie oznaczać alerty jako rozwiązane
  }
};

export default appConfig;

8. Główny plik aplikacji (index.js)

Na koniec, zapiszmy główny plik naszej aplikacji, który łączy wszystkie moduły:

// index.js
import { appConfig } from './data/config.js';
import * as DinosaurService from './modules/dinosaurs.js';
import * as EnclosureService from './modules/enclosures.js';
import * as MonitoringService from './modules/monitoring.js';
import { formatDate, formatTimeAgo, formatDangerLevel, getDangerLevelColor } from './modules/utils.js';
import { APIError, DinoError, SecurityError, EnclosureBreachError } from './modules/errors/index.js';

console.log(`==========================================`);
console.log(`Witaj w ${appConfig.appName} v${appConfig.version}!`);
console.log(`Inicjalizacja systemów Parku Jurajskiego...`);
console.log(`==========================================`);

// Obsługa błędów na poziomie globalnym
process.on('unhandledRejection', (reason, promise) => {
  console.error('Nieobsłużone odrzucenie obietnicy:', reason);
});

process.on('uncaughtException', (error) => {
  console.error('Nieobsłużony wyjątek:', error);

  // Analiza typów błędów
  if (error instanceof EnclosureBreachError) {
    console.error(`KRYTYCZNY: Naruszenie wybiegu w sektorze ${error.sector}!`);
    console.error(`${error.count} ${error.dinoSpecies} poza wybiegiem!`);
    console.error('Uruchamianie protokołu awaryjnego...');
  } else if (error instanceof SecurityError) {
    console.error(`BEZPIECZEŃSTWO: Problem w sektorze ${error.sector}`);
  } else if (error instanceof DinoError) {
    console.error(`DINOZAUR: Problem z ${error.species} (ID: ${error.dinoId})`);
  } else if (error instanceof APIError) {
    console.error(`API: Błąd ${error.statusCode} podczas komunikacji z ${error.endpoint}`);
  }
});

// Główna funkcja startowa
async function initializeApp() {
  try {
    // Rejestrowanie listenera dla alertów
    const removeAlertListener = MonitoringService.addAlertListener(alert => {
      const { type, data, timestamp } = alert;

      console.log(`[ALERT] ${formatDate(timestamp)} - ${type}`);

      switch (type) {
        case 'DANGEROUS_BEHAVIOR':
          console.log(`Dinozaur ${data.species} (ID: ${data.dinoId}) wykazuje niebezpieczne zachowanie: ${data.behavior}`);
          console.log(`Poziom zagrożenia: ${formatDangerLevel(data.dangerLevel)}`);
          break;

        case 'ENCLOSURE_SECURITY':
          console.log(`Problem z bezpieczeństwem wybiegu ${data.name} (Sektor ${data.sector})`);
          console.log(`Wskaźnik bezpieczeństwa: ${data.securityScore}/100`);
          console.log(`Status zasilania: ${data.powerStatus}`);
          break;

        case 'ENCLOSURE_BREACH':
          console.log(`!!! NARUSZENIE WYBIEGU !!!`);
          console.log(`Sektor: ${data.sector}, Gatunek: ${data.species}, Liczba: ${data.count}`);
          console.log('UWAGA: Wymagana natychmiastowa interwencja!');
          break;

        default:
          console.log('Otrzymano alert:', data);
      }
    });

    // Pobieranie danych początkowych
    console.log('Pobieranie danych o dinozaurach...');
    const dinosaurs = await DinosaurService.getAllDinosaurs();
    console.log(`Załadowano dane ${dinosaurs.length} dinozaurów.`);

    console.log('Pobieranie danych o wybiegach...');
    const enclosures = await EnclosureService.getAllEnclosures();
    console.log(`Załadowano dane ${enclosures.length} wybiegów.`);

    // Uruchomienie monitorowania, jeśli jest włączone w konfiguracji
    if (appConfig.monitoring.autoStart) {
      console.log('Uruchamianie systemu monitorowania...');
      MonitoringService.startMonitoring({
        dinoBehaviorInterval: appConfig.monitoring.dinoBehaviorInterval,
        enclosureSecurityInterval: appConfig.monitoring.enclosureSecurityInterval
      });

      const status = MonitoringService.getMonitoringStatus();
      console.log(`Status monitorowania: ${status.status}`);
      console.log(`Aktywne monitory: ${status.activeMonitors.join(', ')}`);
    }

    console.log('\nSystemy Parku Jurajskiego zostały zainicjalizowane pomyślnie.');
    console.log('Rozpoczynam monitorowanie...');

    // Przykładowe wywołania API, które mogą zostać użyte przez użytkownika
    setTimeout(async () => {
      try {
        // Karmienie dinozaura
        const fedDino = await DinosaurService.feedDinosaur('trx1');
        console.log(`Nakarmiono ${fedDino.name} (${fedDino.species})`);

        // Inspekcja wybiegu
        const inspectedEnclosure = await EnclosureService.inspectEnclosure('enc2');
        console.log(`Przeprowadzono inspekcję wybiegu: ${inspectedEnclosure.name} (Sektor ${inspectedEnclosure.sector})`);

        // Naprawa systemu zasilania (jeśli jakiś wybieg ma problem)
        const enclosureWithPowerIssue = enclosures.find(e => e.powerStatus !== 'active');
        if (enclosureWithPowerIssue) {
          const repairedEnclosure = await EnclosureService.repairPowerSystem(enclosureWithPowerIssue.id);
          console.log(`Naprawiono system zasilania w: ${repairedEnclosure.name}`);
        }

      } catch (error) {
        console.error('Błąd podczas wykonywania operacji demonstracyjnych:', error);
      }
    }, 5000);

  } catch (error) {
    console.error('Błąd podczas inicjalizacji aplikacji:', error);

    if (error instanceof APIError) {
      console.error(`Nie można połączyć się z API: ${error.statusCode} ${error.message}`);
    } else {
      console.error('Nieoczekiwany błąd:', error.message);
    }

    console.error('Próba ponownej inicjalizacji za 10 sekund...');
    setTimeout(initializeApp, 10000);
  }
}

// Uruchomienie aplikacji
initializeApp();

// Funkcja do zatrzymania aplikacji przed zamknięciem
function cleanup() {
  console.log('\nZamykanie aplikacji...');

  // Zatrzymanie systemu monitorowania
  MonitoringService.stopMonitoring();

  console.log('Wszystkie systemy monitorowania zostały zatrzymane.');
  console.log('Do widzenia!');
  process.exit(0);
}

// Obsługa sygnałów zakończenia
process.on('SIGINT', cleanup);
process.on('SIGTERM', cleanup);

Uruchomienie aplikacji

W rzeczywistym środowisku moglibyśmy uruchomić tę aplikację za pomocą:

node index.js

Po uruchomieniu, aplikacja:

  1. Zainicjalizuje wszystkie systemy
  2. Pobierze dane o dinozaurach i wybiegach
  3. Uruchomi monitorowanie w tle
  4. Rozpocznie reagowanie na zdarzenia

Podsumowanie zastosowanych technik

W naszej aplikacji JurassicTracker wykorzystaliśmy wszystkie najważniejsze techniki poznane w tym module:

  1. ES Modules - Cała aplikacja jest zorganizowana w moduły, które importują i eksportują funkcjonalności
  2. Asynchroniczność:
    • Używamy async/await dla przejrzystej obsługi operacji asynchronicznych
    • Wykorzystujemy Promise.all dla równoległego wykonywania operacji
    • Obsługujemy opóźnienia i interwały czasowe
  3. Obsługa błędów:
    • Stworzyliśmy hierarchię własnych klas błędów (APIError, DinoError, SecurityError)
    • Używamy try/catch bloków dla lokalnej obsługi błędów
    • Zaimplementowaliśmy globalną obsługę nieobsłużonych błędów
    • Stosujemy technikę retry dla operacji, które mogą być ponowione
  4. Monitorowanie w tle:
    • Używamy setInterval do cyklicznego wykonywania zadań monitorowania
    • Implementujemy prosty system powiadomień oparty na wzorcu obserwatora (observer pattern)
  5. Zarządzanie stanem aplikacji:
    • Przechowujemy stan w zmiennych modułowych
    • Używamy Map dla efektywnego przechowywania danych
    • Implementujemy system buforowania (memoization) dla optymalizacji

Ta aplikacja pokazuje, jak można połączyć wszystkie poznane techniki w funkcjonalny, modularny i odporny na błędy system.

W rzeczywistej aplikacji webowej moglibyśmy dodać warstwę UI (React, Vue, Angular) oraz prawdziwe API backendowe, ale podstawowa struktura i organizacja kodu pozostałyby podobne.

Wnioski

Budowa złożonej aplikacji JavaScript wymaga dobrego zrozumienia:

  1. Modularyzacji kodu dla łatwiejszego utrzymania
  2. Asynchronicznych wzorców dla wydajnych operacji
  3. Obsługi błędów dla odpornej aplikacji
  4. Monitorowania i logowania dla diagnostyki

Nasz system JurassicTracker, choć jest przykładem dydaktycznym, pokazuje, jak te wszystkie elementy współpracują ze sobą, tworząc solidną aplikację, która mogłaby - z odpowiednimi rozszerzeniami - zostać wykorzystana w prawdziwym Parku Jurajskim. Miejmy jednak nadzieję, że jej systemy bezpieczeństwa działałyby lepiej niż w filmie!

W następnym ćwiczeniu zagłębimy się w strukturyzację kodu w jeszcze większych projektach JavaScript, rozszerzając poznane techniki i wzorce.

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. Jaka jest najlepsza praktyka organizacji modułów w projekcie JavaScript?

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz DinosaurDatabase z metodami i ParkMonitor z obsługą błędów.

  • Układanie w pionie

    Uporządkuj warstwy projektu od najniższej do najwyższej:

  1. PytanieModuły w strukturze projektu
  2. Zadanie z kodemPraktyka: System JurassicTracker
  3. Ułóż w kolejnościStruktura projektu JavaScript

Przydatne artykuły