Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne
Model zdarzeń (event loop)
W tej lekcji8
Witaj ponownie w Parku Jurajskim! Do tej pory skupialiśmy się na podstawach programowania obiektowego - konstrukcji klas, dziedziczeniu i kompozycji. Jednak w realnych aplikacjach, takich jak system zarządzania parkiem pełnym dinozaurów, często musimy radzić sobie z operacjami, które zajmują dużo czasu - od pobierania danych z czujników w wybiegach, komunikacji z systemami bezpieczeństwa, po obsługę interakcji z gośćmi parku.
W tym module przejdziemy do kluczowego aspektu JavaScript: jego asynchronicznej natury i modelu zdarzeń, na którym się opiera. Zrozumienie tego mechanizmu jest niezbędne dla budowania responsywnych i wydajnych aplikacji, które mogą obsługiwać wiele operacji jednocześnie - co jest kluczowe dla bezpieczeństwa parku pełnego drapieżników!
JavaScript - język jednowątkowy z asynchronicznymi możliwościami
JavaScript jest językiem jednowątkowym (single-threaded). Oznacza to, że może wykonywać tylko jedną operację na raz. Jest to podobne do sytuacji, gdy masz tylko jednego pracownika do obsługi wszystkich zadań w parku.
Wyobraź sobie, że ten pracownik (wątek JavaScript) musi:
- Sprawdzać stan ogrodzeń
- Monitorować znaki życiowe dinozaurów
- Odpowiadać na komunikaty od gości
- Kontrolować systemy awaryjne
Gdyby wykonywał te zadania synchronicznie (jedno po drugim), musiałby całkowicie zakończyć jedno zadanie, zanim przejdzie do następnego. To byłoby niewydajne i potencjalnie niebezpieczne!
Na szczęście, JavaScript ma sprytny system zwany "event loop" (pętlą zdarzeń), który pozwala mu obsługiwać asynchroniczne operacje, mimo że jest jednowątkowy.
Event Loop - serce asynchronicznego JavaScript
Aby zrozumieć event loop, wyobraźmy sobie centrum kontroli Parku Jurajskiego. W tym centrum mamy:
- Stos wywołań (Call Stack) - lista aktualnie wykonywanych zadań (główne zadania naszego pracownika)
- Kolejka wywołań zwrotnych (Callback Queue) - lista zadań czekających na wykonanie po zakończeniu operacji asynchronicznych
- Web APIs (w przeglądarkach) lub C++ APIs (w Node.js) - zewnętrzne systemy, które mogą wykonywać zadania "w tle"
- Event Loop - mechanizm, który ciągle sprawdza, czy stos wywołań jest pusty, i jeśli tak, przenosi zadania z kolejki na stos
Zobaczmy, jak to działa na przykładzie zadań w Parku Jurajskim:
console.log("1. Rozpoczynam poranny obchód parku.");
setTimeout(() => {
console.log("4. Otrzymano dane z czujników wybiegów dinozaurów.");
}, 2000);
fetch('https://jurassic-park-api.com/security-status')
.then(response => response.json())
.then(data => {
console.log("5. Status systemów bezpieczeństwa:", data.status);
});
console.log("2. Sprawdzam listę pracowników na dzisiaj.");
console.log("3. Poranny obchód zakończony.");Jeśli uruchomimy ten kod, zobaczymy w konsoli:
1. Rozpoczynam poranny obchód parku.
2. Sprawdzam listę pracowników na dzisiaj.
3. Poranny obchód zakończony.
4. Otrzymano dane z czujników wybiegów dinozaurów.
5. Status systemów bezpieczeństwa: aktywnyCo się stało? Przeanalizujmy to krok po kroku:
console.log("1. Rozpoczynam poranny obchód parku.")jest dodawany do stosu wywołań, wykonywany i zdejmowany ze stosu.setTimeout(...)jest dodawany do stosu wywołań. JavaScript rozpoznaje, że to jest wywołanie asynchroniczne i przekazuje je do Web API, które startuje timer.setTimeoutjest zdejmowany ze stosu.fetch(...)jest dodawany do stosu wywołań. JavaScript rozpoznaje, że to jest wywołanie asynchroniczne i przekazuje je do Web API, które wysyła żądanie HTTP.fetchjest zdejmowany ze stosu.console.log("2. Sprawdzam listę pracowników na dzisiaj.")jest dodawany do stosu, wykonywany i zdejmowany.console.log("3. Poranny obchód zakończony.")jest dodawany do stosu, wykonywany i zdejmowany.Stos wywołań jest teraz pusty, ale mamy dwie operacje asynchroniczne w toku:
- Timer od
setTimeout - Żądanie HTTP od
fetch
- Timer od
Po 2 sekundach timer kończy odliczanie i callback z
setTimeoutjest dodawany do kolejki zadań (task queue).Event loop widzi, że stos wywołań jest pusty, więc przenosi callback z kolejki na stos.
console.log("4. Otrzymano dane z czujników wybiegów dinozaurów.")jest wykonywany i zdejmowany ze stosu.W międzyczasie żądanie HTTP się kończy, pobierane są dane i callback z
.then()jest dodawany do kolejki.Event loop znów przenosi callback z kolejki na stos.
Dane są przetwarzane i
console.log("5. Status systemów bezpieczeństwa:", data.status)jest wykonywany.
Event Loop - szczegółowa analiza
Aby lepiej zrozumieć event loop, narysujmy jego główne komponenty:
┌─────────────┐ ┌───────────┐ ┌───────────────────┐
│ │ │ │ │ │
│ Call Stack │ │ Web APIs │ │ Callback Queue │
│ │ │ │ │ │
└─────────────┘ └───────────┘ └───────────────────┘
↑ │ │
│ ↓ │
│ ┌────────┐ │
└────────────│ Event │←─────────────┘
│ Loop │
└────────┘W graficznej reprezentacji:
- Call Stack - Stos LIFO (Last In, First Out) przechowujący wywołania funkcji, które są obecnie wykonywane
- Web APIs - Interfejsy przeglądarki/środowiska dla operacji asynchronicznych (setTimeout, fetch, Event Listeners)
- Callback Queue - Kolejka FIFO (First In, First Out) przechowująca callbacki, które są gotowe do wykonania
- Event Loop - Ciągłe sprawdzanie, czy stos wywołań jest pusty, i jeśli tak, przenoszenie funkcji z kolejki na stos
Zadziwiające jest to, że cały ten proces działa na jednym wątku! JavaScript nie wykonuje tych zadań równolegle, ale przełącza się między nimi w taki sposób, że wydaje się, jakby wszystko działo się jednocześnie.
Mikrozadania i makrozadania
W nowszych implementacjach JavaScript (i specyfikacji) rozróżniamy dwa rodzaje kolejek:
- Kolejka mikrozadań (Microtask Queue) - dla zadań o wyższym priorytecie, jak Promise callbacks
- Kolejka makrozadań (Macrotask Queue/Task Queue) - dla zadań o niższym priorytecie, jak setTimeout, setInterval, I/O
Kiedy stos jest pusty, najpierw wykonywane są wszystkie zadania z kolejki mikrozadań, dopiero potem z kolejki makrozadań.
console.log("1. Rozpoczynam poranne karmienie dinozaurów.");
// Makrozadanie (setTimeout)
setTimeout(() => {
console.log("4. Sprawdzam stan zdrowia dinozaurów.");
}, 0);
// Mikrozadanie (Promise)
Promise.resolve().then(() => {
console.log("3. Odczyt danych z systemu bezpieczeństwa.");
});
console.log("2. Przygotowuję pokarm dla drapieżników.");Wynik:
1. Rozpoczynam poranne karmienie dinozaurów.
2. Przygotowuję pokarm dla drapieżników.
3. Odczyt danych z systemu bezpieczeństwa.
4. Sprawdzam stan zdrowia dinozaurów.Zauważ, że choć oba zadania asynchroniczne (setTimeout z czasem 0ms i Promise.resolve()) są gotowe do wykonania niemal natychmiast, Promise (mikrozadanie) jest wykonywany przed setTimeout (makrozadaniem).
Blokowanie Event Loop
Ponieważ JavaScript jest jednowątkowy, długotrwałe operacje mogą "zablokować" event loop, zatrzymując wykonywanie innych zadań. To jak sytuacja, gdy pracownik centrum kontroli utknął przy jednym monitorze i nie może sprawdzić pozostałych systemów.
console.log("Uruchamiam symulację wzrostu dinozaurów...");
// Funkcja blokująca wykonywanie przez 5 sekund
function heavyComputation() {
const startTime = Date.now();
while (Date.now() - startTime < 5000) {
// Intensywne obliczenia...
}
}
heavyComputation();
console.log("Symulacja zakończona!"); // Po 5 sekundach
// Ten kod nie wykona się przez 5 sekund, nawet jeśli jest asynchroniczny!
setTimeout(() => {
console.log("Sprawdzam systemy bezpieczeństwa...");
}, 1000);W tym przykładzie funkcja heavyComputation() blokuje wątek JavaScript na 5 sekund. W tym czasie żadne inne zadania nie mogą być wykonywane, nawet te asynchroniczne. To jak sytuacja, gdy pracownik parku utknął w jednym zadaniu i nie może reagować na alarmy czy inne ważne sygnały.
W prawdziwym Parku Jurajskim takie blokowanie mogłoby być katastrofalne - raptor mógłby uciec, a system nie zarejestrowałby tego, bo jest zajęty czymś innym!
Dlatego w JavaScript staramy się:
- Unikać długich operacji synchronicznych
- Dzielić złożone obliczenia na mniejsze części
- Wykorzystywać Web Workers do operacji intensywnie wykorzystujących CPU
Kolejność wykonywania zadań - praktyczny przykład
Przeanalizujmy bardziej złożony przykład, który pokazuje kolejność wykonywania różnych typów zadań w Parku Jurajskim:
// Symulacja systemu kontroli Parku Jurajskiego
console.log("1. Uruchamianie systemu kontroli Parku Jurajskiego...");
// Makrozadanie (setTimeout)
setTimeout(() => {
console.log("6. Sprawdzanie ogrodzeń elektrycznych...");
// Zagnieżdżone mikrozadanie w makrozadaniu
Promise.resolve().then(() => {
console.log("7. Weryfikacja stanu drapieżników...");
});
}, 0);
// Mikrozadanie (Promise)
Promise.resolve().then(() => {
console.log("3. Inicjalizacja kamer bezpieczeństwa...");
// Zagnieżdżone mikrozadanie
Promise.resolve().then(() => {
console.log("4. Kalibracja czujników ruchu...");
});
});
// Kolejne mikrozadanie
Promise.resolve().then(() => {
console.log("5. Uruchamianie protokołów awaryjnych...");
});
// Synchroniczny kod
console.log("2. Sprawdzanie statusu systemów...");Wynik:
1. Uruchamianie systemu kontroli Parku Jurajskiego...
2. Sprawdzanie statusu systemów...
3. Inicjalizacja kamer bezpieczeństwa...
4. Kalibracja czujników ruchu...
5. Uruchamianie protokołów awaryjnych...
6. Sprawdzanie ogrodzeń elektrycznych...
7. Weryfikacja stanu drapieżników...Ten przykład pokazuje, że:
- Najpierw wykonywany jest kod synchroniczny (1, 2)
- Następnie wykonywane są wszystkie zadania z kolejki mikrozadań (3, 4, 5)
- Dopiero potem wykonywane są zadania z kolejki makrozadań (6)
- Mikrozadania stworzone podczas wykonywania makrozadania (7) są wykonywane natychmiast po zakończeniu bieżącego makrozadania
Bonus: Var, Let, Const - kiedy używać którego?
Przy pracy z kodem asynchronicznym ważne jest, aby poprawnie deklarować zmienne. Sposób deklaracji wpływa na ich zachowanie w blokach i funkcjach, co ma bezpośredni wpływ na kod asynchroniczny (np. zmienne w pętlach z setTimeout). Podobnie jak w parku mamy różne rodzaje ogrodzeń dla różnych typów dinozaurów (elektryczne dla T-Rexa, standardowe dla Triceratopsa), w JavaScript mamy różne sposoby deklarowania zmiennych: var, let i const.
Const - zawsze domyślny wybór
const oznacza stałą - wartość, która nie może być ponownie przypisana. W Parku Jurajskim używamy const dla rzeczy, które nie powinny się zmieniać, jak parametry bezpieczeństwa czy konfiguracja systemów:
// Konfiguracja systemu - nie powinna się zmieniać
const MAX_DINOSAURS_PER_ENCLOSURE = 5;
const FENCE_MINIMUM_VOLTAGE = 10000; // wolty
const EMERGENCY_CONTACT = "+1-555-JURASSIC";
// Próba zmiany const spowoduje błąd
MAX_DINOSAURS_PER_ENCLOSURE = 10; // TypeError: Assignment to constant variableKiedy używać const:
- Dla wartości, które nie będą zmieniane
- Dla obiektów i tablic (nawet jeśli ich zawartość się zmienia)
- Jako domyślny wybór - jeśli nie jesteś pewien, użyj
const
Ważne: const nie oznacza niezmienności zawartości obiektu lub tablicy!
// To jest poprawne - modyfikujemy zawartość, nie przypisanie
const dinosaurs = [];
dinosaurs.push({ name: "Rexy", species: "T-Rex" }); // OK!
dinosaurs.push({ name: "Blue", species: "Velociraptor" }); // OK!
const parkConfig = {
openTime: "09:00",
closeTime: "18:00"
};
parkConfig.closeTime = "20:00"; // OK - modyfikujemy właściwość
// To spowoduje błąd - próbujemy ponownie przypisać
dinosaurs = []; // TypeError!
parkConfig = {}; // TypeError!Let - gdy wartość się zmienia
let używamy, gdy wartość zmiennej będzie się zmieniać w trakcie wykonania programu. W Parku Jurajskim używamy let dla rzeczy dynamicznych, jak liczniki, akumulatory czy zmienne pętli:
// Licznik odwiedzających - zmienia się w ciągu dnia
let visitorCount = 0;
function addVisitors(count) {
visitorCount += count;
console.log(`Aktualna liczba odwiedzających: ${visitorCount}`);
}
addVisitors(50); // 50
addVisitors(30); // 80
addVisitors(20); // 100Kiedy używać let:
- W pętlach (for, while)
- Dla liczników i akumulatorów
- Gdy wartość będzie ponownie przypisywana
// Pętle - klasyczny przypadek użycia let
for (let i = 0; i < 5; i++) {
console.log(`Sprawdzam dinozaura nr ${i}`);
}
// Akumulatory
let totalFeedingCost = 0;
const dinosaurs = [
{ name: "Rexy", dailyFoodCost: 500 },
{ name: "Blue", dailyFoodCost: 150 },
{ name: "Trixie", dailyFoodCost: 200 }
];
for (const dino of dinosaurs) {
totalFeedingCost += dino.dailyFoodCost;
}
console.log(`Całkowity koszt karmienia: $${totalFeedingCost}`);Var - prawie nigdy (legacy code)
var to stary sposób deklarowania zmiennych w JavaScript. Ma problematyczne zachowanie i nie powinien być używany w nowoczesnym kodzie. Jedyny czas, gdy zobaczysz var, to w starym kodzie (legacy), który został napisany przed 2015 rokiem (przed ES6).
Problemy z var:
- Function scope zamiast block scope -
var"wydostaje się" z bloków
// Problem: var ignoruje bloki
function checkDinosaur(isDangerous) {
if (isDangerous) {
var alert = "NIEBEZPIECZEŃSTWO!"; // var jest dostępny poza if!
}
console.log(alert); // "NIEBEZPIECZEŃSTWO!" - przecieka poza if!
// Z let/const dostalibyśmy ReferenceError
}
checkDinosaur(true);
// Porównaj z let:
function checkDinosaurProper(isDangerous) {
if (isDangerous) {
let alert = "NIEBEZPIECZEŃSTWO!";
}
console.log(alert); // ReferenceError: alert is not defined
}- Hoisting z undefined -
varjest "podnoszony" na górę funkcji
// Dziwne zachowanie var
function feedDinosaurs() {
console.log(food); // undefined (nie ReferenceError!)
var food = "meat";
console.log(food); // "meat"
}
// To jest interpretowane jako:
function feedDinosaurs() {
var food; // hoisting - deklaracja na górze
console.log(food); // undefined
food = "meat"; // przypisanie
console.log(food); // "meat"
}- Można redekla rować - można przypadkowo nadpisać zmienne
var dinosaurName = "Rexy";
// Przypadkowo używamy tej samej nazwy
var dinosaurName = "Blue"; // Brak błędu! Nadpisało poprzednią wartość
console.log(dinosaurName); // "Blue" - Rexy zniknął!
// Z let/const:
let dinoName = "Rexy";
let dinoName = "Blue"; // SyntaxError: Identifier 'dinoName' has already been declaredKiedy używać var:
- Nigdy w nowym kodzie
- Tylko gdy edytujesz bardzo stary kod i musisz zachować kompatybilność
Praktyczny przykład - Code Review
Wyobraź sobie, że dostajesz kod od kolegi do przejrzenia. Oto jak poprawić użycie zmiennych:
Zły kod (przed):
// Źle - wszystko na var
var parkName = "Jurassic Park"; // Nie zmienia się - powinno być const
var isOpen = true; // Zmienia się - powinno być let
var maxCapacity = 10000; // Nie zmienia się - powinno być const
function processVisitors() {
var totalVisitors = 0; // Akumulator - powinno być let
for (var i = 0; i < 100; i++) { // Iterator - powinno być let
totalVisitors++;
}
console.log(i); // 100 - var przecieka! Problem!
return totalVisitors;
}Dobry kod (po):
// Dobrze - używamy const jako domyślnego
const parkName = "Jurassic Park";
const maxCapacity = 10000;
// let tylko gdy wartość się zmienia
let isOpen = true;
function processVisitors() {
// let dla akumulatora
let totalVisitors = 0;
// let w pętli - block scoped
for (let i = 0; i < 100; i++) {
totalVisitors++;
}
// console.log(i); // ReferenceError - i jest w scope pętli
return totalVisitors;
}
// Możemy zmieniać isOpen
isOpen = false;
isOpen = true;
// Ale nie możemy zmienić const
// parkName = "Dino World"; // TypeError!Kolejny przykład - System zarządzania dinozaurami
class DinosaurManagementSystem {
constructor() {
// const dla właściwości, które nie zmieniają referencji
this.dinosaurs = []; // tablica może się zmieniać, ale referencja nie
this.config = { // obiekt może się zmieniać, ale referencja nie
maxDinosaurs: 50,
securityLevel: "high"
};
}
addDinosaur(name, species, dangerLevel) {
// const dla parametrów funkcji i lokalnych wartości, które się nie zmieniają
const newDinosaur = {
id: Date.now(),
name,
species,
dangerLevel,
status: "active"
};
this.dinosaurs.push(newDinosaur);
return newDinosaur;
}
getDangerousCount() {
// let dla akumulatora
let count = 0;
// const w for...of gdy nie modyfikujemy zmiennej pętli
for (const dino of this.dinosaurs) {
if (dino.dangerLevel > 7) {
count++; // modyfikujemy count, dlatego let
}
}
return count;
}
calculateDailyFoodCost() {
// let dla wartości, które się zmieniają
let totalCost = 0;
// let w klasycznej pętli for
for (let i = 0; i < this.dinosaurs.length; i++) {
const dino = this.dinosaurs[i]; // const - nie zmieniamy referencji
// const dla wartości obliczonych
const dailyCost = this.calculateDinosaurFoodCost(dino);
totalCost += dailyCost;
}
return totalCost;
}
calculateDinosaurFoodCost(dinosaur) {
// const dla wszystkich wartości, które się nie zmieniają
const baseCost = 50;
const costMultiplier = dinosaur.dangerLevel > 5 ? 2 : 1;
const dailyCost = baseCost * costMultiplier;
return dailyCost;
}
}
// Przykład użycia
const parkSystem = new DinosaurManagementSystem(); // const - referencja się nie zmienia
parkSystem.addDinosaur("Rexy", "T-Rex", 9);
parkSystem.addDinosaur("Blue", "Velociraptor", 8);
parkSystem.addDinosaur("Trixie", "Triceratops", 3);
// let dla wartości, które będą się zmieniać
let dangerousCount = parkSystem.getDangerousCount();
console.log(`Niebezpieczne dinozaury: ${dangerousCount}`);
// const dla wartości jednorazowego użycia
const foodCost = parkSystem.calculateDailyFoodCost();
console.log(`Dzienny koszt jedzenia: $${foodCost}`);
// Możemy dodać więcej dinozaurów
parkSystem.addDinosaur("Delta", "Velociraptor", 8);
// I ponownie obliczyć
dangerousCount = parkSystem.getDangerousCount(); // let pozwala na zmianę
console.log(`Niebezpieczne dinozaury: ${dangerousCount}`);Zasada kciuka (Rule of Thumb)
- Zawsze zaczyń od
const- jeśli kompilator/linter narzeka, że próbujesz zmienić wartość, zmień nalet - Użyj
lettylko gdy musisz - pętle, liczniki, akumulatory - Nigdy nie używaj
var- chyba że edytujesz stary kod
// Dobra praktyka
const maxDinosaurs = 50;
let currentDinosaurs = 0;
for (let i = 0; i < maxDinosaurs; i++) {
const dinosaur = createDinosaur();
currentDinosaurs++;
}
// Zła praktyka
var maxDinosaurs = 50;
var currentDinosaurs = 0;
for (var i = 0; i < maxDinosaurs; i++) {
var dinosaur = createDinosaur();
currentDinosaurs++;
}Dlaczego to ważne?
Podobnie jak prawidłowe ogrodzenia w Parku Jurajskim zapobiegają ucieczkom dinozaurów, prawidłowe używanie const i let zapobiega błędom w kodzie:
- Czytelność - widzisz natychmiast, które wartości się zmieniają (
let) a które nie (const) - Bezpieczeństwo -
constchroni przed przypadkową modyfikacją - Block scope - zmienne nie "przeciekają" z bloków
- Łatwiejsze debugowanie - mniej niespodzianek z hoistingiem
Zapamiętaj: w nowoczesnym JavaScript, var to jak dinozaury - interesujący relikt przeszłości, ale nie chcesz go w swoim produkcyjnym kodzie!
Podsumowanie
Model zdarzeń JavaScript (event loop) jest kluczem do zrozumienia, jak ten jednowątkowy język może obsługiwać wiele operacji asynchronicznych, co jest niezbędne w aplikacjach takich jak system zarządzania Parkiem Jurajskim.
Pamiętaj kluczowe zasady:
- JavaScript jest jednowątkowy, ale asynchroniczny
- Event loop pozwala na obsługę wielu zadań bez blokowania interfejsu użytkownika
- Zadania są wykonywane w określonej kolejności: synchroniczne → mikrozadania → makrozadania
- Unikaj blokowania event loop długimi operacjami synchronicznymi
W kolejnych lekcjach zobaczymy, jak wykorzystać tę wiedzę do pisania wydajnego kodu asynchronicznego za pomocą callbacków, Promises i async/await.
Kod do tej lekcji: index.js
// Event Loop i asynchroniczność w Parku Jurajskim
console.log("Centrum Kontroli Parku Jurajskiego - Event Loop Demo");
console.log("Symulacja systemu asynchronicznego zarządzania parkiem\n");
// ===========================================
// 1. Podstawy Event Loop - Call Stack
// ===========================================
console.log("=== 1. CALL STACK - Kolejność wykonywania ===");
function sprawdzOgrodzenie() {
console.log("1. Sprawdzam ogrodzenie T-Rexa...");
return "Ogrodzenie bezpieczne";
}
function sprawdzDinozaura() {
console.log("2. Sprawdzam stan dinozaura...");
const wynik = sprawdzOgrodzenie(); // Synchroniczne wywołanie
console.log("3. " + wynik);
return "Dinozaur bezpieczny";
}
function raportBezpieczenstwa() {
console.log("0. Rozpoczynam raport bezpieczeństwa");
const status = sprawdzDinozaura();
console.log("4. Raport: " + status);
}
// Synchroniczne wykonanie - call stack
raportBezpieczenstwa();
// ===========================================
// 2. setTimeout - Callback Queue
// ===========================================
console.log("\n=== 2. SETTIMEOUT - Asynchroniczne operacje ===");
console.log("A. Rozpoczynam monitorowanie parku...");
setTimeout(() => {
console.log("C. Alarm! Wykryto ruch w zagrodzie T-Rexa!");
}, 2000);
setTimeout(() => {
console.log("D. System automatyczny: Aktywowano dodatkowe zabezpieczenia");
}, 1000);
console.log("B. Kontynuuję inne zadania...");
// ===========================================
// 3. Symulacja czujników parku
// ===========================================
console.log("\n=== 3. SYMULACJA CZUJNIKÓW PARKU ===");
class DinosaurSensor {
constructor(nazwa, dinozaur) {
this.nazwa = nazwa;
this.dinozaur = dinozaur;
this.isActive = true;
}
sprawdzStatus(callback) {
console.log(`Czujnik ${this.nazwa}: Sprawdzam ${this.dinozaur}...`);
// Symulacja opóźnienia czujnika
const delay = Math.random() * 3000 + 1000; // 1-4 sekundy
setTimeout(() => {
const status = Math.random() > 0.8 ? 'ALARM' : 'BEZPIECZNY';
const raport = {
czujnik: this.nazwa,
dinozaur: this.dinozaur,
status: status,
czas: new Date().toLocaleTimeString()
};
callback(raport);
}, delay);
}
}
// Callback hell - problem z zagnieżdżonymi callbackami
function monitorujPark() {
console.log("\nRozpoczynam monitoring parku...");
const czujnikTRex = new DinosaurSensor("TR-001", "T-Rex");
const czujnikVelociraptor = new DinosaurSensor("VR-002", "Velociraptor");
const czujnikTriceratops = new DinosaurSensor("TC-003", "Triceratops");
// Callback hell - każdy czujnik po kolei
czujnikTRex.sprawdzStatus((raportTRex) => {
console.log("Raport T-Rex:", raportTRex);
czujnikVelociraptor.sprawdzStatus((raportVelo) => {
console.log("Raport Velociraptor:", raportVelo);
czujnikTriceratops.sprawdzStatus((raportTrice) => {
console.log("Raport Triceratops:", raportTrice);
// Analiza wszystkich raportów
const raporty = [raportTRex, raportVelo, raportTrice];
const alarmy = raporty.filter(r => r.status === 'ALARM');
if (alarmy.length > 0) {
console.log("UWAGA! Wykryto alarmy:", alarmy.length);
alarmy.forEach(alarm => {
console.log(` ${alarm.dinozaur} - ${alarm.status}`);
});
} else {
console.log("Wszystkie dinozaury bezpieczne");
}
});
});
});
}
// Uruchom monitoring po 3 sekundach
setTimeout(monitorujPark, 3000);
// ===========================================
// 4. Promises - rozwiązanie Callback Hell
// ===========================================
console.log("\n=== 4. PROMISES - Lepsze zarządzanie asynchronicznością ===");
class ModernSensor {
constructor(nazwa, dinozaur) {
this.nazwa = nazwa;
this.dinozaur = dinozaur;
}
sprawdzStatus() {
return new Promise((resolve, reject) => {
console.log(`Promise: Sprawdzam ${this.dinozaur}...`);
const delay = Math.random() * 2000 + 500;
setTimeout(() => {
const success = Math.random() > 0.1; // 90% szans na sukces
if (success) {
const status = Math.random() > 0.7 ? 'ALARM' : 'BEZPIECZNY';
resolve({
czujnik: this.nazwa,
dinozaur: this.dinozaur,
status: status,
czas: new Date().toLocaleTimeString()
});
} else {
reject(new Error(`Czujnik ${this.nazwa} nie odpowiada`));
}
}, delay);
});
}
}
function monitorujParkPromises() {
console.log("\nPromise-based monitoring...");
const modernTRex = new ModernSensor("MTR-001", "Modern T-Rex");
const modernVelo = new ModernSensor("MVR-002", "Modern Velociraptor");
const modernTrice = new ModernSensor("MTC-003", "Modern Triceratops");
// Promise chain
modernTRex.sprawdzStatus()
.then(raport => {
console.log("Promise T-Rex:", raport);
return modernVelo.sprawdzStatus();
})
.then(raport => {
console.log("Promise Velociraptor:", raport);
return modernTrice.sprawdzStatus();
})
.then(raport => {
console.log("Promise Triceratops:", raport);
console.log("Wszystkie Promise czujniki sprawdzone!");
})
.catch(error => {
console.log("Błąd w Promise chain:", error.message);
});
// Promise.all - wszystkie jednocześnie
console.log("\nPromise.all - równoległe sprawdzanie...");
Promise.all([
modernTRex.sprawdzStatus(),
modernVelo.sprawdzStatus(),
modernTrice.sprawdzStatus()
])
.then(raporty => {
console.log("Wszystkie Promise.all raporty gotowe:");
raporty.forEach(raport => {
console.log(` ${raport.dinozaur}: ${raport.status}`);
});
const alarmy = raporty.filter(r => r.status === 'ALARM');
if (alarmy.length > 0) {
console.log(`Promise.all: ${alarmy.length} alarmów!`);
} else {
console.log("Promise.all: Park bezpieczny!");
}
})
.catch(error => {
console.log("Promise.all error:", error.message);
});
}
// Uruchom Promise monitoring po 8 sekundach
setTimeout(monitorujParkPromises, 8000);
// ===========================================
// 5. Async/Await - najczystszy sposób
// ===========================================
console.log("\n=== 5. ASYNC/AWAIT - Nowoczesny asynchroniczny JavaScript ===");
class AsyncSensor {
constructor(nazwa, dinozaur) {
this.nazwa = nazwa;
this.dinozaur = dinozaur;
}
async sprawdzStatus() {
console.log(`Async: Sprawdzam ${this.dinozaur}...`);
const delay = Math.random() * 1500 + 500;
// Async/await z Promise
return new Promise((resolve, reject) => {
setTimeout(() => {
const success = Math.random() > 0.05; // 95% sukcesu
if (success) {
const status = Math.random() > 0.6 ? 'ALARM' : 'BEZPIECZNY';
resolve({
czujnik: this.nazwa,
dinozaur: this.dinozaur,
status: status,
czas: new Date().toLocaleTimeString(),
delay: delay.toFixed(0) + 'ms'
});
} else {
reject(new Error(`Async czujnik ${this.nazwa} error`));
}
}, delay);
});
}
}
// Async function
async function monitorujParkAsync() {
console.log("\nAsync/Await monitoring started...");
try {
const asyncTRex = new AsyncSensor("ATR-001", "Async T-Rex");
const asyncVelo = new AsyncSensor("AVR-002", "Async Velociraptor");
const asyncTrice = new AsyncSensor("ATC-003", "Async Triceratops");
// Sekwencyjnie (jeden po drugim)
console.log("Sekwencyjne sprawdzanie:");
const raportTRex = await asyncTRex.sprawdzStatus();
console.log(" Async T-Rex:", raportTRex);
const raportVelo = await asyncVelo.sprawdzStatus();
console.log(" Async Velociraptor:", raportVelo);
const raportTrice = await asyncTrice.sprawdzStatus();
console.log(" Async Triceratops:", raportTrice);
// Równolegle z Promise.all
console.log("\nRównoległe sprawdzanie async/await:");
const [raportT2, raportV2, raportTr2] = await Promise.all([
asyncTRex.sprawdzStatus(),
asyncVelo.sprawdzStatus(),
asyncTrice.sprawdzStatus()
]);
const wszystkieRaporty = [raportT2, raportV2, raportTr2];
console.log("Wyniki równoległe:");
wszystkieRaporty.forEach(raport => {
console.log(` ${raport.dinozaur}: ${raport.status} (${raport.delay})`);
});
// Analiza bezpieczeństwa
const niebezpieczne = wszystkieRaporty.filter(r => r.status === 'ALARM');
if (niebezpieczne.length > 0) {
console.log(`\nASYNC ALERT: ${niebezpieczne.length} dinozaurów wymaga uwagi!`);
niebezpieczne.forEach(dino => {
console.log(` ${dino.dinozaur} - wymagana interwencja`);
});
} else {
console.log("\nASYNC SUCCESS: Wszystkie dinozaury pod kontrolą!");
}
} catch (error) {
console.log("Async/await error:", error.message);
}
}
// Uruchom async monitoring po 15 sekundach
setTimeout(monitorujParkAsync, 15000);
// ===========================================
// 6. Event Loop w praktyce - Mikrotaski vs Makrotaski
// ===========================================
console.log("\n=== 6. EVENT LOOP - Kolejność wykonywania ===");
function demonstracjaEventLoop() {
console.log("\nEvent Loop demo - kolejność wykonywania:");
console.log("1. Synchroniczny kod");
setTimeout(() => {
console.log("4. setTimeout (Macro task)");
}, 0);
Promise.resolve().then(() => {
console.log("3. Promise.then (Micro task)");
});
console.log("2. Synchroniczny kod - koniec");
// Kolejność: 1, 2, 3, 4
// Microtasks (Promise) mają wyższy priorytet niż macrotasks (setTimeout)
}
demonstracjaEventLoop();
// ===========================================
// 7. Praktyczny przykład - System alertów parku
// ===========================================
console.log("\n=== 7. SYSTEM ALERTÓW PARKU ===");
class ParkAlertSystem {
constructor() {
this.alerts = [];
this.isMonitoring = false;
}
async startMonitoring() {
this.isMonitoring = true;
console.log("System alertów rozpoczął monitoring...");
while (this.isMonitoring) {
await this.sprawdzSystemy();
await this.czekaj(2000); // Sprawdzaj co 2 sekundy
}
}
stopMonitoring() {
this.isMonitoring = false;
console.log("⏹Monitoring zatrzymany");
}
async sprawdzSystemy() {
const systemy = ['ogrodzenia', 'zasilanie', 'komunikacja', 'bezpieczeństwo'];
const obietnice = systemy.map(system => this.sprawdzSystem(system));
try {
const wyniki = await Promise.allSettled(obietnice);
wyniki.forEach((wynik, index) => {
const systemName = systemy[index];
if (wynik.status === 'fulfilled') {
if (wynik.value.status === 'ALARM') {
this.dodajAlert(systemName, wynik.value.message);
}
} else {
this.dodajAlert(systemName, `Błąd systemu: ${wynik.reason}`);
}
});
if (this.alerts.length > 0) {
this.wyswietlAlertyIWyczysc();
}
} catch (error) {
console.log("Krytyczny błąd monitoringu:", error);
}
}
async sprawdzSystem(system) {
const delay = Math.random() * 1000 + 200;
return new Promise((resolve, reject) => {
setTimeout(() => {
const isWorking = Math.random() > 0.2; // 80% szans na działanie
if (isWorking) {
const hasAlert = Math.random() > 0.8; // 20% szans na alert
resolve({
system,
status: hasAlert ? 'ALARM' : 'OK',
message: hasAlert ? `Problem z systemem ${system}` : `System ${system} działa poprawnie`
});
} else {
reject(`System ${system} nie odpowiada`);
}
}, delay);
});
}
dodajAlert(system, message) {
this.alerts.push({
system,
message,
time: new Date().toLocaleTimeString()
});
}
wyswietlAlertyIWyczysc() {
console.log(`\nALERT PARKU (${this.alerts.length} problemów):`);
this.alerts.forEach(alert => {
console.log(` [${alert.time}] ${alert.system}: ${alert.message}`);
});
this.alerts = []; // Wyczyść po wyświetleniu
}
async czekaj(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
}
// Test systemu alertów
const alertSystem = new ParkAlertSystem();
// Uruchom system po 20 sekundach na 10 sekund
setTimeout(async () => {
await alertSystem.startMonitoring();
// Zatrzymaj po 10 sekundach
setTimeout(() => {
alertSystem.stopMonitoring();
}, 10000);
}, 20000);
// ===========================================
// 8. Podsumowanie Event Loop
// ===========================================
setTimeout(() => {
console.log("\n" + "=".repeat(50));
console.log("PODSUMOWANIE EVENT LOOP:");
console.log("1. JavaScript jest jednowątkowy");
console.log("2. Event Loop pozwala na asynchroniczność");
console.log("3. Callbacks → Promises → Async/Await");
console.log("4. Microtasks mają wyższy priorytet niż Macrotasks");
console.log("5. Async/Await to najczystsza składnia");
console.log("=".repeat(50));
}, 35000);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. Co to jest Event Loop w JavaScript?