Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne

Promise.all, Promise.race, Promise.allSettled

16 min czytania ·
W tej lekcji7

W poprzednich ćwiczeniach skupialiśmy się na pojedynczych Promise oraz ich łańcuchach. Jednak w rzeczywistych aplikacjach, takich jak system zarządzania Parkiem Jurajskim, często musimy pracować z wieloma operacjami asynchronicznymi jednocześnie. JavaScript oferuje specjalne metody pomocnicze na obiekcie Promise, które pozwalają na elegancką kompozycję i koordynację wielu obietnic.

W tym ćwiczeniu przyjrzymy się trzem kluczowym statycznym metodom obiektu Promise:

  • Promise.all(): do wykonywania operacji równoległych i oczekiwania na zakończenie wszystkich
  • Promise.race(): do reagowania na pierwszą zakończoną operację
  • Promise.allSettled(): do czekania na zakończenie wszystkich operacji, niezależnie od wyniku

Promise.all() - wszystko albo nic

Metoda Promise.all() przyjmuje tablicę obietnic i zwraca nową obietnicę, która:

  • rozwiązuje się, gdy wszystkie obietnice w tablicy zostaną spełnione, z tablicą wyników
  • odrzuca się, gdy którakolwiek z obietnic zostanie odrzucona, z pierwszym błędem

Jest to idealne narzędzie, gdy musisz wykonać wiele niezależnych operacji równolegle i potrzebujesz wszystkich wyników, aby kontynuować.

Przykład: Przygotowanie parku do otwarcia

Zanim Park Jurajski może zostać otwarty dla zwiedzających, musimy sprawdzić różne systemy równocześnie:

// Funkcje zwracające Promise dla różnych systemów
function sprawdźSystemyBezpieczeństwa() {
  console.log("Sprawdzanie systemów bezpieczeństwa...");
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const systemySprawne = Math.random() > 0.1; // 10% szans na błąd
      if (systemySprawne) {
        resolve({
          status: "OK",
          message: "Wszystkie systemy bezpieczeństwa działają prawidłowo",
          lastChecked: new Date().toISOString()
        });
      } else {
        reject(new Error("Awaryjne ogrodzenie w sektorze B nie działa!"));
      }
    }, 2000);
  });
}

function sprawdźZdrowieDinozaurów() {
  console.log("Sprawdzanie zdrowia dinozaurów...");
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        status: "OK",
        message: "Wszystkie dinozaury zdrowe",
        count: 36,
        sick: 0
      });
    }, 3000);
  });
}

function sprawdźSystemyZasilania() {
  console.log("Sprawdzanie systemów zasilania...");
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        status: "OK",
        message: "Zasilanie główne i zapasowe działa prawidłowo",
        mainPower: "online",
        backupPower: "standby"
      });
    }, 1500);
  });
}

function sprawdźPogodę() {
  console.log("Sprawdzanie prognozy pogody...");
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const pogodaOK = Math.random() > 0.2; // 20% szans na złą pogodę
      if (pogodaOK) {
        resolve({
          status: "OK",
          message: "Pogoda sprzyjająca",
          forecast: "Słonecznie, 25°C"
        });
      } else {
        reject(new Error("Nadchodzi burza tropikalna! Otwarcie parku niemożliwe."));
      }
    }, 1000);
  });
}

// Funkcja główna do sprawdzenia gotowości parku
function sprawdźGotowośćParku() {
  console.log("Rozpoczynam sprawdzanie gotowości parku do otwarcia...");

  const startTime = Date.now();

  // Uruchamiamy wszystkie sprawdzenia równolegle
  const bezpieczeństwo = sprawdźSystemyBezpieczeństwa();
  const dinozaury = sprawdźZdrowieDinozaurów();
  const zasilanie = sprawdźSystemyZasilania();
  const pogoda = sprawdźPogodę();

  // Używamy Promise.all, aby poczekać na wszystkie wyniki
  return Promise.all([bezpieczeństwo, dinozaury, zasilanie, pogoda])
    .then(wyniki => {
      const endTime = Date.now();
      const czasWykonania = (endTime - startTime) / 1000;

      // Rozpakowanie wyników
      const [wynikBezpieczeństwa, wynikDinozaurów, wynikZasilania, wynikPogody] = wyniki;

      return {
        status: "PARK GOTOWY DO OTWARCIA",
        bezpieczeństwo: wynikBezpieczeństwa,
        dinozaury: wynikDinozaurów,
        zasilanie: wynikZasilania,
        pogoda: wynikPogody,
        czasSprawdzenia: `${czasWykonania} sekund`
      };
    })
    .catch(error => {
      throw new Error(`Park nie jest gotowy do otwarcia: ${error.message}`);
    });
}

// Używamy naszej funkcji
sprawdźGotowośćParku()
  .then(raport => {
    console.log("RAPORT GOTOWOŚCI PARKU:");
    console.log(JSON.stringify(raport, null, 2));

    // Rozpocznij procedurę otwarcia bram
    otwórzBramyParku();
  })
  .catch(error => {
    console.error("BŁĄD:", error.message);

    // Powiadom kierownictwo o problemie
    powiadomKierownictwo(error.message);
  });

function otwórzBramyParku() {
  console.log("Otwieranie bram parku dla zwiedzających...");
}

function powiadomKierownictwo(wiadomość) {
  console.log(`Powiadamianie kierownictwa: ${wiadomość}`);
}

W powyższym przykładzie:

  1. Uruchamiamy 4 niezależne sprawdzenia systemów parku równolegle
  2. Używamy Promise.all() do czekania na zakończenie wszystkich sprawdzeń
  3. Jeśli wszystkie się powiodą, otrzymujemy tablicę wyników w tej samej kolejności, co tablica obietnic
  4. Jeśli którykolwiek się nie powiedzie, cała operacja jest uznawana za nieudaną

Zauważ, że wszystkie operacje są uruchamiane jednocześnie (nie jedna po drugiej), co znacznie przyspiesza cały proces. Zamiast czekać 2000 + 3000 + 1500 + 1000 = 7500 ms, czekamy tylko na najdłuższą operację, czyli około 3000 ms.

Obsługa wyników Promise.all()

Wynikiem spełnionej obietnicy zwróconej przez Promise.all() jest tablica wyników w tej samej kolejności, co wejściowa tablica obietnic. Możemy użyć destrukturyzacji tablicy, aby elegancko przypisać nazwy do poszczególnych wyników:

Promise.all([pobierzDino(1), pobierzDino(2), pobierzDino(3)])
  .then(([dino1, dino2, dino3]) => {
    console.log("T-Rex:", dino1.name);
    console.log("Velociraptor:", dino2.name);
    console.log("Triceratops:", dino3.name);
  });

Kiedy nie używać Promise.all()

Trzeba pamiętać, że Promise.all() stosuje podejście "wszystko albo nic". Jeśli którakolwiek obietnica zostanie odrzucona, cała operacja kończy się niepowodzeniem. Nie jest to zawsze pożądane zachowanie.

Promise.race() - odpowiedź na pierwszą zakończoną operację

Metoda Promise.race() również przyjmuje tablicę obietnic, ale zwraca nową obietnicę, która rozwiązuje się lub odrzuca z wynikiem pierwszej rozwiązanej lub odrzuconej obietnicy z tablicy.

Jest to idealne rozwiązanie dla scenariuszy, w których:

  • Potrzebujesz tylko pierwszego dostępnego wyniku
  • Chcesz ustawić timeout dla operacji
  • Potrzebujesz zaimplementować wzorzec "wyścig"

Przykład: Szybkie rozpoznawanie gatunku dinozaura

Wyobraźmy sobie, że mamy kilka różnych systemów rozpoznawania gatunków dinozaurów (wizualny, DNA, behawioralny) i chcemy użyć wyniku z tego, który zadziała najszybciej:

function rozpoznajWizualnie(obrazDinozaura) {
  console.log("Rozpoczynam analizę wizualną...");
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.random() > 0.3) { // 70% szans na sukces
        resolve({
          method: "visual",
          species: "Velociraptor",
          confidence: 0.82,
          timeMs: 1800
        });
      } else {
        reject(new Error("Nie udało się rozpoznać wizualnie"));
      }
    }, 1800);
  });
}

function rozpoznajPrzezDNA(próbkaDNA) {
  console.log("Rozpoczynam analizę DNA...");
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.random() > 0.1) { // 90% szans na sukces
        resolve({
          method: "dna",
          species: "Velociraptor",
          subspecies: "V. mongoliensis",
          confidence: 0.98,
          timeMs: 3500
        });
      } else {
        reject(new Error("Próbka DNA zanieczyszczona"));
      }
    }, 3500);
  });
}

function rozpoznajZachowanie(nagranieBehawioralne) {
  console.log("Rozpoczynam analizę behawioralną...");
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.random() > 0.4) { // 60% szans na sukces
        resolve({
          method: "behavioral",
          species: "Velociraptor",
          behaviors: ["pack-hunting", "high-agility", "vocalizations"],
          confidence: 0.75,
          timeMs: 2200
        });
      } else {
        reject(new Error("Za mało danych behawioralnych"));
      }
    }, 2200);
  });
}

// Funkcja do szybkiego rozpoznania dinozaura
function szybkieRozpoznanie(dane) {
  console.log("Uruchamiam szybkie rozpoznanie dinozaura...");

  return Promise.race([
    rozpoznajWizualnie(dane.obraz),
    rozpoznajPrzezDNA(dane.dna),
    rozpoznajZachowanie(dane.nagranie)
  ]);
}

// Użycie
const daneDinozaura = {
  obraz: "https://jurassic-world.com/images/suspect_dino.jpg",
  dna: "ACGTTTCGAACGTACGATCGATCG...",
  nagranie: "https://jurassic-world.com/videos/suspect_dino.mp4"
};

szybkieRozpoznanie(daneDinozaura)
  .then(wynik => {
    console.log(`Dinozaur rozpoznany jako: ${wynik.species}`);
    console.log(`Metoda: ${wynik.method}, Pewność: ${wynik.confidence * 100}%`);
    console.log(`Czas rozpoznania: ${wynik.timeMs} ms`);

    // Podejmij działania na podstawie gatunku
    if (wynik.species === "Velociraptor") {
      podwyższBezpieczeństwoWybiegu("RAPTOR-PADDOCK");
    }
  })
  .catch(error => {
    console.error("Nie udało się rozpoznać dinozaura:", error.message);
    console.log("Uruchamiam procedurę bezpieczeństwa dla nieznanego gatunku...");
    proceduraBezpieczeństwaDlaNieznanego();
  });

function podwyższBezpieczeństwoWybiegu(id) {
  console.log(`Podwyższanie poziomu bezpieczeństwa wybiegu ${id}...`);
}

function proceduraBezpieczeństwaDlaNieznanego() {
  console.log("Aktywacja protokołu dla nieznanego gatunku...");
}

W tym przykładzie uruchamiamy trzy metody rozpoznawania równolegle i używamy pierwszego dostępnego wyniku. Metoda wizualna jest najszybsza (1800 ms), ale ma najniższą dokładność. Metoda DNA jest najwolniejsza (3500 ms), ale najbardziej dokładna. Metoda behawioralna jest pośrodku. Dzięki Promise.race() otrzymujemy pierwszy dostępny wynik, co pozwala na szybką reakcję.

Implementacja timeoutu za pomocą Promise.race()

Często potrzebujemy przerwać długotrwające operacje, jeśli trwają zbyt długo. Promise.race() jest idealnym narzędziem do implementacji timeoutu:

// Funkcja pomocnicza tworząca obietnicę timeoutu
function timeout(ms, message) {
  return new Promise((_, reject) => {
    setTimeout(() => {
      reject(new Error(`Timeout po ${ms}ms: ${message}`));
    }, ms);
  });
}

// Funkcja z timeoutem
function pobierzDaneDinozauraZTimeoutem(id, czasTimeout) {
  console.log(`Pobieranie danych dinozaura #${id} z timeoutem ${czasTimeout}ms...`);

  // Właściwa operacja
  const pobieranieDanych = pobierzDaneDinozaura(id);

  // Obietnica timeoutu
  const timeoutPromise = timeout(czasTimeout, `Pobieranie danych dinozaura #${id}`);

  // Wyścig między pobieraniem danych a timeoutem
  return Promise.race([pobieranieDanych, timeoutPromise]);
}

// Przykładowa funkcja pobierająca dane
function pobierzDaneDinozaura(id) {
  return new Promise((resolve) => {
    // Symulacja czasu odpowiedzi od 1s do 6s
    const czas = 1000 + Math.random() * 5000;
    setTimeout(() => {
      resolve({
        id: id,
        name: `Dino-${id}`,
        species: id % 2 === 0 ? "Tyrannosaurus" : "Velociraptor",
        age: Math.floor(Math.random() * 20) + 1
      });
    }, czas);
  });
}

// Użycie funkcji z timeoutem
pobierzDaneDinozauraZTimeoutem(42, 3000)
  .then(dino => {
    console.log("Otrzymane dane dinozaura:", dino);
  })
  .catch(error => {
    console.error("Błąd:", error.message);
    console.log("Podejmuję działania awaryjne...");
  });

W tym przykładzie, jeśli pobierzDaneDinozaura() zajmie więcej niż 3 sekundy, operacja zostanie przerwana przez timeout, a Promise zostanie odrzucony z błędem timeoutu.

Promise.allSettled() - pełna informacja o wszystkich operacjach

Metoda Promise.allSettled() (wprowadzona w ES2020) przyjmuje tablicę obietnic i zwraca nową obietnicę, która zawsze rozwiązuje się po zakończeniu wszystkich obietnic w tablicy, niezależnie od tego, czy zostały spełnione, czy odrzucone.

Wynikiem jest tablica obiektów, gdzie każdy obiekt opisuje wynik odpowiedniej obietnicy:

  • Dla spełnionych obietnic: { status: 'fulfilled', value: wynik }
  • Dla odrzuconych obietnic: { status: 'rejected', reason: błąd }

Jest to doskonałe rozwiązanie, gdy:

  • Potrzebujesz wiedzieć o wszystkich wynikach, niezależnie od sukcesu czy porażki
  • Operacje są niezależne i niepowodzenie jednej nie powinno wpływać na inne
  • Chcesz mieć pełny raport o stanie wszystkich operacji

Przykład: Monitorowanie wszystkich systemów parku

W Parku Jurajskim musimy regularnie monitorować wszystkie systemy i raporty powinny zawierać informacje o każdym systemie, nawet jeśli niektóre zgłaszają błędy:

function monitorujWszystkieSystemy() {
  console.log("Rozpoczynam monitorowanie wszystkich systemów parku...");

  // Tablica obietnic dla wszystkich systemów
  const monitorowanieSystemów = [
    monitorujOgrodzenie(),
    monitorujZasilanie(),
    monitorujKamery(),
    monitorujCzujnikiRuchu(),
    monitorujSystemWodny(),
    monitorujWentylację(),
    monitorujTemperaturę(),
    monitorujBramyWybiegów()
  ];

  // Użycie Promise.allSettled
  return Promise.allSettled(monitorowanieSystemów)
    .then(wyniki => {
      // Przygotowanie raportu
      const raport = {
        czasMonitorowania: new Date().toISOString(),
        liczbaSprawnychSystemów: 0,
        liczbaSystemówZProblemi: 0,
        systemySprawne: [],
        systemyZProblemami: []
      };

      // Analiza wyników
      wyniki.forEach((wynik, index) => {
        const nazwaSystemu = pobierzNazwęSystemu(index);

        if (wynik.status === 'fulfilled') {
          raport.liczbaSprawnychSystemów++;
          raport.systemySprawne.push({
            nazwa: nazwaSystemu,
            status: wynik.value.status,
            szczegóły: wynik.value.details
          });
        } else {
          raport.liczbaSystemówZProblemi++;
          raport.systemyZProblemami.push({
            nazwa: nazwaSystemu,
            błąd: wynik.reason.message,
            czasWystąpienia: new Date().toISOString()
          });
        }
      });

      // Dodanie podsumowania
      raport.czyWszystkieSystemySprawne = raport.liczbaSystemówZProblemi === 0;
      raport.poziomZagrożenia = obliczPoziomZagrożenia(raport);

      return raport;
    });
}

// Funkcja pomocnicza do mapowania indeksu na nazwę systemu
function pobierzNazwęSystemu(index) {
  const nazwySystemów = [
    "Ogrodzenie elektryczne",
    "System zasilania",
    "System kamer",
    "Czujniki ruchu",
    "System wodny",
    "System wentylacji",
    "Kontrola temperatury",
    "Bramy wybiegów"
  ];
  return nazwySystemów[index];
}

// Funkcja do obliczania poziomu zagrożenia na podstawie raportu
function obliczPoziomZagrożenia(raport) {
  // Logika określająca poziom zagrożenia
  if (raport.systemyZProblemami.some(s => s.nazwa === "Ogrodzenie elektryczne")) {
    return "CRITICAL";
  } else if (raport.liczbaSystemówZProblemi > 2) {
    return "HIGH";
  } else if (raport.liczbaSystemówZProblemi > 0) {
    return "MEDIUM";
  } else {
    return "LOW";
  }
}

// Przykładowe implementacje funkcji monitorujących
function monitorujOgrodzenie() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.random() > 0.9) { // 10% szans na błąd
        reject(new Error("Wykryto awarię w sektorze ogrodzenia A3"));
      } else {
        resolve({ status: "OK", details: { voltage: "10000V", lastCheck: new Date() } });
      }
    }, 1000 + Math.random() * 1000);
  });
}

function monitorujZasilanie() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        status: "OK",
        details: {
          mainPower: "ONLINE",
          backupPower: "STANDBY",
          powerConsumption: "75%"
        }
      });
    }, 800 + Math.random() * 1000);
  });
}

function monitorujKamery() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.random() > 0.8) { // 20% szans na błąd
        reject(new Error("Kamera nr 12 w sektorze B nie odpowiada"));
      } else {
        resolve({
          status: "OK",
          details: {
            onlineCameras: 36,
            offlineCameras: 0
          }
        });
      }
    }, 1200 + Math.random() * 800);
  });
}

// Implementacje pozostałych funkcji monitorujących...
function monitorujCzujnikiRuchu() {
  return Promise.resolve({ status: "OK", details: { sensorsActive: 48 } });
}

function monitorujSystemWodny() {
  return Promise.resolve({ status: "OK", details: { pressure: "Normal", quality: "Good" } });
}

function monitorujWentylację() {
  return Promise.resolve({ status: "OK", details: { airQuality: "Excellent" } });
}

function monitorujTemperaturę() {
  return Promise.resolve({ status: "OK", details: { avgTemp: "22°C" } });
}

function monitorujBramyWybiegów() {
  return Promise.resolve({ status: "OK", details: { allGatesClosed: true } });
}

// Użycie funkcji monitorującej
monitorujWszystkieSystemy()
  .then(raport => {
    console.log("RAPORT MONITOROWANIA SYSTEMÓW:");
    console.log(JSON.stringify(raport, null, 2));

    // Podejmowanie działań na podstawie raportu
    if (raport.poziomZagrożenia === "CRITICAL") {
      console.log("UWAGA! KRYTYCZNY POZIOM ZAGROŻENIA! Ewakuacja parku!");
      ewakuujPark();
    } else if (raport.poziomZagrożenia === "HIGH") {
      console.log("UWAGA! WYSOKI POZIOM ZAGROŻENIA! Wstrzymanie wstępu gości!");
      wstrzymajWstęp();
    } else if (raport.systemyZProblemami.length > 0) {
      console.log("Wykryto problemy w niektórych systemach. Wysyłanie ekip technicznych...");
      wyślijEkipyTechniczne(raport.systemyZProblemami);
    } else {
      console.log("Wszystkie systemy działają prawidłowo.");
    }
  });

// Funkcje do obsługi różnych poziomów zagrożenia
function ewakuujPark() {
  console.log("Rozpoczynanie procedury ewakuacji parku...");
}

function wstrzymajWstęp() {
  console.log("Wstrzymywanie wstępu nowych gości do parku...");
}

function wyślijEkipyTechniczne(systemyZProblemami) {
  console.log(`Wysyłanie ekip technicznych do ${systemyZProblemami.length} systemów z problemami...`);
  systemyZProblemami.forEach(system => {
    console.log(`- Wysyłanie techników do systemu: ${system.nazwa} (błąd: ${system.błąd})`);
  });
}

W tym przykładzie Promise.allSettled() pozwala nam zebrać informacje o wszystkich systemach parku, niezależnie od tego, czy są sprawne czy nie. Dzięki temu możemy przygotować kompleksowy raport i podjąć odpowiednie działania na podstawie ogólnego stanu systemów.

Promise.allSettled() vs. Promise.all()

Porównajmy zachowanie Promise.allSettled() z Promise.all():

// Tablica zawierająca obiektnice, z których niektóre są odrzucone
const mieszanePromises = [
  Promise.resolve("Sukces 1"),
  Promise.reject(new Error("Błąd 1")),
  Promise.resolve("Sukces 2"),
  Promise.reject(new Error("Błąd 2"))
];

// Używając Promise.all
Promise.all(mieszanePromises)
  .then(results => {
    console.log("Wszystkie powiodły się:", results);
    // Ten kod nigdy się nie wykona z powodu odrzuconych Promise w tablicy
  })
  .catch(error => {
    console.error("Promise.all złapał błąd:", error.message);
    // Wyświetli: "Promise.all złapał błąd: Błąd 1"
    // Zauważ, że otrzymujemy tylko pierwszy błąd, a nie wszystkie
  });

// Używając Promise.allSettled
Promise.allSettled(mieszanePromises)
  .then(results => {
    console.log("Wyniki wszystkich Promise:");

    // Przetwarzamy wszystkie wyniki
    results.forEach((result, index) => {
      if (result.status === 'fulfilled') {
        console.log(`Promise ${index}: OK - ${result.value}`);
      } else {
        console.log(`Promise ${index}: BŁĄD - ${result.reason.message}`);
      }
    });

    // Wyświetli:
    // "Promise 0: OK - Sukces 1"
    // "Promise 1: BŁĄD - Błąd 1"
    // "Promise 2: OK - Sukces 2"
    // "Promise 3: BŁĄD - Błąd 2"
  });

Kluczowa różnica: Promise.all() kończy się niepowodzeniem przy pierwszym błędzie, podczas gdy Promise.allSettled() zawsze kończy się sukcesem z informacjami o wszystkich wynikach.

Promise.any() - sukces, gdy którakolwiek się powiedzie

Metoda Promise.any() (wprowadzona w ES2021) przyjmuje tablicę obietnic i zwraca nową obietnicę, która:

  • rozwiązuje się z wartością pierwszej spełnionej obietnicy
  • odrzuca się tylko wtedy, gdy wszystkie obietnice zostaną odrzucone, z obiektem AggregateError zawierającym wszystkie błędy

Jest to podobne do Promise.race(), ale z jedną kluczową różnicą: Promise.any() ignoruje odrzucone obietnice, czekając na pierwszą spełnioną obietnicę.

Przykład: Testowanie różnych bram ewakuacyjnych

function testBramyEwakuacyjnej(id) {
  console.log(`Testowanie bramy ewakuacyjnej #${id}...`);
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const działa = Math.random() > 0.6; // 40% szans na awarię
      if (działa) {
        resolve({
          id: id,
          status: "Operacyjna",
          czasOtwarcia: `${(Math.random() * 2 + 1).toFixed(1)}s`
        });
      } else {
        reject(new Error(`Brama #${id} nie reaguje na sygnał otwarcia`));
      }
    }, 1000 + Math.random() * 2000);
  });
}

// Próba otwarcia dowolnej działającej bramy
function znajdźDziałającąBramę() {
  console.log("Próba otwarcia dowolnej działającej bramy ewakuacyjnej...");

  // Testujemy wszystkie bramy równocześnie
  return Promise.any([
    testBramyEwakuacyjnej(1),
    testBramyEwakuacyjnej(2),
    testBramyEwakuacyjnej(3),
    testBramyEwakuacyjnej(4)
  ]);
}

// Użycie
znajdźDziałającąBramę()
  .then(działającaBrama => {
    console.log(`Znaleziono działającą bramę ewakuacyjną: #${działającaBrama.id}`);
    console.log(`Czas otwarcia: ${działającaBrama.czasOtwarcia}`);
    console.log("Rozpoczynanie ewakuacji przez tę bramę...");
  })
  .catch(error => {
    // Ten catch zostanie wykonany tylko wtedy, gdy wszystkie bramy zawiodą
    console.error("KRYTYCZNY BŁĄD: Wszystkie bramy ewakuacyjne nie działają!");
    console.error("Szczegóły:", error.errors.map(e => e.message).join(", "));
    console.log("Uruchamianie procedury awaryjnej wyłamania bram...");
  });

W tym przykładzie Promise.any() pozwala nam znaleźć pierwszą działającą bramę ewakuacyjną i natychmiast rozpocząć przez nią ewakuację, ignorując bramy, które nie działają. Tylko gdy wszystkie bramy zawodzą, całość kończy się niepowodzeniem.

Wybór odpowiedniej metody do kompozycji Promise

Podsumowując, mamy cztery główne metody do kompozycji Promise:

  1. Promise.all()

    • Użyj gdy: Potrzebujesz wszystkich wyników i wszystkie operacje muszą się powieść
    • Zachowanie: Wszystko albo nic
    • Wynik: Tablica wszystkich wyników (gdy wszystkie powiodą się)
    • Błąd: Pierwszy błąd (gdy którakolwiek zawiedzie)
  2. Promise.race()

    • Użyj gdy: Potrzebujesz tylko pierwszego wyniku (sukces lub błąd) - np. do timeoutów
    • Zachowanie: Pierwszy wygrywa (sukces lub błąd)
    • Wynik: Pierwszy sukces lub pierwszy błąd (cokolwiek nastąpi pierwsze)
  3. Promise.allSettled()

    • Użyj gdy: Potrzebujesz informacji o wszystkich operacjach, niezależnie od wyniku
    • Zachowanie: Czeka na zakończenie wszystkich (zawsze kończy się sukcesem)
    • Wynik: Tablica obiektów statusu dla wszystkich obietnic (sukces lub błąd)
  4. Promise.any()

    • Użyj gdy: Potrzebujesz pierwszego udanego wyniku, ignorując błędy
    • Zachowanie: Pierwszy sukces wygrywa
    • Wynik: Pierwszy udany wynik
    • Błąd: AggregateError zawierający wszystkie błędy (tylko gdy wszystkie zawiodą)

Wybór metody na podstawie scenariusza

Poniższa tabelka pomoże Ci wybrać odpowiednią metodę w zależności od Twoich potrzeb:

ScenariuszZalecana metoda
Musisz wykonać wiele zadań, gdzie wszystkie muszą się powieść (np. sprawdzenie gotowości systemu)Promise.all()
Potrzebujesz pierwszego dostępnego wyniku, nieważne którego (np. wyścig zasobów)Promise.race()
Chcesz ustawić timeout dla operacjiPromise.race() z timeoutem
Potrzebujesz pełnego raportu o wszystkich operacjach, nawet jeśli niektóre zawiodłyPromise.allSettled()
Potrzebujesz pierwszego udanego wyniku, ignorując błędy (np. próba różnych źródeł danych)Promise.any()

Praktyki zaawansowane

Dynamiczne tworzenie tablicy Promise

Często musimy dynamicznie tworzyć tablicę obietnic na podstawie danych:

// Pobieranie danych o wszystkich dinozaurach w parku
function pobierzDaneWszystkichDinozaurów(ids) {
  console.log(`Pobieranie danych dla ${ids.length} dinozaurów...`);

  // Mapowanie ID na obietnice
  const promises = ids.map(id => pobierzDaneDinozaura(id));

  // Użycie Promise.all do równoległego pobierania
  return Promise.all(promises);
}

// Użycie
const idDinozaurów = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

pobierzDaneWszystkichDinozaurów(idDinozaurów)
  .then(dinozaury => {
    console.log(`Pobrano dane ${dinozaury.length} dinozaurów`);

    // Obliczanie statystyk
    const mięsożerne = dinozaury.filter(d => d.diet === "carnivore").length;
    const roślinożerne = dinozaury.filter(d => d.diet === "herbivore").length;
    const wszystkożerne = dinozaury.filter(d => d.diet === "omnivore").length;

    console.log(`Statystyki: ${mięsożerne} mięsożernych, ${roślinożerne} roślinożernych, ${wszystkożerne} wszystkożernych`);
  })
  .catch(error => {
    console.error("Błąd pobierania danych:", error.message);
  });

Łączenie różnych metod kompozycji Promise

Możemy łączyć różne metody kompozycji Promise, aby uzyskać bardziej złożone zachowania:

function monitorujDinozaury() {
  // Pobieramy wszystkie sektory parku
  return pobierzWszystkieSektory()
    .then(sektory => {
      // Dla każdego sektora równolegle sprawdzamy dinozaury
      const obietniceSektorów = sektory.map(sektor => {
        // Dla każdego sektora używamy allSettled, aby mieć informacje o wszystkich dinozaurach
        const obietniceDinozaurów = sektor.dinozaury.map(dino =>
          sprawdźStatusDinozaura(dino.id)
            .catch(error => ({
              status: "error",
              dinoId: dino.id,
              message: error.message
            }))
        );

        // Używamy allSettled dla dinozaurów w obrębie sektora
        return Promise.allSettled(obietniceDinozaurów)
          .then(wyniki => ({
            sektor: sektor.id,
            nazwa: sektor.name,
            wyniki: wyniki
          }));
      });

      // Używamy all dla sektorów, bo potrzebujemy danych z wszystkich
      return Promise.all(obietniceSektorów);
    });
}

Obsługa zbyt wielu równoległych zapytań

Kiedy mamy do wykonania wiele operacji asynchronicznych, nie zawsze dobrym pomysłem jest uruchamianie ich wszystkich równocześnie - może to przeciążyć system. Możemy zaimplementować mechanizm ograniczający liczbę równoległych operacji:

// Funkcja wykonująca zadania z ograniczeniem równoległości
async function wykonajZadaniaZOgraniczeniem(zadania, maxRównoległe) {
  const wyniki = [];

  // Przetwarzamy zadania w porcjach
  for (let i = 0; i < zadania.length; i += maxRównoległe) {
    const porcja = zadania.slice(i, i + maxRównoległe);

    // Wykonujemy porcję zadań równolegle
    const wynikPorcji = await Promise.allSettled(porcja.map(zadanie => zadanie()));
    wyniki.push(...wynikPorcji);

    console.log(`Zakończono porcję ${Math.floor(i / maxRównoległe) + 1}/${Math.ceil(zadania.length / maxRównoległe)}`);
  }

  return wyniki;
}

// Przykład użycia
const zadaniaDinozaurów = Array.from({ length: 50 }, (_, i) => {
  return () => sprawdźStatusDinozaura(i + 1);
});

// Wykonujemy maksymalnie 5 zadań równocześnie
wykonajZadaniaZOgraniczeniem(zadaniaDinozaurów, 5)
  .then(wyniki => {
    console.log(`Zakończono sprawdzanie wszystkich ${wyniki.length} dinozaurów`);
    // Analiza wyników...
  });

Podsumowanie

Statyczne metody Promise (Promise.all(), Promise.race(), Promise.allSettled() i Promise.any()) zapewniają potężne narzędzia do kompozycji i koordynacji wielu operacji asynchronicznych. Wybór odpowiedniej metody zależy od konkretnych wymagań Twojej aplikacji:

  • Promise.all() - gdy potrzebujesz wszystkich wyników i wszystkie operacje muszą się powieść
  • Promise.race() - gdy potrzebujesz pierwszego wyniku lub chcesz zaimplementować timeout
  • Promise.allSettled() - gdy potrzebujesz informacji o wszystkich operacjach, niezależnie od wyniku
  • Promise.any() - gdy potrzebujesz pierwszego udanego wyniku, ignorując błędy

W Parku Jurajskim, jak i w każdej złożonej aplikacji JavaScript, umiejętność efektywnego komponowania operacji asynchronicznych jest kluczowa dla tworzenia responsywnych, wydajnych i niezawodnych systemów.

W następnym ćwiczeniu poznamy składnię async/await, która zapewnia jeszcze bardziej czytelny sposób pracy z asynchronicznym kodem.

Kod do tej lekcji: index.js
// Scope Chain Explorer - Zasięg zmiennych
console.log("ZASIĘG ZMIENNYCH W PARKU JURAJSKIM\n");

// Global scope
const parkName = "Jurassic Park";
let visitorCount = 0;

function managePark() {
  // Function scope
  const parkStatus = "OPEN";
  let securityLevel = 5;

  console.log("=== PARK MANAGEMENT ===");
  console.log(`Park: ${parkName}`); // Dostęp do global
  console.log(`Status: ${parkStatus}`);
  console.log(`Poziom bezpieczeństwa: ${securityLevel}`);

  function checkSecurity() {
    // Nested function scope
    const alertMessage = "Sprawdzanie bezpieczeństwa...";

    console.log(`\n${alertMessage}`);
    console.log(`Park: ${parkName}`); // Dostęp do global
    console.log(`Status parku: ${parkStatus}`); // Dostęp do parent function
    console.log(`Poziom: ${securityLevel}`); // Dostęp do parent function

    // Modyfikacja zmiennej z parent scope
    if (securityLevel < 8) {
      securityLevel = 8;
      console.log(`Podniesiono poziom bezpieczeństwa do: ${securityLevel}`);
    }

    function activateAlarm() {
      // Even deeper nested function
      const alarmCode = "RED";
      console.log(`\nALARM ${alarmCode}!`);
      console.log(`Park: ${parkName}`);
      console.log(`Status: ${parkStatus}`);
      console.log(`Bezpieczeństwo: ${securityLevel}`);

      // Nie możemy dostać się do alertMessage z checkSecurity
      // console.log(alertMessage); // To by działało!
    }

    activateAlarm();
  }

  checkSecurity();
  console.log(`\nPoziom po sprawdzeniu: ${securityLevel}`); // Zmieniony przez checkSecurity

  // console.log(alertMessage); // ERROR! alertMessage jest w function scope checkSecurity
}

managePark();

// console.log(parkStatus); // ERROR! parkStatus jest w function scope managePark

console.log(`\n=== BLOCK SCOPE (let/const) ===\n`);

if (true) {
  let blockVariable = "Jestem w bloku";
  const blockConstant = "Ja też!";
  var functionVariable = "Ja jestem var";

  console.log(blockVariable);
  console.log(blockConstant);
  console.log(functionVariable);
}

// console.log(blockVariable); // ERROR! let ma block scope
// console.log(blockConstant); // ERROR! const ma block scope
console.log(functionVariable); // OK! var ma function scope (lub global)

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. Które z poniższych jest microtask?

  2. 2. Co robi Promise.all()?

Zadania praktyczne w grze

  • Edytor kodu

    Użyj Promise.all() do równoległego wykonania trzech operacji monitoringu i wyświetl zbiorczy raport po zakończeniu wszystkich.

  • Układanie w pionie

    Uporządkuj chronologicznie mechanizmy asynchroniczności:

  • Klikanie w kolejności

    Ułóż elementy obsługi błędu w Promise:

  1. Zadanie z kodemPraktyka: Promise.all do równoległego monitoringu
  2. Ułóż w kolejnościEwolucja asynchroniczności w JavaScript
  3. PytanieMicrotask vs Macrotask
  4. PytaniePromise.all()
  5. Kliknij w kolejnościSkładnia .catch()

Przydatne artykuły