Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne
Projekt końcowy: Asynchroniczny system monitoringu Parku Jurajskiego
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:
- Moduł czujników - symulacja odczytów z czujników (callbacki)
- Moduł komunikacji - wymiana danych między sektorami (Promise)
- Moduł analizy zagrożeń - przetwarzanie danych i klasyfikacja alertów (async/await)
- 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 startowyObsł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?