Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne

Projekt końcowy: Asynchroniczny system monitoringu Parku Jurajskiego

8 min czytania ·
W tej lekcji4

Gratulacje, dotarłeś do końcowego projektu tego modułu! Przez cały czas uczyłeś się o asynchroniczności w JavaScript - od callbacków, przez Promise, aż po eleganckie async/await. Teraz nadszedł czas, aby połączyć wszystkie te umiejętności w jeden, spójny system.

Wyobraź sobie, że zarząd Parku Jurajskiego zlecił Ci stworzenie centralnego systemu monitoringu, który w czasie rzeczywistym zbiera dane ze wszystkich sektorów parku, analizuje zagrożenia i koordynuje reakcje na incydenty. System musi obsługiwać wiele operacji jednocześnie - od odczytów z czujników ruchu w wybiegach raptorów, przez monitoring systemów zasilania, po komunikację z zespołami terenowymi. Każda z tych operacji trwa różną ilość czasu i może zakończyć się niepowodzeniem - a w parku pełnym dinozaurów nie ma miejsca na nieobsłużone błędy!

W tym projekcie zbudujesz kompletny system monitoringu, wykorzystując callbacki, Promise, async/await, obsługę błędów oraz równoległe wykonywanie operacji asynchronicznych.

Cel projektu

Stworzysz asynchroniczny system monitoringu Parku Jurajskiego składający się z czterech podsystemów:

  1. Moduł czujników - symulacja odczytów z czujników (callbacki)
  2. Moduł komunikacji - wymiana danych między sektorami (Promise)
  3. Moduł analizy zagrożeń - przetwarzanie danych i klasyfikacja alertów (async/await)
  4. Centralny koordynator - równoległe zarządzanie wszystkimi podsystemami (Promise.all/race/allSettled)

Wymagania funkcjonalne

1. Moduł czujników (Callbacki)

Pierwszy podsystem to warstwa niskopoziomowa, która symuluje odczyty z czujników rozmieszczonych w całym parku. Używamy callbacków, ponieważ reprezentują one najstarszy wzorzec asynchroniczny - podobnie jak stare systemy w parku, które działają na starszej technologii.

// Symulacja odczytu z czujnika - używamy callbacków
function readSensor(sensorId, sectorName, callback) {
  const delay = Math.random() * 2000 + 500; // 0.5-2.5 sekundy

  setTimeout(() => {
    // 15% szans na awarię czujnika
    if (Math.random() < 0.15) {
      callback(new Error(`Czujnik ${sensorId} w sektorze ${sectorName} nie odpowiada`), null);
      return;
    }

    const sensorData = {
      sensorId,
      sector: sectorName,
      timestamp: new Date().toISOString(),
      temperature: Math.round(20 + Math.random() * 25),
      motion: Math.random() > 0.5,
      fenceIntegrity: Math.round(70 + Math.random() * 30),
      powerLevel: Math.round(50 + Math.random() * 50)
    };

    callback(null, sensorData);
  }, delay);
}

// Odczyt wielu czujników z jednego sektora - callback hell
function scanSector(sectorName, sensorCount, callback) {
  const results = [];
  const errors = [];
  let completed = 0;

  for (let i = 1; i <= sensorCount; i++) {
    readSensor(`SENSOR-${sectorName}-${i}`, sectorName, (error, data) => {
      completed++;

      if (error) {
        errors.push(error.message);
      } else {
        results.push(data);
      }

      // Gdy wszystkie czujniki odpowiedziały
      if (completed === sensorCount) {
        callback({
          sector: sectorName,
          successfulReads: results,
          failedReads: errors,
          scanCompletedAt: new Date().toISOString()
        });
      }
    });
  }
}

Zwróć uwagę na wzorzec "callback counter" - zliczamy zakończone operacje i wywołujemy finalny callback dopiero gdy wszystkie się zakończą.

2. Moduł komunikacji (Promise)

Drugi podsystem odpowiada za komunikację między sektorami parku. Zamiast callbacków używamy Promise, co pozwala na czytelniejsze łańcuchowanie operacji i lepszą obsługę błędów.

// Konwersja callbacka na Promise (promisyfikacja)
function readSensorAsync(sensorId, sectorName) {
  return new Promise((resolve, reject) => {
    readSensor(sensorId, sectorName, (error, data) => {
      if (error) reject(error);
      else resolve(data);
    });
  });
}

// Wysyłanie alertu do centrum dowodzenia
function sendAlert(alertData) {
  return new Promise((resolve, reject) => {
    const delay = Math.random() * 1000 + 200;

    setTimeout(() => {
      if (Math.random() < 0.1) {
        reject(new Error(`Nie udało się wysłać alertu: system komunikacji przeciążony`));
        return;
      }

      resolve({
        alertId: `ALERT-${Date.now()}`,
        status: "wysłany",
        data: alertData,
        confirmedAt: new Date().toISOString()
      });
    }, delay);
  });
}

// Łańcuch Promise - odczyt, analiza, alert
function monitorAndAlert(sensorId, sectorName) {
  return readSensorAsync(sensorId, sectorName)
    .then(sensorData => {
      console.log(`Odczyt z ${sensorId}: temp=${sensorData.temperature}°C, ogrodzenie=${sensorData.fenceIntegrity}%`);

      // Analiza danych - czy jest zagrożenie?
      if (sensorData.fenceIntegrity < 80 || sensorData.motion) {
        return {
          level: sensorData.fenceIntegrity < 75 ? "KRYTYCZNY" : "OSTRZEŻENIE",
          sensor: sensorId,
          sector: sectorName,
          details: sensorData
        };
      }
      return null; // Brak zagrożenia
    })
    .then(threat => {
      if (threat) {
        return sendAlert(threat);
      }
      return { status: "brak zagrożeń", sensor: sensorId };
    })
    .catch(error => {
      console.error(`Błąd monitoringu ${sensorId}: ${error.message}`);
      return { status: "błąd", sensor: sensorId, error: error.message };
    })
    .finally(() => {
      console.log(`Zakończono cykl monitoringu dla ${sensorId}`);
    });
}

Zauważ, jak .then(), .catch() i .finally() tworzą czytelny przepływ danych z pełną obsługą błędów.

3. Moduł analizy zagrożeń (async/await)

Trzeci podsystem to warstwa analityczna, która przetwarza dane z czujników i klasyfikuje zagrożenia. Używamy async/await dla maksymalnej czytelności kodu.

// Klasyfikacja poziomu zagrożenia
async function classifyThreat(sectorData) {
  // Symulacja czasu przetwarzania AI
  await new Promise(resolve => setTimeout(resolve, 300));

  const { successfulReads, failedReads } = sectorData;

  const avgFenceIntegrity = successfulReads.reduce(
    (sum, s) => sum + s.fenceIntegrity, 0
  ) / successfulReads.length;

  const motionDetected = successfulReads.filter(s => s.motion).length;
  const sensorFailures = failedReads.length;

  let threatLevel = "ZIELONY"; // Bezpiecznie
  const warnings = [];

  if (avgFenceIntegrity < 75) {
    threatLevel = "CZERWONY";
    warnings.push(`Krytyczny stan ogrodzeń: ${avgFenceIntegrity.toFixed(1)}%`);
  } else if (avgFenceIntegrity < 85) {
    threatLevel = "ŻÓŁTY";
    warnings.push(`Obniżona integralność ogrodzeń: ${avgFenceIntegrity.toFixed(1)}%`);
  }

  if (motionDetected > successfulReads.length * 0.6) {
    threatLevel = "CZERWONY";
    warnings.push(`Intensywny ruch wykryty w ${motionDetected} czujnikach`);
  }

  if (sensorFailures > 2) {
    warnings.push(`${sensorFailures} czujników nie odpowiada - możliwa sabotaż!`);
    if (threatLevel !== "CZERWONY") threatLevel = "ŻÓŁTY";
  }

  return {
    sector: sectorData.sector,
    threatLevel,
    warnings,
    avgFenceIntegrity: avgFenceIntegrity.toFixed(1),
    activeSensors: successfulReads.length,
    failedSensors: sensorFailures,
    motionDetections: motionDetected,
    analyzedAt: new Date().toISOString()
  };
}

// Główna funkcja analizy sektora z obsługą błędów
async function analyzeSector(sectorName, sensorCount) {
  console.log(`\nRozpoczynam analizę sektora: ${sectorName}`);

  try {
    // Skanowanie sektora (konwersja callbacka na Promise)
    const scanResult = await new Promise((resolve) => {
      scanSector(sectorName, sensorCount, resolve);
    });

    console.log(`Skan zakończony: ${scanResult.successfulReads.length} odczytów, ${scanResult.failedReads.length} błędów`);

    // Klasyfikacja zagrożenia
    const analysis = await classifyThreat(scanResult);

    // Jeśli zagrożenie, wyślij alert
    if (analysis.threatLevel !== "ZIELONY") {
      try {
        const alertResult = await sendAlert({
          type: "ANALIZA_SEKTORA",
          ...analysis
        });
        console.log(`Alert wysłany: ${alertResult.alertId}`);
        analysis.alertSent = true;
        analysis.alertId = alertResult.alertId;
      } catch (alertError) {
        console.error(`Nie udało się wysłać alertu: ${alertError.message}`);
        analysis.alertSent = false;
        analysis.alertError = alertError.message;
      }
    }

    return analysis;

  } catch (error) {
    console.error(`Krytyczny błąd analizy sektora ${sectorName}: ${error.message}`);
    return {
      sector: sectorName,
      threatLevel: "NIEZNANY",
      error: error.message,
      analyzedAt: new Date().toISOString()
    };
  }
}

Zauważ zagnieżdżony try/catch - zewnętrzny blok obsługuje krytyczne błędy analizy, a wewnętrzny pozwala na kontynuację nawet gdy wysyłanie alertu się nie powiedzie.

4. Centralny koordynator (Promise.all / race / allSettled)

Ostatni podsystem to serce systemu monitoringu. Koordynuje równoległe skanowanie wszystkich sektorów parku i podejmuje decyzje na podstawie zagregowanych danych.

// Konfiguracja sektorów parku
const parkSectors = [
  { name: "T-Rex-Paddock", sensors: 5 },
  { name: "Raptor-Pen", sensors: 4 },
  { name: "Herbivore-Valley", sensors: 6 },
  { name: "Aviary", sensors: 3 },
  { name: "Marine-Exhibit", sensors: 4 }
];

// Pełne skanowanie parku - wszystkie sektory równolegle
async function fullParkScan() {
  console.log("=== ROZPOCZYNAM PEŁNE SKANOWANIE PARKU ===\n");
  const startTime = Date.now();

  // Promise.allSettled - kontynuuj nawet jeśli jeden sektor zawiedzie
  const sectorPromises = parkSectors.map(
    sector => analyzeSector(sector.name, sector.sensors)
  );

  const results = await Promise.allSettled(sectorPromises);

  const report = {
    scanDuration: `${((Date.now() - startTime) / 1000).toFixed(1)}s`,
    sectors: [],
    overallStatus: "ZIELONY"
  };

  results.forEach((result, index) => {
    if (result.status === "fulfilled") {
      report.sectors.push(result.value);
      if (result.value.threatLevel === "CZERWONY") {
        report.overallStatus = "CZERWONY";
      } else if (result.value.threatLevel === "ŻÓŁTY" && report.overallStatus !== "CZERWONY") {
        report.overallStatus = "ŻÓŁTY";
      }
    } else {
      report.sectors.push({
        sector: parkSectors[index].name,
        threatLevel: "BŁĄD",
        error: result.reason?.message || "Nieznany błąd"
      });
      report.overallStatus = "CZERWONY";
    }
  });

  return report;
}

// Skanowanie z limitem czasu - Promise.race
async function timedScan(sectorName, sensorCount, timeoutMs) {
  const scanPromise = analyzeSector(sectorName, sensorCount);

  const timeoutPromise = new Promise((_, reject) => {
    setTimeout(() => {
      reject(new Error(`Timeout: skan sektora ${sectorName} przekroczył ${timeoutMs}ms`));
    }, timeoutMs);
  });

  try {
    return await Promise.race([scanPromise, timeoutPromise]);
  } catch (error) {
    return {
      sector: sectorName,
      threatLevel: "TIMEOUT",
      error: error.message,
      analyzedAt: new Date().toISOString()
    };
  }
}

// Uruchomienie pełnego skanowania i wyświetlenie raportu
async function runParkMonitoring() {
  try {
    const report = await fullParkScan();

    console.log("\n=== RAPORT KOŃCOWY ===");
    console.log(`Czas skanowania: ${report.scanDuration}`);
    console.log(`Status ogólny: ${report.overallStatus}`);
    console.log("\nSektory:");

    report.sectors.forEach(sector => {
      const icon = sector.threatLevel === "ZIELONY" ? "OK" :
                   sector.threatLevel === "ŻÓŁTY" ? "!" :
                   sector.threatLevel === "CZERWONY" ? "!!" : "?";
      console.log(`  ${icon} ${sector.sector}: ${sector.threatLevel}`);

      if (sector.warnings?.length > 0) {
        sector.warnings.forEach(w => console.log(`     → ${w}`));
      }
    });

    if (report.overallStatus === "CZERWONY") {
      console.log("\nUWAGA: Wykryto krytyczne zagrożenia! Uruchomienie protokołu awaryjnego.");
    }

    return report;
  } catch (error) {
    console.error("Krytyczny błąd systemu monitoringu:", error.message);
  }
}

// Start systemu
runParkMonitoring();

Wskazówki implementacyjne

Przy tworzeniu własnego systemu monitoringu pamiętaj o kilku kluczowych zasadach:

Struktura plików:

// sensors.js      - moduł czujników (callbacki)
// communication.js - moduł komunikacji (Promise)
// analysis.js     - moduł analizy (async/await)
// coordinator.js  - centralny koordynator (Promise.all/race/allSettled)
// main.js         - punkt startowy

Obsługa błędów na każdym poziomie:

// Poziom 1: Callback - error-first pattern
function callbackOperation(callback) {
  // callback(error, data) - zawsze sprawdzaj error
}

// Poziom 2: Promise - .catch() na końcu łańcucha
promiseOperation()
  .then(result => process(result))
  .catch(error => handleError(error));

// Poziom 3: async/await - try/catch z finally
async function asyncOperation() {
  try {
    const result = await riskyOperation();
    return result;
  } catch (error) {
    logError(error);
    return fallbackValue;
  } finally {
    cleanup();
  }
}

Wybór metody Promise dla różnych scenariuszy:

// Wszystkie muszą się udać → Promise.all()
const allResults = await Promise.all([task1(), task2()]);

// Kontynuuj mimo błędów → Promise.allSettled()
const mixedResults = await Promise.allSettled([task1(), task2()]);

// Najszybszy wygrywa → Promise.race()
const fastest = await Promise.race([task1(), timeout(5000)]);

// Pierwszy sukces → Promise.any()
const firstSuccess = await Promise.any([server1(), server2()]);

Powodzenia!

Ten projekt to Twoja szansa na pokazanie, że opanowałeś asynchroniczność w JavaScript. Podobnie jak w prawdziwym Parku Jurajskim, Twój system musi być odporny na awarie, szybki w reakcji i zdolny do obsługi wielu operacji jednocześnie. Pamiętaj słowa Dr. Iana Malcolma: "Życie znajduje drogę" - a Twój kod musi być na to przygotowany!

Stwórz swój system monitoringu w edytorze poniżej. Zaimplementuj przynajmniej trzy z czterech podsystemów i upewnij się, że system prawidłowo obsługuje błędy oraz wyświetla czytelny raport końcowy.

Kod do tej lekcji: index.js
// Projekt koncowy: Asynchroniczny system monitoringu
// Polacz: callbacki, Promise, async/await, obsluge bledow

// === 1. MODUL CZUJNIKOW (Callbacki) ===
// TODO: Stworz funkcje readSensor(sensorId, sectorName, callback)
// Symuluje odczyt z czujnika z opoznieniem (setTimeout)
function readSensor(sensorId, sectorName, callback) {
  setTimeout(() => {
    // TODO: 15% szans na blad czujnika
    // TODO: Zwroc dane: sensorId, sector, temperature, motion, fenceIntegrity
    const data = {
      sensorId,
      sector: sectorName,
      timestamp: new Date().toISOString(),
      // TODO: Dodaj losowe wartosci czujnikow
    };
    callback(null, data);
  }, Math.random() * 1000 + 500);
}

// === 2. MODUL KOMUNIKACJI (Promise) ===
// TODO: Stworz funkcje sendAlert(sector, message) zwracajaca Promise
function sendAlert(sector, message) {
  // TODO: Zwroc new Promise ktory rozwiazuje sie po opoznieniu
  // Symuluj 10% szans na blad komunikacji
}

// === 3. MODUL ANALIZY ZAGROZEN (async/await) ===
// TODO: Stworz async funkcje analyzeThreat(sectorData)
async function analyzeThreat(sectorData) {
  // TODO: Uzyj await do pobrania danych
  // TODO: Uzyj try/catch do obslugi bledow
  // TODO: Klasyfikuj zagrozenie: "critical", "warning", "normal"
}

// === 4. CENTRALNY KOORDYNATOR ===
// TODO: Stworz async funkcje runParkMonitoring()
// Uzyj Promise.all do rownoleglego skanowania wielu sektorow
async function runParkMonitoring() {
  console.log("=== URUCHAMIANIE MONITORINGU ===");
  const sectors = ["A-1", "B-2", "C-3"];

  // TODO: Uzyj Promise.allSettled do skanowania wszystkich sektorow
  // TODO: Wyswietl raport z wynikami

  console.log("=== MONITORING ZAKONCZONY ===");
}

// Uruchom system:
runParkMonitoring();

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. Projekt do wysłaniaUkończenie modułu: Programowanie asynchroniczne
  2. WideoVideo: Podsumowanie modułu

Przydatne artykuły