Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne
Składnia async/await
W tej lekcji12
W poprzednich ćwiczeniach poznaliśmy Promisy oraz metody ich składania, które znacznie ułatwiają pracę z kodem asynchronicznym. Jednak JavaScript oferuje jeszcze bardziej elegancką i czytelną składnię do obsługi asynchroniczności: async/await.
Składnia async/await, wprowadzona w ECMAScript 2017 (ES8), działa na bazie Promisów, ale pozwala pisać kod asynchroniczny w sposób, który wygląda jak synchroniczny. Dzięki temu nasz kod staje się bardziej czytelny i łatwiejszy w utrzymaniu - co jest niezwykle ważne przy zarządzaniu tak skomplikowanym przedsięwzięciem jak Park Jurajski!
Podstawy async/await
Składnia async/await składa się z dwóch głównych elementów:
- Słowo kluczowe async - używane przed deklaracją funkcji, oznacza, że funkcja zawsze zwróci Promise
- Słowo kluczowe await - używane wewnątrz funkcji async, wstrzymuje wykonanie funkcji do czasu rozwiązania Promise
Funkcje async
Zobaczmy, jak wygląda prosta funkcja async:
// Funkcja tradycyjna zwracająca Promise
function pobierzDinozaura(id) {
return new Promise((resolve, reject) => {
setTimeout(() => {
if (id > 0 && id <= 100) {
resolve({
id: id,
name: `Dino-${id}`,
species: id % 2 === 0 ? "Tyrannosaurus" : "Velociraptor",
health: "Good"
});
} else {
reject(new Error(`Dinozaur o ID ${id} nie istnieje`));
}
}, 1000);
});
}
// Funkcja async pobierająca dane dinozaura
async function pobierzDaneDinozaura(id) {
console.log(`Rozpoczynam pobieranie danych dinozaura #${id}...`);
// Używamy await do "czekania" na wynik Promisa
const dinozaur = await pobierzDinozaura(id);
console.log(`Pobrano dane dinozaura: ${dinozaur.name}`);
return dinozaur;
}
// Wywołanie funkcji async
pobierzDaneDinozaura(42)
.then(dino => {
console.log("Otrzymane dane:", dino);
})
.catch(error => {
console.error("Wystąpił błąd:", error.message);
});Oto, co dzieje się w powyższym kodzie:
- Deklarujemy funkcję
pobierzDaneDinozaura()ze słowem kluczowymasync, co oznacza, że będzie ona zawsze zwracać Promise - Wewnątrz tej funkcji używamy
awaitprzed wywołaniempobierzDinozaura(id), co powoduje, że wykonanie funkcji zostanie wstrzymane do czasu rozwiązania Promise - Kiedy Promise zostanie rozwiązany, kod będzie kontynuował wykonywanie od miejsca, w którym został wstrzymany, a zmiennej
dinozaurzostanie przypisana rozwiązana wartość Promise - Ponieważ funkcja async zawsze zwraca Promise, możemy użyć metod
.then()i.catch()przy wywołaniupobierzDaneDinozaura()
Porównanie tradycyjnego podejścia z Promise i async/await
Porównajmy te same funkcjonalności, zaimplementowane z użyciem tradycyjnej składni Promise oraz async/await:
// Z użyciem tradycyjnych Promise
function sprawdźSystemyBezpieczeństwa() {
console.log("Sprawdzanie systemów bezpieczeństwa...");
return pobierzStatusBram()
.then(statusBram => {
console.log("Status bram:", statusBram.allClosed ? "Wszystkie zamknięte" : "UWAGA! Niektóre otwarte");
return pobierzStatusOgrodzenia();
})
.then(statusOgrodzenia => {
console.log("Ogrodzenie:", statusOgrodzenia.power > 8000 ? "Zabezpieczone" : "Niewystarczające zasilanie!");
return pobierzStatusKamer();
})
.then(statusKamer => {
console.log("Kamery:", statusKamer.allOperational ? "Wszystkie działają" : "Niektóre nie działają!");
return {
brama: statusBram,
ogrodzenie: statusOgrodzenia,
kamery: statusKamer,
czasSprawdzenia: new Date().toISOString()
};
})
.catch(error => {
console.error("Błąd podczas sprawdzania:", error.message);
throw new Error(`Sprawdzanie nie powiodło się: ${error.message}`);
});
}
// Z użyciem async/await
async function sprawdźSystemyBezpieczeństwa() {
console.log("Sprawdzanie systemów bezpieczeństwa...");
try {
// Każde z poniższych wywołań wstrzymuje wykonanie funkcji
const statusBram = await pobierzStatusBram();
console.log("Status bram:", statusBram.allClosed ? "Wszystkie zamknięte" : "UWAGA! Niektóre otwarte");
const statusOgrodzenia = await pobierzStatusOgrodzenia();
console.log("Ogrodzenie:", statusOgrodzenia.power > 8000 ? "Zabezpieczone" : "Niewystarczające zasilanie!");
const statusKamer = await pobierzStatusKamer();
console.log("Kamery:", statusKamer.allOperational ? "Wszystkie działają" : "Niektóre nie działają!");
return {
brama: statusBram,
ogrodzenie: statusOgrodzenia,
kamery: statusKamer,
czasSprawdzenia: new Date().toISOString()
};
} catch (error) {
console.error("Błąd podczas sprawdzania:", error.message);
throw new Error(`Sprawdzanie nie powiodło się: ${error.message}`);
}
}Zauważ, że:
- Kod wykorzystujący async/await jest znacznie bardziej czytelny - wygląda prawie jak kod synchroniczny
- Łatwiej śledzić przepływ danych (wartości
statusBram,statusOgrodzenia,statusKamer) - Obsługa błędów jest prostsza, wykorzystując standardową składnię
try/catchzamiast.catch()
Zamiana funkcji zwracających Promise na async/await
Każdą funkcję, która zwraca Promise, możemy przekształcić na funkcję async:
// Funkcja zwracająca Promise
function pomiarTemperaturyWybiegu(wybiegId) {
return new Promise((resolve, reject) => {
// Kod pomiarowy...
});
}
// Przekształcenie na funkcję async
async function pomiarTemperaturyWybiegu(wybiegId) {
// Możemy użyć operacji asynchronicznych z await
const czujnik = await połączZCzujnikiem(wybiegId);
const odczyt = await czujnik.pobierzTemperaturę();
if (odczyt.status === "error") {
throw new Error(`Błąd odczytu temperatury: ${odczyt.message}`);
}
return {
wybiegId,
temperatura: odczyt.value,
jednostka: "Celsius",
czasPomiaru: new Date()
};
}Równoległe wykonywanie operacji z async/await
Jedną rzeczą, na którą trzeba uważać przy używaniu async/await, jest sekwencyjność. Używając await przed każdym wywołaniem funkcji asynchronicznej, wykonujemy je jedna po drugiej, co nie zawsze jest pożądane.
Na przykład, w poniższym kodzie operacje są wykonywane sekwencyjnie, jedna po drugiej:
async function inicjalizacjaSystemówParkuSekwencyjnie() {
console.log("Inicjalizacja systemów parku...");
const systemWodny = await inicjalizujSystemWodny(); // 3 sekundy
const systemZasilania = await inicjalizujSystemZasilania(); // 2 sekundy
const systemBezpieczeństwa = await inicjalizujSystemBezpieczeństwa(); // 4 sekundy
// Łączny czas: około 9 sekund
return {
systemWodny,
systemZasilania,
systemBezpieczeństwa,
status: "Wszystkie systemy gotowe"
};
}Jeśli operacje są niezależne od siebie, lepiej wykonać je równolegle:
async function inicjalizacjaSystemówParkuRównolegle() {
console.log("Inicjalizacja systemów parku...");
// Uruchamiamy wszystkie operacje jednocześnie (bez await)
const obietnicaSystemuWodnego = inicjalizujSystemWodny();
const obietnicaSystemuZasilania = inicjalizujSystemZasilania();
const obietnicaSystemuBezpieczeństwa = inicjalizujSystemBezpieczeństwa();
// Czekamy na zakończenie wszystkich operacji
const [systemWodny, systemZasilania, systemBezpieczeństwa] = await Promise.all([
obietnicaSystemuWodnego,
obietnicaSystemuZasilania,
obietnicaSystemuBezpieczeństwa
]);
// Łączny czas: około 4 sekundy (najdłuższa operacja)
return {
systemWodny,
systemZasilania,
systemBezpieczeństwa,
status: "Wszystkie systemy gotowe"
};
}W powyższym przykładzie wszystkie trzy inicjalizacje systemów są uruchamiane równolegle, a następnie używamy Promise.all() z await, aby poczekać na zakończenie wszystkich operacji. Dzięki temu możemy zredukować czas wykonania do czasu najdłuższej operacji, zamiast sumy czasów wszystkich operacji.
Obsługa błędów w async/await
Jak już widzieliśmy, jedną z głównych zalet składni async/await jest możliwość używania standardowej składni try/catch do obsługi błędów. Jest to znacznie bardziej czytelne niż łańcuchy .catch() w tradycyjnym podejściu Promise.
async function wypuśćDinozauraZWybiegu(dinoId, wybiegId) {
try {
// Sprawdzenie, czy mamy uprawnienia
const uprawnienia = await sprawdźUprawnienia();
if (!uprawnienia.canReleaseAnimals) {
throw new Error("Brak uprawnień do wypuszczania dinozaurów");
}
// Sprawdzenie statusu dinozaura
const statusDinozaura = await sprawdźStatusDinozaura(dinoId);
if (statusDinozaura.health !== "Good") {
throw new Error(`Dinozaur #${dinoId} nie jest w dobrym stanie zdrowia`);
}
// Sprawdzenie, czy wybieg jest bezpieczny
const statusWybiegu = await sprawdźStatusWybiegu(wybiegId);
if (!statusWybiegu.isSecure) {
throw new Error(`Wybieg #${wybiegId} nie jest bezpieczny`);
}
// Otwieranie bramy wybiegu
await otwórzBramęWybiegu(wybiegId);
console.log(`Brama wybiegu #${wybiegId} otwarta`);
// Wypuszczenie dinozaura
const wynik = await przenieśDinozaura(dinoId, wybiegId, "outdoor-area");
console.log(`Dinozaur #${dinoId} został wypuszczony do strefy zewnętrznej wybiegu #${wybiegId}`);
return {
success: true,
message: `Dinozaur #${dinoId} został pomyślnie wypuszczony`,
details: wynik
};
} catch (error) {
console.error("Operacja wypuszczenia dinozaura nie powiodła się:", error.message);
// Możemy podjąć próbę naprawy błędu lub wykonać operacje czyszczące
try {
await zamknijWszystkieBramy();
await aktywujSystemBezpieczeństwa();
} catch (cleanupError) {
console.error("Błąd podczas operacji czyszczących:", cleanupError.message);
}
return {
success: false,
message: `Błąd podczas wypuszczania dinozaura: ${error.message}`,
error: error.message
};
}
}W powyższym przykładzie użyliśmy bloku try/catch do obsługi wszelkich błędów, które mogą wystąpić podczas procesu wypuszczania dinozaura. Możemy również zagnieżdżać bloki try/catch, jak widać w obsłudze błędu, gdzie próbujemy wykonać operacje czyszczące, które również mogą się nie powieść.
Asynchroniczne iteracje
Wprowadzenie async/await umożliwiło również asynchroniczne iteracje, które są szczególnie przydatne przy pracy z kolekcjami obiektów, które wymagają operacji asynchronicznych.
Sekwencyjne przetwarzanie kolekcji
async function zbadajWszystkieDinozaury(listaId) {
console.log(`Rozpoczynam badanie ${listaId.length} dinozaurów...`);
const wyniki = [];
// Sekwencyjne przetwarzanie (jeden po drugim)
for (const id of listaId) {
try {
const wynik = await zbadajDinozaura(id);
console.log(`Dinozaur #${id} przebadany: ${wynik.status}`);
wyniki.push({
id,
success: true,
result: wynik
});
} catch (error) {
console.error(`Błąd badania dinozaura #${id}: ${error.message}`);
wyniki.push({
id,
success: false,
error: error.message
});
}
}
return {
łącznaBadań: listaId.length,
udanych: wyniki.filter(w => w.success).length,
nieudanych: wyniki.filter(w => !w.success).length,
wyniki
};
}W powyższym przykładzie używamy for...of z await wewnątrz pętli, co powoduje, że badania dinozaurów są wykonywane jedno po drugim. To jest odpowiednie podejście, gdy kolejność ma znaczenie lub gdy operacje muszą być wykonywane sekwencyjnie.
Równoległe przetwarzanie kolekcji
Jeśli operacje nie muszą być wykonywane sekwencyjnie, często lepiej jest przetwarzać kolekcję równolegle:
async function zbadajWszystkieDinozauryRównolegle(listaId) {
console.log(`Rozpoczynam badanie ${listaId.length} dinozaurów równolegle...`);
// Tworzenie tablicy obietnic
const obietnice = listaId.map(id => {
return zbadajDinozaura(id)
.then(wynik => ({
id,
success: true,
result: wynik
}))
.catch(error => ({
id,
success: false,
error: error.message
}));
});
// Równoległe wykonanie wszystkich badań
const wyniki = await Promise.all(obietnice);
return {
łącznaBadań: listaId.length,
udanych: wyniki.filter(w => w.success).length,
nieudanych: wyniki.filter(w => !w.success).length,
wyniki
};
}W tym przypadku używamy map() do tworzenia tablicy Promise i następnie używamy Promise.all() z await, aby poczekać na zakończenie wszystkich operacji. Dzięki temu wszystkie badania są wykonywane równolegle, co może znacznie przyspieszyć przetwarzanie dużych kolekcji.
Równoległe przetwarzanie z ograniczeniem
Czasami nie chcemy wykonywać wszystkich operacji jednocześnie, bo mogłoby to przeciążyć system. W takim przypadku możemy ograniczyć liczbę równoległych operacji:
async function zbadajDinozauryZOgraniczeniem(listaId, maxRównoległe = 3) {
console.log(`Rozpoczynam badanie ${listaId.length} dinozaurów (max ${maxRównoległe} równolegle)...`);
const wyniki = [];
// Przetwarzanie w porcjach
for (let i = 0; i < listaId.length; i += maxRównoległe) {
const porcja = listaId.slice(i, i + maxRównoległe);
console.log(`Przetwarzanie porcji ${Math.floor(i / maxRównoległe) + 1} (${porcja.length} dinozaurów)...`);
// Tworzenie tablicy obietnic dla bieżącej porcji
const obietnicePorcji = porcja.map(id => {
return zbadajDinozaura(id)
.then(wynik => ({
id,
success: true,
result: wynik
}))
.catch(error => ({
id,
success: false,
error: error.message
}));
});
// Równoległe wykonanie badań w bieżącej porcji
const wynikiPorcji = await Promise.all(obietnicePorcji);
wyniki.push(...wynikiPorcji);
console.log(`Porcja ${Math.floor(i / maxRównoległe) + 1} zakończona.`);
}
return {
łącznaBadań: listaId.length,
udanych: wyniki.filter(w => w.success).length,
nieudanych: wyniki.filter(w => !w.success).length,
wyniki
};
}W tym przypadku przetwarzamy listę ID w porcjach po maxRównoległe elementów. Każda porcja jest przetwarzana równolegle, ale czekamy na zakończenie wszystkich operacji w jednej porcji przed przejściem do następnej.
Async/await w funkcjach strzałkowych
Słowo kluczowe async może być również używane z funkcjami strzałkowymi:
// Tradycyjna funkcja strzałkowa zwracająca Promise
const monitorujDinozaura = (id) => {
return pobierzDinozaura(id)
.then(dino => {
return aktualizujStatusDinozaura(id, { lastChecked: new Date() });
});
};
// Funkcja strzałkowa async
const monitorujDinozaura = async (id) => {
const dino = await pobierzDinozaura(id);
return await aktualizujStatusDinozaura(id, { lastChecked: new Date() });
};Async/await w metodach klasy
Możemy również używać async w metodach klas:
class SystemMonitorowaniaDinozaurów {
constructor(sektor) {
this.sektor = sektor;
this.aktywny = false;
this.dinozaury = [];
}
async inicjalizuj() {
try {
// Pobieranie listy dinozaurów w sektorze
const lista = await pobierzListęDinozaurówWSektorze(this.sektor);
this.dinozaury = lista;
// Inicjalizacja czujników
await this.inicjalizujCzujniki();
this.aktywny = true;
console.log(`System monitorowania sektora ${this.sektor} zainicjalizowany`);
return true;
} catch (error) {
console.error(`Błąd inicjalizacji systemu monitorowania: ${error.message}`);
return false;
}
}
async inicjalizujCzujniki() {
// Inicjalizacja czujników dla każdego dinozaura
const obietnice = this.dinozaury.map(dino =>
inicjalizujCzujnikDlaDinozaura(dino.id)
);
return Promise.all(obietnice);
}
async monitoruj(czasMonitorowania = 60000) {
if (!this.aktywny) {
throw new Error("System monitorowania nie jest aktywny");
}
console.log(`Rozpoczynam monitorowanie sektora ${this.sektor} przez ${czasMonitorowania/1000} sekund...`);
// Monitorowanie przez określony czas
const startTime = Date.now();
while (Date.now() - startTime < czasMonitorowania) {
// Pobieranie statusu wszystkich dinozaurów
const statusy = await Promise.all(
this.dinozaury.map(dino => sprawdźStatusDinozaura(dino.id))
);
// Analiza statusów
const anormalneDinozaury = statusy.filter(s => s.status !== "normal");
if (anormalneDinozaury.length > 0) {
console.warn(`Wykryto ${anormalneDinozaury.length} dinozaurów z anormalnym statusem!`);
for (const status of anormalneDinozaury) {
console.warn(`Dinozaur #${status.dinoId}: ${status.status} - ${status.details}`);
// Wysłanie alertu dla każdego anormalnego statusu
await wyslijAlert(this.sektor, status);
}
}
// Czekamy 5 sekund przed następnym sprawdzeniem
await new Promise(resolve => setTimeout(resolve, 5000));
}
console.log(`Monitorowanie sektora ${this.sektor} zakończone.`);
return `Monitorowanie zakończone: ${new Date().toISOString()}`;
}
}
// Użycie klasy
async function uruchomSystemMonitorowania(sektor) {
const system = new SystemMonitorowaniaDinozaurów(sektor);
const inicjalizacjaUdana = await system.inicjalizuj();
if (!inicjalizacjaUdana) {
console.error(`Nie udało się zainicjalizować systemu dla sektora ${sektor}`);
return;
}
// Monitorowanie przez 5 minut
await system.monitoruj(300000);
console.log(`Sesja monitorowania dla sektora ${sektor} zakończona`);
}W powyższym przykładzie mamy klasę z metodami asynchronicznymi, które używają async/await do obsługi operacji asynchronicznych.
Async IIFE (natychmiast wywołane funkcje asynchroniczne)
Czasami chcemy użyć async/await na najwyższym poziomie (np. w skrypcie), gdzie normalnie nie możemy używać await. W takich przypadkach możemy użyć IIFE (Immediately Invoked Function Expression) z async:
// Natychmiast wywołana funkcja asynchroniczna
(async () => {
try {
console.log("Uruchamianie systemu Parku Jurajskiego...");
// Inicjalizacja systemów
await inicjalizujWszystkieSystemy();
// Sprawdzanie statusu dinozaurów
const statusDinozaurów = await sprawdźWszystkieDinozaury();
// Logika na podstawie statusu
if (statusDinozaurów.wszystkieBezpieczne) {
console.log("Park jest gotowy do otwarcia dla zwiedzających.");
await otwórzParkDlaZwiedzających();
} else {
console.error("Park nie jest jeszcze gotowy. Wymagany przegląd bezpieczeństwa.");
await inicjujPrzeglądBezpieczeństwa();
}
} catch (error) {
console.error("Krytyczny błąd podczas uruchamiania systemu:", error);
await aktywujProtokolyAwaryjne();
}
})();Rekursywne funkcje asynchroniczne
Async/await może być również używane w funkcjach rekurencyjnych:
// Funkcja rekurencyjna do próbowania aż do powodzenia
async function spróbujAżDoSkutku(operacja, maxPrób = 5, opóźnienie = 1000) {
try {
return await operacja();
} catch (error) {
if (maxPrób <= 1) {
throw new Error(`Operacja nie powiodła się po wielu próbach: ${error.message}`);
}
console.log(`Próba nie powiodła się (pozostało ${maxPrób-1} prób). Czekam ${opóźnienie}ms...`);
// Czekamy określony czas
await new Promise(resolve => setTimeout(resolve, opóźnienie));
// Rekurencyjne wywołanie z jedną próbą mniej
return spróbujAżDoSkutku(operacja, maxPrób - 1, opóźnienie * 1.5);
}
}
// Przykład użycia
async function uruchomDinozaura(id) {
await spróbujAżDoSkutku(
async () => {
const dino = await pobierzDinozaura(id);
if (!dino.awakened) {
await wybudźDinozaura(id);
}
return await aktualizujStatusDinozaura(id, { status: "active" });
},
3, // maksymalnie 3 próby
2000 // początkowe opóźnienie 2s (potem będzie 3s, potem 4.5s)
);
console.log(`Dinozaur #${id} został pomyślnie uruchomiony`);
}Async generatory i for-await-of
ECMAScript 2018 wprowadził asynchroniczne generatory i pętlę for-await-of, które są szczególnie przydatne do przetwarzania strumieni asynchronicznych danych:
// Asynchroniczny generator dostarczający dane o dinozaurach
async function* generatorDanychDinozaurów(sektor) {
const listaDinozaurów = await pobierzListęDinozaurówWSektorze(sektor);
for (const dino of listaDinozaurów) {
// Pobieranie szczegółowych danych dla każdego dinozaura
const szczegóły = await pobierzSzczegółyDinozaura(dino.id);
// Zwracamy dane dla każdego dinozaura osobno
yield {
...dino,
szczegóły
};
// Symulujemy opóźnienie przed przejściem do następnego
await new Promise(resolve => setTimeout(resolve, 500));
}
}
// Użycie asynchronicznego generatora z for-await-of
async function przetwórzDaneDinozaurów(sektor) {
console.log(`Rozpoczynam przetwarzanie danych dinozaurów z sektora ${sektor}...`);
for await (const dino of generatorDanychDinozaurów(sektor)) {
console.log(`Przetwarzam dane dinozaura: ${dino.name} (ID: ${dino.id})`);
// Przetwarzanie danych
await zapiszDaneDoRaportu(dino);
// Emisja alertu, jeśli dinozaur potrzebuje uwagi
if (dino.szczegóły.requiresAttention) {
await wyslijAlert(sektor, dino);
}
}
console.log(`Zakończono przetwarzanie danych dinozaurów z sektora ${sektor}`);
}W powyższym przykładzie używamy asynchronicznego generatora, który dostarcza dane o dinozaurach, a następnie używamy pętli for-await-of do przetwarzania tych danych. Jest to szczególnie przydatne, gdy mamy do czynienia z dużą ilością danych, które chcemy przetwarzać po kolei, ale gdzie każdy element wymaga operacji asynchronicznej.
Wzorce projektowe z async/await
Składnia async/await otwiera nowe możliwości dla wzorców projektowych w JavaScript. Oto kilka użytecznych wzorców:
Wzorzec retry (ponowne próby)
async function zPonownymiPróbami(operacja, opcje = {}) {
const { maxPrób = 3, opóźnienie = 1000, backoffMnożnik = 2 } = opcje;
let ostatniError;
for (let próba = 1; próba <= maxPrób; próba++) {
try {
if (próba > 1) {
console.log(`Próba ${próba}/${maxPrób}...`);
}
return await operacja();
} catch (error) {
console.error(`Próba ${próba} nie powiodła się: ${error.message}`);
ostatniError = error;
if (próba < maxPrób) {
const czasOczekiwania = opóźnienie * Math.pow(backoffMnożnik, próba - 1);
console.log(`Oczekiwanie ${czasOczekiwania}ms przed kolejną próbą...`);
await new Promise(resolve => setTimeout(resolve, czasOczekiwania));
}
}
}
throw new Error(`Operacja nie powiodła się po ${maxPrób} próbach. Ostatni błąd: ${ostatniError.message}`);
}
// Przykład użycia
async function podłączDoSystemuBezpieczeństwa() {
return zPonownymiPróbami(
async () => {
const połączenie = await nawiążPołączenieZSystememBezpieczeństwa();
const autentykacja = await uwierzytelnijPołączenie(połączenie);
return await pobierzStatusBezpieczeństwa(połączenie, autentykacja);
},
{
maxPrób: 5,
opóźnienie: 2000,
backoffMnożnik: 1.5
}
);
}Wzorzec timeout (limit czasu)
async function zTimeoutem(operacja, limitCzasu, wiadomość) {
// Tworzymy Promise, który odrzuca się po przekroczeniu limitu czasu
const timeoutPromise = new Promise((_, reject) => {
setTimeout(() => {
reject(new Error(`Przekroczono limit czasu (${limitCzasu}ms): ${wiadomość}`));
}, limitCzasu);
});
// Uruchamiamy wyścig między operacją a timeoutem
return Promise.race([operacja(), timeoutPromise]);
}
// Przykład użycia
async function bezpieczneOdczytywanieTemperatury(wybiegId) {
try {
const temperatura = await zTimeoutem(
() => odczytajTemperaturęWybiegu(wybiegId),
5000,
`Odczytywanie temperatury wybiegu #${wybiegId}`
);
console.log(`Temperatura wybiegu #${wybiegId}: ${temperatura}°C`);
return temperatura;
} catch (error) {
console.error(`Błąd odczytu temperatury: ${error.message}`);
return null; // Lub możemy zwrócić wartość domyślną
}
}Wzorzec retry z exponential backoff
async function zExponentialBackoff(operacja, opcje = {}) {
const {
maxPrób = 5,
bazoweCzekanie = 1000,
maksymalneCzekanie = 30000,
jitter = true
} = opcje;
let próba = 0;
while (true) {
try {
return await operacja(++próba);
} catch (error) {
if (próba >= maxPrób) {
throw new Error(`Operacja nie powiodła się po ${próba} próbach: ${error.message}`);
}
// Obliczanie czasu oczekiwania z exponential backoff
let czasOczekiwania = Math.min(
maksymalneCzekanie,
bazoweCzekanie * Math.pow(2, próba - 1)
);
// Dodanie jittera (losowość) do czasu oczekiwania
if (jitter) {
czasOczekiwania = czasOczekiwania * (0.5 + Math.random() * 0.5);
}
console.log(`Próba ${próba} nie powiodła się. Oczekiwanie ${Math.round(czasOczekiwania)}ms przed kolejną próbą...`);
await new Promise(resolve => setTimeout(resolve, czasOczekiwania));
}
}
}
// Przykład użycia
async function zsynchronizujDaneZCentralą() {
return zExponentialBackoff(
async (próba) => {
console.log(`Próba synchronizacji #${próba}...`);
const dane = await pobierzAktualneDane();
await wyślijDaneDoCentrali(dane);
return `Synchronizacja ukończona: ${dane.length} rekordów`;
},
{
maxPrób: 10,
bazoweCzekanie: 2000,
maksymalneCzekanie: 60000
}
);
}Wzorzec waterfalls (kaskadowe operacje)
async function kaskadowePrzeszukiwanie(zapytanie) {
console.log(`Rozpoczynam kaskadowe przeszukiwanie dla: ${zapytanie}`);
// Próbujemy najpierw w pamięci podręcznej
try {
console.log("Przeszukiwanie pamięci podręcznej...");
const wynikCache = await przeszukajPamięćPodręczną(zapytanie);
console.log("Znaleziono w pamięci podręcznej!");
return {
źródło: "cache",
wynik: wynikCache
};
} catch (error) {
console.log("Nie znaleziono w pamięci podręcznej, próbuję lokalnej bazy danych...");
}
// Następnie próbujemy w lokalnej bazie danych
try {
const wynikLokalne = await przeszukajLokalnąBazęDanych(zapytanie);
console.log("Znaleziono w lokalnej bazie danych!");
// Aktualizacja pamięci podręcznej
await aktualizujPamięćPodręczną(zapytanie, wynikLokalne);
return {
źródło: "lokalna_baza",
wynik: wynikLokalne
};
} catch (error) {
console.log("Nie znaleziono w lokalnej bazie, próbuję w centralnej bazie...");
}
// W końcu próbujemy w centralnej bazie danych
try {
const wynikCentralne = await przeszukajCentralnąBazęDanych(zapytanie);
console.log("Znaleziono w centralnej bazie danych!");
// Aktualizacja lokalnej bazy i pamięci podręcznej
await aktualizujLokalnąBazęDanych(zapytanie, wynikCentralne);
await aktualizujPamięćPodręczną(zapytanie, wynikCentralne);
return {
źródło: "centralna_baza",
wynik: wynikCentralne
};
} catch (error) {
throw new Error(`Nie znaleziono wyników dla zapytania: ${zapytanie}`);
}
}Podsumowanie
Składnia async/await oferuje elegancki i czytelny sposób pracy z kodem asynchronicznym w JavaScript, który działa na bazie Promise. Oto główne zalety:
- Czytelność - kod wygląda bardziej jak synchroniczny, co ułatwia zrozumienie przepływu programu
- Obsługa błędów - możliwość używania standardowej składni
try/catchzamiast.catch() - Debugowanie - łatwiejsze śledzenie stosu wywołań i ustawianie breakpointów
- Kompozycja - łatwiejsze komponowanie złożonych operacji asynchronicznych
Pamiętaj jednak o kilku istotnych kwestiach:
- Funkcje async zawsze zwracają Promise - nawet jeśli nie używasz
awaitwewnątrz funkcji - Uważaj na sekwencyjność - używanie
awaitprzed każdym wywołaniem powoduje sekwencyjne wykonanie, co może nie być optymalne - Nie zapomnij o obsłudze błędów - zawsze używaj
try/catchlub.catch()przy wywołaniu funkcji async - Używaj Promise.all() dla równoległego wykonania - gdy operacje są niezależne i mogą być wykonywane równolegle
W Parku Jurajskim, jak i w każdej złożonej aplikacji JavaScript, async/await jest nieocenionym narzędziem do zarządzania operacjami asynchronicznymi, takimi jak komunikacja z systemami bezpieczeństwa, monitorowanie dinozaurów, czy koordynacja różnych podsystemów parku.
W następnym ćwiczeniu skupimy się na strategiach obsługi błędów w kodzie asynchronicznym, co jest kluczowe dla tworzenia odpornych i niezawodnych aplikacji.
Kod do tej lekcji: index.js
// Closure Counter - Domknięcia
console.log("CLOSURE - LICZNIK DINOZAURÓW\n");
// Closure - funkcja pamiętająca swoje środowisko
function createDinosaurCounter(species) {
let count = 0; // Prywatna zmienna
return {
increment: function() {
count++;
console.log(`${species} count: ${count}`);
return count;
},
decrement: function() {
if (count > 0) {
count--;
console.log(`${species} count: ${count}`);
} else {
console.log(`${species} count już jest 0!`);
}
return count;
},
getCount: function() {
return count;
},
reset: function() {
count = 0;
console.log(`${species} counter zresetowany`);
}
};
}
// Tworzymy liczniki dla różnych gatunków
console.log("=== TWORZENIE LICZNIKÓW ===\n");
const trexCounter = createDinosaurCounter('T-Rex');
const velociraptorCounter = createDinosaurCounter('Velociraptor');
console.log("T-Rex:");
trexCounter.increment(); // 1
trexCounter.increment(); // 2
trexCounter.increment(); // 3
console.log("\nVelociraptor:");
velociraptorCounter.increment(); // 1
velociraptorCounter.increment(); // 2
console.log("\nT-Rex znowu:");
trexCounter.increment(); // 4
console.log(`\n=== STAN LICZNIKÓW ===`);
console.log(`T-Rex: ${trexCounter.getCount()}`);
console.log(`Velociraptor: ${velociraptorCounter.getCount()}`);
console.log("\n=== DEKREMENTACJA ===\n");
trexCounter.decrement(); // 3
velociraptorCounter.decrement(); // 1
velociraptorCounter.decrement(); // 0
velociraptorCounter.decrement(); // Próba zejścia poniżej 0
console.log("\n=== RESET ===\n");
trexCounter.reset();
console.log(`T-Rex po reset: ${trexCounter.getCount()}`);
// count jest niedostępny z zewnątrz!
// console.log(count); // ERROR! count jest prywatnyHasł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 robi słowo kluczowe await?
2. Co automatycznie zwraca funkcja oznaczona słowem async?
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Napisz async function, która używa await do sekwencyjnego sprawdzenia trzech czujników dinozaurów i wyświetla wyniki.
- Układanie w poziomie
Ułóż elementy równoległego wykonania Promise: