Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne

Składnia async/await

16 min czytania ·
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:

  1. Słowo kluczowe async - używane przed deklaracją funkcji, oznacza, że funkcja zawsze zwróci Promise
  2. 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:

  1. Deklarujemy funkcję pobierzDaneDinozaura() ze słowem kluczowym async, co oznacza, że będzie ona zawsze zwracać Promise
  2. Wewnątrz tej funkcji używamy await przed wywołaniem pobierzDinozaura(id), co powoduje, że wykonanie funkcji zostanie wstrzymane do czasu rozwiązania Promise
  3. Kiedy Promise zostanie rozwiązany, kod będzie kontynuował wykonywanie od miejsca, w którym został wstrzymany, a zmiennej dinozaur zostanie przypisana rozwiązana wartość Promise
  4. Ponieważ funkcja async zawsze zwraca Promise, możemy użyć metod .then() i .catch() przy wywołaniu pobierzDaneDinozaura()

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/catch zamiast .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:

  1. Czytelność - kod wygląda bardziej jak synchroniczny, co ułatwia zrozumienie przepływu programu
  2. Obsługa błędów - możliwość używania standardowej składni try/catch zamiast .catch()
  3. Debugowanie - łatwiejsze śledzenie stosu wywołań i ustawianie breakpointów
  4. Kompozycja - łatwiejsze komponowanie złożonych operacji asynchronicznych

Pamiętaj jednak o kilku istotnych kwestiach:

  1. Funkcje async zawsze zwracają Promise - nawet jeśli nie używasz await wewnątrz funkcji
  2. Uważaj na sekwencyjność - używanie await przed każdym wywołaniem powoduje sekwencyjne wykonanie, co może nie być optymalne
  3. Nie zapomnij o obsłudze błędów - zawsze używaj try/catch lub .catch() przy wywołaniu funkcji async
  4. 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 prywatny

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. 1. Co robi słowo kluczowe await?

  2. 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:

  1. Pytanieasync/await
  2. PytanieFunkcja async
  3. Zadanie z kodemPraktyka: async/await
  4. PytaniePromise.allSettled()
  5. PytaniePromise.race
  6. Ułóż w kolejnościSkładnia Promise.all

Przydatne artykuły