Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Projekt końcowy: System diagnostyki Parku Jurajskiego
W tej lekcji4
Dotarłeś do końcowego projektu tego modułu! Przez ostatnie lekcje poznałeś narzędzia, które są fundamentem profesjonalnego programowania: modularyzację kodu, techniki debugowania, profilowanie wydajności oraz zaawansowaną obsługę błędów. Teraz nadszedł czas, aby wszystkie te umiejętności połączyć w jeden kompleksowy system.
Wyobraź sobie, że po serii incydentów w Parku Jurajskim - awariach ogrodzeń, przeciążeniach systemów zasilania i niewyjaśnionych błędach w oprogramowaniu sterującym - zarząd parku postanowił stworzyć zaawansowany system diagnostyczny. System ten ma wykrywać problemy zanim staną się katastrofalne, logować wszystkie zdarzenia, a w przypadku awarii - dostarczać szczegółowe raporty, które pomogą inżynierom szybko zlokalizować i naprawić usterki. Twoje zadanie: zaprojektować i zaimplementować ten system od podstaw.
W tym projekcie zbudujesz modularny system diagnostyczny z własnymi typami błędów, zaawansowaną obsługą wyjątków, systemem logowania i narzędziami do analizy wydajności.
Cel projektu
Stworzysz system diagnostyki Parku Jurajskiego składający się z czterech kluczowych modułów:
- Moduł błędów - własna hierarchia typów błędów dla systemów parku
- Moduł logowania - zaawansowany logger z poziomami i kontekstem
- Moduł diagnostyczny - skanowanie i testowanie podsystemów parku
- Moduł raportowania - generowanie szczegółowych raportów diagnostycznych
Wymagania funkcjonalne
1. Hierarchia błędów parku (Własne typy błędów)
Pierwszym krokiem jest stworzenie dedykowanej hierarchii błędów, która pozwoli precyzyjnie identyfikować rodzaj i źródło każdego problemu w parku.
// Bazowy błąd parku
class ParkError extends Error {
constructor(message, code, sector, severity) {
super(message);
this.name = "ParkError";
this.code = code;
this.sector = sector;
this.severity = severity; // "low", "medium", "high", "critical"
this.timestamp = new Date().toISOString();
this.resolved = false;
}
resolve() {
this.resolved = true;
this.resolvedAt = new Date().toISOString();
}
toReport() {
return {
type: this.name,
message: this.message,
code: this.code,
sector: this.sector,
severity: this.severity,
timestamp: this.timestamp,
resolved: this.resolved
};
}
}
// Błąd ogrodzenia - krytyczny dla bezpieczeństwa
class FenceError extends ParkError {
constructor(sector, fenceId, integrityLevel) {
const severity = integrityLevel < 50 ? "critical" : "high";
super(
`Ogrodzenie ${fenceId} w sektorze ${sector}: integralność ${integrityLevel}%`,
"FENCE_INTEGRITY",
sector,
severity
);
this.name = "FenceError";
this.fenceId = fenceId;
this.integrityLevel = integrityLevel;
}
}
// Błąd zasilania
class PowerError extends ParkError {
constructor(sector, powerLevel, isBackupActive) {
const severity = !isBackupActive && powerLevel < 20 ? "critical" : "medium";
super(
`Zasilanie w sektorze ${sector}: ${powerLevel}% - backup: ${isBackupActive ? "aktywny" : "nieaktywny"}`,
"POWER_FAILURE",
sector,
severity
);
this.name = "PowerError";
this.powerLevel = powerLevel;
this.isBackupActive = isBackupActive;
}
}
// Błąd czujników
class SensorError extends ParkError {
constructor(sector, sensorId, errorType) {
super(
`Czujnik ${sensorId} w sektorze ${sector}: ${errorType}`,
"SENSOR_MALFUNCTION",
sector,
"medium"
);
this.name = "SensorError";
this.sensorId = sensorId;
this.errorType = errorType;
}
}
// Błąd bezpieczeństwa - zawsze krytyczny
class SecurityBreachError extends ParkError {
constructor(sector, breachType, speciesInvolved) {
super(
`NARUSZENIE BEZPIECZEŃSTWA w ${sector}: ${breachType} - gatunek: ${speciesInvolved}`,
"SECURITY_BREACH",
sector,
"critical"
);
this.name = "SecurityBreachError";
this.breachType = breachType;
this.speciesInvolved = speciesInvolved;
}
}Każdy typ błędu niesie dodatkowe informacje kontekstowe, co ułatwia diagnostykę i naprawę problemu.
2. System logowania (Logger z poziomami)
Drugi moduł to profesjonalny system logowania, który rejestruje wszystkie zdarzenia z odpowiednim poziomem ważności i kontekstem.
// Poziomy logowania
const LogLevel = {
DEBUG: 0,
INFO: 1,
WARN: 2,
ERROR: 3,
FATAL: 4
};
const LogLevelNames = ["DEBUG", "INFO", "WARN", "ERROR", "FATAL"];
class ParkLogger {
constructor(moduleName, minLevel = LogLevel.DEBUG) {
this.moduleName = moduleName;
this.minLevel = minLevel;
this.logs = [];
this.maxLogs = 1000; // Limit przechowywanych logów
}
_log(level, message, context = {}) {
if (level < this.minLevel) return;
const entry = {
timestamp: new Date().toISOString(),
level: LogLevelNames[level],
module: this.moduleName,
message,
context
};
this.logs.push(entry);
// Rotacja logów - usuwanie najstarszych
if (this.logs.length > this.maxLogs) {
this.logs = this.logs.slice(-this.maxLogs);
}
// Formatowanie wyjścia
const prefix = `[${entry.timestamp}] [${entry.level}] [${this.moduleName}]`;
const contextStr = Object.keys(context).length > 0
? ` | ${JSON.stringify(context)}`
: "";
switch (level) {
case LogLevel.DEBUG: console.log(`${prefix} ${message}${contextStr}`); break;
case LogLevel.INFO: console.info(`${prefix} ${message}${contextStr}`); break;
case LogLevel.WARN: console.warn(`${prefix} ${message}${contextStr}`); break;
case LogLevel.ERROR: console.error(`${prefix} ${message}${contextStr}`); break;
case LogLevel.FATAL: console.error(`${prefix} ${message}${contextStr}`); break;
}
return entry;
}
debug(message, context) { return this._log(LogLevel.DEBUG, message, context); }
info(message, context) { return this._log(LogLevel.INFO, message, context); }
warn(message, context) { return this._log(LogLevel.WARN, message, context); }
error(message, context) { return this._log(LogLevel.ERROR, message, context); }
fatal(message, context) { return this._log(LogLevel.FATAL, message, context); }
// Filtrowanie logów po poziomie
getLogsByLevel(level) {
const levelName = LogLevelNames[level];
return this.logs.filter(log => log.level === levelName);
}
// Statystyki logów
getStats() {
const stats = { total: this.logs.length };
LogLevelNames.forEach(name => {
stats[name] = this.logs.filter(l => l.level === name).length;
});
return stats;
}
}Logger pozwala na filtrowanie po poziomie, przechowuje historię zdarzeń i automatycznie rotuje stare logi.
3. Moduł diagnostyczny (Skanowanie i try/catch/finally)
Trzeci moduł to serce systemu - skanuje poszczególne podsystemy parku, przechwytuje i klasyfikuje błędy, a następnie podejmuje odpowiednie działania naprawcze.
class ParkDiagnostics {
constructor() {
this.logger = new ParkLogger("Diagnostyka", LogLevel.DEBUG);
this.errors = [];
this.scanResults = [];
}
// Symulacja skanowania ogrodzenia
scanFence(sector, fenceId) {
this.logger.info(`Skanowanie ogrodzenia ${fenceId} w sektorze ${sector}`);
try {
const integrity = Math.round(40 + Math.random() * 60);
if (integrity < 80) {
throw new FenceError(sector, fenceId, integrity);
}
this.logger.debug(`Ogrodzenie ${fenceId} OK: ${integrity}%`, { sector, fenceId });
return { status: "OK", integrity };
} catch (error) {
if (error instanceof FenceError) {
this.errors.push(error);
this.logger.error(error.message, error.toReport());
if (error.severity === "critical") {
this.logger.fatal(`KRYTYCZNA awaria ogrodzenia! Ewakuacja sektora ${sector}!`);
this._initiateEmergencyProtocol(sector);
}
} else {
// Nieoczekiwany błąd - loguj i rzuć dalej
this.logger.fatal(`Nieoczekiwany błąd podczas skanowania: ${error.message}`);
throw error;
}
return { status: "AWARIA", error: error.toReport() };
} finally {
this.logger.debug(`Zakończono skanowanie ogrodzenia ${fenceId}`);
}
}
// Skanowanie zasilania z zagnieżdżonym try/catch
scanPower(sector) {
this.logger.info(`Skanowanie zasilania w sektorze ${sector}`);
try {
const mainPower = Math.round(Math.random() * 100);
let backupStatus = false;
try {
// Próba sprawdzenia zasilania awaryjnego
backupStatus = Math.random() > 0.3;
if (!backupStatus && mainPower < 30) {
throw new PowerError(sector, mainPower, false);
}
} catch (innerError) {
if (innerError instanceof PowerError) {
this.errors.push(innerError);
this.logger.error(`Problem z zasilaniem: ${innerError.message}`);
} else {
throw innerError; // Przekaż nieznane błędy do zewnętrznego catch
}
}
if (mainPower < 50) {
throw new PowerError(sector, mainPower, backupStatus);
}
return { status: "OK", mainPower, backupActive: backupStatus };
} catch (error) {
if (error instanceof PowerError) {
this.errors.push(error);
this.logger.warn(error.message, error.toReport());
return { status: "OSTRZEŻENIE", error: error.toReport() };
}
throw error;
}
}
// Pełna diagnostyka sektora
runFullDiagnostics(sector) {
this.logger.info(`=== Pełna diagnostyka sektora: ${sector} ===`);
const startTime = performance.now();
const result = {
sector,
fences: [],
power: null,
errors: [],
duration: 0
};
try {
// Skanowanie ogrodzeń (3 ogrodzenia per sektor)
for (let i = 1; i <= 3; i++) {
const fenceResult = this.scanFence(sector, `FENCE-${sector}-${i}`);
result.fences.push(fenceResult);
}
// Skanowanie zasilania
result.power = this.scanPower(sector);
} catch (unexpectedError) {
this.logger.fatal(`Nieoczekiwany błąd diagnostyki: ${unexpectedError.message}`);
result.criticalFailure = true;
} finally {
result.duration = `${(performance.now() - startTime).toFixed(2)}ms`;
result.errors = this.errors.filter(e => e.sector === sector).map(e => e.toReport());
this.scanResults.push(result);
this.logger.info(`Diagnostyka ${sector} zakończona w ${result.duration}`);
}
return result;
}
_initiateEmergencyProtocol(sector) {
this.logger.fatal(`PROTOKÓŁ AWARYJNY dla sektora ${sector} - wysyłanie powiadomień`);
}
}Zwróć uwagę na zagnieżdżone bloki try/catch i zastosowanie finally do rejestrowania czasu trwania operacji niezależnie od wyniku.
4. Moduł raportowania (Agregacja i analiza danych)
Ostatni moduł zbiera dane ze wszystkich diagnostyk i generuje czytelny raport z rekomendacjami.
class DiagnosticsReporter {
constructor(diagnostics) {
this.diagnostics = diagnostics;
this.logger = new ParkLogger("Raportowanie", LogLevel.INFO);
}
generateReport() {
const allErrors = this.diagnostics.errors;
const scanResults = this.diagnostics.scanResults;
// Grupowanie błędów po typie
const errorsByType = {};
allErrors.forEach(error => {
const type = error.name;
if (!errorsByType[type]) errorsByType[type] = [];
errorsByType[type].push(error.toReport());
});
// Grupowanie błędów po sektorze
const errorsBySector = {};
allErrors.forEach(error => {
if (!errorsBySector[error.sector]) errorsBySector[error.sector] = [];
errorsBySector[error.sector].push(error.toReport());
});
// Zliczanie po severity
const severityCounts = { low: 0, medium: 0, high: 0, critical: 0 };
allErrors.forEach(error => {
severityCounts[error.severity]++;
});
const report = {
generatedAt: new Date().toISOString(),
summary: {
totalErrors: allErrors.length,
criticalErrors: severityCounts.critical,
sectorsScanned: scanResults.length,
overallStatus: severityCounts.critical > 0 ? "KRYTYCZNY" :
severityCounts.high > 0 ? "OSTRZEŻENIE" : "STABILNY"
},
errorsByType,
errorsBySector,
severityCounts,
recommendations: this._generateRecommendations(allErrors, severityCounts)
};
this._printReport(report);
return report;
}
_generateRecommendations(errors, severity) {
const recommendations = [];
if (severity.critical > 0) {
recommendations.push("NATYCHMIAST: Ewakuacja sektorów z krytycznymi awariami ogrodzeń");
recommendations.push("Wysłanie zespołów naprawczych do uszkodzonych ogrodzeń");
}
if (severity.high > 0) {
recommendations.push("PILNE: Przegląd ogrodzeń z obniżoną integralnością");
}
const fenceErrors = errors.filter(e => e instanceof FenceError);
if (fenceErrors.length > 3) {
recommendations.push("Systemowy przegląd wszystkich ogrodzeń - wykryto liczne awarie");
}
const powerErrors = errors.filter(e => e instanceof PowerError);
if (powerErrors.length > 0) {
recommendations.push("Sprawdzenie generatorów awaryjnych we wszystkich sektorach");
}
if (recommendations.length === 0) {
recommendations.push("Wszystkie systemy stabilne - kontynuować standardowy monitoring");
}
return recommendations;
}
_printReport(report) {
console.log("\n" + "=".repeat(60));
console.log(" RAPORT DIAGNOSTYCZNY PARKU JURAJSKIEGO");
console.log("=".repeat(60));
console.log(`Wygenerowano: ${report.generatedAt}`);
console.log(`Status: ${report.summary.overallStatus}`);
console.log(`Sektory przeskanowane: ${report.summary.sectorsScanned}`);
console.log(`Wykryte błędy: ${report.summary.totalErrors} (krytycznych: ${report.summary.criticalErrors})`);
console.log("\nBłędy wg typu:");
Object.entries(report.errorsByType).forEach(([type, errors]) => {
console.log(` ${type}: ${errors.length}`);
});
console.log("\nRekomendacje:");
report.recommendations.forEach((rec, i) => {
console.log(` ${i + 1}. ${rec}`);
});
console.log("=".repeat(60));
}
}
// Uruchomienie systemu diagnostycznego
const diagnostics = new ParkDiagnostics();
const sectors = ["T-Rex-Paddock", "Raptor-Pen", "Herbivore-Valley"];
sectors.forEach(sector => diagnostics.runFullDiagnostics(sector));
const reporter = new DiagnosticsReporter(diagnostics);
reporter.generateReport();
// Statystyki loggera
console.log("\nStatystyki logów:", diagnostics.logger.getStats());Wskazówki implementacyjne
Przy budowaniu systemu diagnostycznego pamiętaj o następujących zasadach:
Hierarchia błędów powinna odzwierciedlać domenę:
// Każdy typ błędu = jeden rodzaj problemu w parku
ParkError // bazowy - ogólny błąd parku
├── FenceError // ogrodzenia - bezpieczeństwo fizyczne
├── PowerError // zasilanie - infrastruktura
├── SensorError // czujniki - monitoring
└── SecurityBreachError // naruszenia - najwyższy priorytetUżywaj instanceof do rozróżniania typów błędów:
try {
riskyOperation();
} catch (error) {
if (error instanceof SecurityBreachError) {
// Natychmiastowa reakcja
} else if (error instanceof FenceError) {
// Protokół naprawczy
} else if (error instanceof ParkError) {
// Ogólna obsługa błędów parku
} else {
// Nieznany błąd - loguj i eskaluj
throw error;
}
}Zawsze używaj finally do czyszczenia zasobów:
function scanWithCleanup() {
const connection = openConnection();
try {
return performScan(connection);
} catch (error) {
logError(error);
return null;
} finally {
// Zawsze zamknij połączenie - nawet przy błędzie
connection.close();
}
}Powodzenia!
Ten projekt to Twoja szansa na udowodnienie, że potrafisz budować odporne, dobrze zorganizowane systemy. W Parku Jurajskim nie ma miejsca na nieobsłużone wyjątki - każdy błąd musi być przechwycony, zalogowany i obsłużony, zanim sytuacja wymknie się spod kontroli. Jak mówił John Hammond: "Nie szczędziliśmy kosztów!" - a Ty nie szczędź wysiłku przy obsłudze błędów.
Stwórz swój system diagnostyczny w edytorze poniżej. Zaimplementuj własne typy błędów, system logowania i mechanizm diagnostyki przynajmniej dwóch podsystemów parku.
Kod do tej lekcji: index.js
// Projekt koncowy: System diagnostyki Parku Jurajskiego
// Polacz: moduly, obsluge bledow, try/catch, wlasne bledy
// === 1. HIERARCHIA BLEDOW ===
// TODO: Stworz klase ParkError rozszerzajaca Error
class ParkError extends Error {
constructor(message, code, sector, severity) {
super(message);
this.name = "ParkError";
// TODO: Przypisz code, sector, severity, timestamp
}
// TODO: Metoda toReport() zwracajaca obiekt raportu
}
// TODO: Stworz klasy pochodne: FenceError, PowerError, SystemError
class FenceError extends ParkError {
constructor(message, sector, fenceId) {
// TODO: Wywolaj super z odpowiednimi parametrami
}
}
// === 2. SYSTEM LOGOWANIA ===
// TODO: Stworz obiekt Logger z poziomami: debug, info, warn, error
const Logger = {
logs: [],
// TODO: Metody log(level, message, context)
// TODO: Metoda getLogsByLevel(level)
// TODO: Metoda exportLogs()
};
// === 3. MODUL DIAGNOSTYCZNY ===
// TODO: Stworz funkcje diagnostyczne uzywajace try/catch/finally
function scanSubsystem(subsystemName) {
// TODO: Symuluj skanowanie podsystemu
// TODO: Uzyj try/catch do przechwycenia bledow
// TODO: Uzyj finally do logowania zakonczenia skanu
}
// === 4. GENERATOR RAPORTOW ===
// TODO: Stworz funkcje generateDiagnosticReport()
// Zbierz dane ze wszystkich podsystemow
// Obsluz bledy kazdego podsystemu osobno
function generateDiagnosticReport() {
console.log("=== RAPORT DIAGNOSTYCZNY ===");
const subsystems = ["Ogrodzenia", "Zasilanie", "Monitoring", "Komunikacja"];
// TODO: Przeskanuj kazdy podsystem z obsluga bledow
console.log("=== KONIEC RAPORTU ===");
}
// Uruchom diagnostyke:
generateDiagnosticReport();Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?