Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne

Łączenie Promise (then, catch, finally)

11 min czytania ·
W tej lekcji10

W poprzednim ćwiczeniu poznaliśmy podstawy tworzenia i używania obiektów Promise. Teraz zagłębimy się w techniki łączenia obietnic, aby budować bardziej złożone przepływy asynchroniczne. W systemie tak skomplikowanym jak Park Jurajski, często musimy wykonywać sekwencje operacji asynchronicznych, obsługiwać błędy i zapewniać poprawne działanie systemów.

Przypomnienie metod Promise

Zanim przejdziemy do zaawansowanych technik, przypomnijmy podstawowe metody obiektu Promise:

  1. then(onFulfilled, onRejected) - rejestruje funkcje zwrotne do wykonania, gdy Promise zostanie spełniony lub odrzucony
  2. catch(onRejected) - rejestruje funkcję zwrotną do wykonania, gdy Promise zostanie odrzucony
  3. finally(onFinally) - rejestruje funkcję zwrotną do wykonania, gdy Promise zostanie zakończony (niezależnie od wyniku)

Łańcuchowanie Promise z then()

Metoda .then() zawsze zwraca nowy obiekt Promise, co pozwala na budowanie łańcuchów operacji asynchronicznych. Każdy kolejny .then() otrzymuje wynik z poprzedniego.

Wyobraźmy sobie scenariusz transportu nowego dinozaura do Parku Jurajskiego:

function przygotujTransport(dinoId) {
  console.log(`Przygotowywanie transportu dla dinozaura #${dinoId}...`);
  return new Promise((resolve) => {
    setTimeout(() => {
      const transportInfo = {
        id: dinoId,
        vehicle: "Pojazd terenowy z zabezpieczoną klatką",
        readyTime: new Date().toISOString()
      };
      console.log("Transport przygotowany!");
      resolve(transportInfo);
    }, 2000);
  });
}

function załadujDinozaura(transportInfo) {
  console.log(`Ładowanie dinozaura #${transportInfo.id} do ${transportInfo.vehicle}...`);
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (transportInfo.id > 5) {
        // Większe ID = większy dinozaur = problemy z załadunkiem
        reject(new Error("Dinozaur za duży dla standardowego transportu!"));
        return;
      }

      const shipmentInfo = {
        ...transportInfo,
        loadedTime: new Date().toISOString(),
        status: "Dinozaur bezpiecznie załadowany"
      };
      console.log("Dinozaur załadowany!");
      resolve(shipmentInfo);
    }, 3000);
  });
}

function transportujDoParku(shipmentInfo) {
  console.log(`Transportowanie dinozaura #${shipmentInfo.id} do parku...`);
  return new Promise((resolve) => {
    setTimeout(() => {
      const deliveryInfo = {
        ...shipmentInfo,
        deliveryTime: new Date().toISOString(),
        location: "Wybieg główny",
        status: "Dostarczono"
      };
      console.log("Dinozaur bezpiecznie dostarczony do parku!");
      resolve(deliveryInfo);
    }, 4000);
  });
}

function umieśćWWybiegu(deliveryInfo) {
  console.log(`Przenoszenie dinozaura #${deliveryInfo.id} do wybiegu...`);
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // Symulacja 20% szansy na niepowodzenie
      if (Math.random() < 0.2) {
        reject(new Error("Dinozaur wykazuje agresję podczas wprowadzania do wybiegu!"));
        return;
      }

      const enclosureInfo = {
        ...deliveryInfo,
        enclosureId: `WYB-${deliveryInfo.id}`,
        enclosureTime: new Date().toISOString(),
        status: "W wybiegu"
      };
      console.log("Dinozaur bezpiecznie umieszczony w wybiegu!");
      resolve(enclosureInfo);
    }, 3000);
  });
}

// Używamy łańcucha Promise
console.log("Rozpoczynanie procesu transportu dinozaura #3...");

przygotujTransport(3)
  .then(transportInfo => {
    console.log("Etap 1 zakończony:", transportInfo);
    return załadujDinozaura(transportInfo);
  })
  .then(shipmentInfo => {
    console.log("Etap 2 zakończony:", shipmentInfo);
    return transportujDoParku(shipmentInfo);
  })
  .then(deliveryInfo => {
    console.log("Etap 3 zakończony:", deliveryInfo);
    return umieśćWWybiegu(deliveryInfo);
  })
  .then(enclosureInfo => {
    console.log("Proces zakończony sukcesem!");
    console.log("Raport końcowy:", enclosureInfo);
  })
  .catch(error => {
    console.error("Wystąpił błąd podczas procesu:", error.message);
    console.log("Uruchamianie procedur awaryjnych...");
  })
  .finally(() => {
    console.log("Proces transportu zakończony - raport został wysłany do administracji.");
  });

console.log("Inne operacje mogą być wykonywane równolegle...");

W powyższym przykładzie:

  1. Każda funkcja zwraca Promise, który rozwiązuje się z danymi
  2. Każdy .then() przejmuje wynik z poprzedniego etapu i przekazuje go do następnej funkcji
  3. Dane są przekazywane przez cały łańcuch, z każdym etapem dodającym nowe informacje
  4. Pojedynczy .catch() na końcu przechwytuje błędy z każdego etapu
  5. .finally() jest wykonywane niezależnie od sukcesu lub porażki

Wartości zwracane z then() i catch()

Wartość zwracana z funkcji callback w .then() lub .catch() staje się wartością, z którą rozwiązuje się Promise zwracany przez tę metodę. Daje nam to możliwość transformacji danych na każdym etapie łańcucha.

// Przykład transformacji danych w łańcuchu Promise
pobierzDaneDinozaura(5)
  .then(dinoData => {
    // Przekształcenie danych dinozaura na format używany w UI
    return {
      id: dinoData.id,
      name: dinoData.name || "Nieznany",
      display: `${dinoData.species} (${dinoData.age} lat)`,
      dangerLevel: dinoData.carnivore ? "Wysoki" : "Niski",
      location: dinoData.enclosureId
    };
  })
  .then(uiData => {
    // Dodajemy dodatkowe informacje UI
    return {
      ...uiData,
      icon: uiData.dangerLevel === "Wysoki" ? "!!" : "OK",
      description: `${uiData.icon} ${uiData.display} - Zagrożenie: ${uiData.dangerLevel}`
    };
  })
  .then(finalData => {
    console.log("Dane dla UI:", finalData);
    updateDinoCard(finalData); // Aktualizacja interfejsu użytkownika
  });

Obsługa błędów w łańcuchu Promise

Istnieje kilka strategii obsługi błędów w łańcuchach Promise:

1. Pojedynczy catch na końcu łańcucha

przygotujTransport(7) // Dinozaur z ID 7 jest za duży dla standardowego transportu
  .then(transportInfo => załadujDinozaura(transportInfo))
  .then(shipmentInfo => transportujDoParku(shipmentInfo))
  .then(deliveryInfo => umieśćWWybiegu(deliveryInfo))
  .then(enclosureInfo => {
    console.log("Sukces:", enclosureInfo);
  })
  .catch(error => {
    // Ten catch obsłuży błędy ze wszystkich poprzednich kroków
    console.error("Wystąpił błąd:", error.message);
    notyfikujAdministrację(error);
  });

2. Wiele catch'ów dla różnych etapów

przygotujTransport(7)
  .then(transportInfo => załadujDinozaura(transportInfo))
  .catch(error => {
    // Ten catch obsługuje błędy tylko z przygotujTransport i załadujDinozaura
    console.error("Błąd podczas przygotowania lub załadunku:", error.message);
    return zamówPowiększonyTransport(7); // Alternatywna ścieżka - zwracamy nowy Promise
  })
  .then(info => {
    // Ten then otrzyma albo wynik załadujDinozaura, albo zamówPowiększonyTransport
    return transportujDoParku(info);
  })
  .then(deliveryInfo => umieśćWWybiegu(deliveryInfo))
  .catch(error => {
    // Ten catch obsługuje błędy z transportujDoParku, umieśćWWybiegu lub zamówPowiększonyTransport
    console.error("Błąd podczas transportu lub umieszczania w wybiegu:", error.message);
    notyfikujZespółBezpieczeństwa(error);
    throw error; // Przekazujemy błąd dalej
  })
  .catch(error => {
    // Ten catch przechwytuje wszystkie nieobsłużone błędy
    console.error("Krytyczny błąd w procesie:", error.message);
    aktywujProceduryAwaryjne();
  });

function zamówPowiększonyTransport(dinoId) {
  console.log(`Zamawianie powiększonego transportu dla dinozaura #${dinoId}...`);
  // Implementacja zwracająca Promise
  return Promise.resolve({
    id: dinoId,
    vehicle: "Wzmocniony transport specjalny XL",
    status: "Przygotowany"
  });
}

3. Obsługa błędów wewnątrz funkcji then()

przygotujTransport(3)
  .then(transportInfo => {
    try {
      // Kod, który może wyrzucić wyjątki
      walidujTransport(transportInfo);
      return załadujDinozaura(transportInfo);
    } catch (error) {
      // Obsługa synchronicznych wyjątków
      console.error("Błąd walidacji transportu:", error.message);
      return naprawTransport(transportInfo); // Zwracamy nowy Promise
    }
  })
  .then(shipmentInfo => transportujDoParku(shipmentInfo))
  .catch(error => {
    // Obsługa pozostałych błędów
    console.error("Błąd procesu:", error.message);
  });

function walidujTransport(transportInfo) {
  if (!transportInfo.vehicle.includes("klatka")) {
    throw new Error("Transport nie ma odpowiedniego zabezpieczenia!");
  }
}

function naprawTransport(transportInfo) {
  console.log("Naprawianie problemów z transportem...");
  return Promise.resolve({
    ...transportInfo,
    vehicle: transportInfo.vehicle + " z wzmocnioną klatką",
    status: "Naprawiony"
  });
}

Transformacja błędów

Metoda .catch() może nie tylko obsłużyć błąd, ale także przetransformować go w sukces, zwracając wartość:

pobierzDaneDinozaura(999) // ID nie istnieje
  .catch(error => {
    console.log("Nie znaleziono dinozaura:", error.message);
    // Zamiast propagować błąd, zwracamy dane domyślne
    return {
      id: 999,
      name: "Nieznany",
      species: "Nieznany gatunek",
      age: "?",
      carnivore: true,
      enclosureId: "N/A"
    };
  })
  .then(dinoData => {
    // Ten then zostanie wykonany z danymi domyślnymi
    console.log("Dane dinozaura (domyślne lub rzeczywiste):", dinoData);
    updateUI(dinoData);
  });

Używanie metody finally()

Metoda .finally() jest używana do wykonania kodu czyszczącego, niezależnie od tego, czy Promise został spełniony czy odrzucony. Jest to idealne miejsce dla kodu, który musi zostać wykonany w obu przypadkach:

let connectionToDatabase = null;

connectToDinosaurDatabase()
  .then(connection => {
    connectionToDatabase = connection;
    return connection.query("SELECT * FROM dinosaurs WHERE species = 'Velociraptor'");
  })
  .then(raptors => {
    console.log(`Znaleziono ${raptors.length} velociraptorów w bazie danych`);
    processRaptors(raptors);
  })
  .catch(error => {
    console.error("Błąd podczas pracy z bazą danych:", error.message);
    notifyDatabaseAdmin(error);
  })
  .finally(() => {
    // Ten kod wykonuje się zawsze, niezależnie od sukcesu lub porażki
    if (connectionToDatabase) {
      console.log("Zamykanie połączenia z bazą danych...");
      connectionToDatabase.close(); // Zawsze zamykamy połączenie
    }
  });

Zagnieżdżone Promise vs. łańcuchowanie

Ważne jest, aby unikać zagnieżdżania Promise i zamiast tego używać łańcuchowania. Porównajmy dwa podejścia:

Nieprawidłowe - zagnieżdżanie Promise

// Złe podejście - zagnieżdżanie Promise prowadzi do "Promise Hell"
pobierzDaneDinozaura(1)
  .then(dino => {
    console.log("Dinozaur:", dino.name);

    pobierzDaneWybiegu(dino.enclosureId) // Zagnieżdżony Promise
      .then(enclosure => {
        console.log("Wybieg:", enclosure.name);

        pobierzPracowników(enclosure.id) // Kolejny zagnieżdżony Promise
          .then(staff => {
            console.log("Pracownicy:", staff.map(s => s.name).join(", "));

            // Jeszcze głębsze zagnieżdżenie...
            pobierzHistorięKarmienia(dino.id)
              .then(feedingHistory => {
                console.log("Historia karmienia:", feedingHistory);
              })
              .catch(error => {
                console.error("Błąd historii karmienia:", error.message);
              });
          })
          .catch(error => {
            console.error("Błąd pracowników:", error.message);
          });
      })
      .catch(error => {
        console.error("Błąd wybiegu:", error.message);
      });
  })
  .catch(error => {
    console.error("Błąd dinozaura:", error.message);
  });

Prawidłowe - łańcuchowanie Promise

// Dobre podejście - łańcuchowanie Promise
// Używamy zmiennych dla danych, które będziemy potrzebować w dalszych krokach
let dinoData, enclosureData;

pobierzDaneDinozaura(1)
  .then(dino => {
    dinoData = dino; // Zapisujemy dane dinozaura
    console.log("Dinozaur:", dino.name);
    return pobierzDaneWybiegu(dino.enclosureId); // Zwracamy Promise
  })
  .then(enclosure => {
    enclosureData = enclosure; // Zapisujemy dane wybiegu
    console.log("Wybieg:", enclosure.name);
    return pobierzPracowników(enclosure.id); // Zwracamy Promise
  })
  .then(staff => {
    console.log("Pracownicy:", staff.map(s => s.name).join(", "));
    return pobierzHistorięKarmienia(dinoData.id); // Zwracamy Promise
  })
  .then(feedingHistory => {
    console.log("Historia karmienia:", feedingHistory);
    // Możemy korzystać z zapisanych wcześniej danych
    console.log(`Podsumowanie dla ${dinoData.name} w wybiegu ${enclosureData.name}`);
  })
  .catch(error => {
    // Jeden catch obsługuje wszystkie błędy
    console.error("Wystąpił błąd:", error.message);
  });

Złożone operacje z Promise

Sekwencyjne wykonanie operacji asynchronicznych na tablicy

Czasami potrzebujemy wykonać operację asynchroniczną na każdym elemencie tablicy, jeden po drugim:

// Sekwencyjne karmienie dinozaurów
const dinosaurIds = [1, 2, 3, 4, 5];

// Funkcja karmienia jednego dinozaura
function nakarmDinozaura(id) {
  return new Promise((resolve, reject) => {
    console.log(`Rozpoczynam karmienie dinozaura #${id}...`);
    setTimeout(() => {
      if (id === 3) {
        reject(new Error(`Dinozaur #${id} odmawia jedzenia!`));
        return;
      }
      console.log(`Dinozaur #${id} nakarmiony!`);
      resolve({id, status: 'nakarmiony', time: new Date().toISOString()});
    }, 1000);
  });
}

// Sekwencyjne karmienie wszystkich dinozaurów
dinosaurIds.reduce((promise, dinoId) => {
  return promise
    .then(results => {
      // results to tablica wyników z poprzednich operacji
      return nakarmDinozaura(dinoId)
        .then(result => {
          // Dodaj wynik do tablicy wyników
          return [...results, result];
        })
        .catch(error => {
          console.error(`Błąd karmienia dinozaura #${dinoId}:`, error.message);
          // Dodaj informację o błędzie do wyników
          return [...results, {id: dinoId, status: 'błąd', error: error.message}];
        });
    });
}, Promise.resolve([]))  // Rozpocznij z pustą tablicą wyników
  .then(allResults => {
    console.log("Wszystkie dinozaury obsłużone:");
    console.log(allResults);

    // Sprawdzamy, czy wszystkie dinozaury zostały nakarmione
    const allFed = allResults.every(result => result.status === 'nakarmiony');
    if (allFed) {
      console.log("Wszystkie dinozaury zostały nakarmione!");
    } else {
      console.log("Nie wszystkie dinozaury zostały nakarmione - sprawdź raport.");
    }
  });

Wykonanie operacji asynchronicznych z ograniczoną liczbą równoległych zadań

// Funkcja do wykonania operacji asynchronicznych z ograniczoną liczbą równoległych zadań
async function wykonajZOgraniczeniem(tablica, funkcjaPromise, limitRównolegle) {
  const wszystkieWyniki = [];

  // Wykonujemy zadania w porcjach
  for (let i = 0; i < tablica.length; i += limitRównolegle) {
    const porcja = tablica.slice(i, i + limitRównolegle);

    // Uruchamiamy Promise.all dla porcji zadań
    const wyniki = await Promise.all(
      porcja.map(element =>
        funkcjaPromise(element)
          .catch(error => {
            console.error(`Błąd dla elementu ${element}:`, error.message);
            return { element, status: 'błąd', error: error.message };
          })
      )
    );

    wszystkieWyniki.push(...wyniki);
    console.log(`Zakończono porcję ${i / limitRównolegle + 1} (${wyniki.length} operacji)`);
  }

  return wszystkieWyniki;
}

// Użycie funkcji do równoległego, ale ograniczonego sprawdzania zdrowia dinozaurów
const wszystkieIdDinozaurów = Array.from({ length: 20 }, (_, i) => i + 1);

function sprawdźZdrowieDinozaura(id) {
  return new Promise((resolve, reject) => {
    console.log(`Sprawdzam zdrowie dinozaura #${id}...`);
    setTimeout(() => {
      // Symulacja losowego stanu zdrowia
      const health = Math.floor(Math.random() * 100);
      if (health < 30) {
        reject(new Error(`Dinozaur #${id} ma problemy zdrowotne! Poziom zdrowia: ${health}`));
        return;
      }
      console.log(`Dinozaur #${id} jest zdrowy. Poziom zdrowia: ${health}`);
      resolve({id, health, status: 'zdrowy'});
    }, 500 + Math.random() * 1000); // Losowy czas wykonania
  });
}

// Sprawdzamy zdrowie maksymalnie 5 dinozaurów naraz
wykonajZOgraniczeniem(wszystkieIdDinozaurów, sprawdźZdrowieDinozaura, 5)
  .then(wyniki => {
    console.log("Sprawdzanie zdrowia wszystkich dinozaurów zakończone:");

    const zdrowe = wyniki.filter(w => w.status === 'zdrowy').length;
    const chore = wyniki.filter(w => w.status === 'błąd').length;

    console.log(`Zdrowe: ${zdrowe}, Wymagające uwagi: ${chore}`);

    // Wyświetl dinozaury wymagające uwagi
    if (chore > 0) {
      console.log("Dinozaury wymagające interwencji weterynaryjnej:");
      wyniki
        .filter(w => w.status === 'błąd')
        .forEach(w => console.log(`- Dinozaur #${w.element}: ${w.error}`));
    }
  });

Dobre praktyki przy łączeniu Promise

  1. Zawsze zwracaj Promise z funkcji then() - zapewnia to prawidłowe łańcuchowanie i propagację wyników:

    .then(data => {
      // Źle - nie zwraca Promise, łańcuch zostanie przerwany
      processData(data);
    })
    
    .then(data => {
      // Dobrze - zwraca wynik przetwarzania do następnego then()
      return processData(data);
    })
  2. Używaj jednego catch() dla grupy powiązanych operacji - dzięki temu kod jest bardziej czytelny:

    pobierzDaneWybiegu(5)
      .then(data => updateEnclosureStatus(data))
      .then(status => notifyStaff(status))
      .catch(error => {
        // Jeden catch dla całej operacji aktualizacji wybiegu
        handleEnclosureError(error);
      });
    
    // Nowa, niepowiązana operacja z własnym catch
    pobierzListeGości()
      .then(visitors => updateVisitorCount(visitors))
      .catch(error => {
        // Oddzielny catch dla operacji związanej z gośćmi
        handleVisitorError(error);
      });
  3. Używaj finally() do kodu czyszczącego - niezależnie od sukcesu czy porażki:

    otwórzBrameWybiegu(enclosureId)
      .then(() => przeniośDinozaura(dinoId, enclosureId))
      .catch(error => {
        logError("Błąd przenoszenia:", error);
        throw error; // Propaguj błąd dalej
      })
      .finally(() => {
        // Zawsze zamykaj bramę, niezależnie od wyniku
        zamknijBrameWybiegu(enclosureId);
      });
  4. Unikaj zbyt głębokich łańcuchów Promise - rozbijaj je na mniejsze, nazwane funkcje:

    // Zamiast jednego długiego łańcucha:
    function przenieśDinozauraDoNowegoWybiegu(dinoId, newEnclosureId) {
      return pobierzDaneDinozaura(dinoId)
        .then(dino => {
          // Sprawdz aktualny wybieg
          return pobierzDaneWybiegu(dino.enclosureId)
            .then(oldEnclosure => {
              // Przygotuj nowy wybieg
              return pobierzDaneWybiegu(newEnclosureId)
                .then(newEnclosure => {
                  // Sprawdz kompatybilność
                  // ... więcej zagnieżdżonych then...
                });
            });
        });
    }
    
    // Lepiej - rozbij na mniejsze funkcje:
    function przenieśDinozauraDoNowegoWybiegu(dinoId, newEnclosureId) {
      return pobierzDaneDinozauraZAktualnymWybiegiem(dinoId)
        .then(data => sprawdźKompatybilnośćWybiegów(data, newEnclosureId))
        .then(data => wykonajTransfer(data));
    }
    
    function pobierzDaneDinozauraZAktualnymWybiegiem(dinoId) {
      let dinoData;
      return pobierzDaneDinozaura(dinoId)
        .then(dino => {
          dinoData = dino;
          return pobierzDaneWybiegu(dino.enclosureId);
        })
        .then(oldEnclosure => {
          return { dino: dinoData, oldEnclosure };
        });
    }
    
    function sprawdźKompatybilnośćWybiegów(data, newEnclosureId) {
      return pobierzDaneWybiegu(newEnclosureId)
        .then(newEnclosure => {
          // Sprawdz kompatybilność
          return { ...data, newEnclosure };
        });
    }
    
    function wykonajTransfer(data) {
      // Implementacja transferu
      return Promise.resolve({ status: "zakończony", ...data });
    }

Podsumowanie

Łączenie Promise za pomocą .then(), .catch() i .finally() daje potężne narzędzia do budowania złożonych przepływów asynchronicznych. Dobrze zaprojektowany łańcuch Promise może sprawiać, że nawet skomplikowane operacje asynchroniczne, takie jak zarządzanie transportem dinozaurów w Parku Jurajskim, stają się czytelne i łatwe w utrzymaniu.

Kluczowe zasady to:

  1. Zawsze zwracaj Promise z funkcji w .then() aby kontynuować łańcuch
  2. Używaj .catch() do jednolitej obsługi błędów
  3. Wykorzystuj .finally() do operacji czyszczących
  4. Unikaj zagnieżdżania Promise na rzecz łańcuchowania
  5. Rozbijaj skomplikowane operacje na mniejsze, nazwane funkcje

W następnym ćwiczeniu omówimy bardziej zaawansowane metody pracy z wieloma Promise jednocześnie, takie jak Promise.all(), Promise.race() i Promise.allSettled().

Kod do tej lekcji: index.js
// Arrow Function Converter - Nowoczesne funkcje
console.log("FUNKCJE STRZAŁKOWE W PARKU JURAJSKIM\n");

// Tradycyjna funkcja
function calculateFeedingCost(dinosaurCount, costPerDinosaur) {
  return dinosaurCount * costPerDinosaur;
}

// Funkcja strzałkowa - krótsza składnia
const calculateFeedingCostArrow = (dinosaurCount, costPerDinosaur) => {
  return dinosaurCount * costPerDinosaur;
};

// Funkcja strzałkowa - implicit return (bez {})
const calculateFeedingCostShort = (dinosaurCount, costPerDinosaur) =>
  dinosaurCount * costPerDinosaur;

console.log("=== PORÓWNANIE SKŁADNI ===\n");

const trexCount = 3;
const costPerTRex = 5000;

console.log("Tradycyjna funkcja:");
console.log(`Koszt: $${calculateFeedingCost(trexCount, costPerTRex)}`);

console.log("\nFunkcja strzałkowa:");
console.log(`Koszt: $${calculateFeedingCostArrow(trexCount, costPerTRex)}`);

console.log("\nFunkcja strzałkowa (short):");
console.log(`Koszt: $${calculateFeedingCostShort(trexCount, costPerTRex)}`);

// Funkcje strzałkowe w array methods
console.log("\n=== FUNKCJE STRZAŁKOWE Z TABLICAMI ===\n");

const dinosaurs = [
  { name: 'T-Rex', danger: 10 },
  { name: 'Velociraptor', danger: 8 },
  { name: 'Triceratops', danger: 3 },
  { name: 'Brachiosaurus', danger: 2 }
];

// Filter - tylko niebezpieczne
const dangerous = dinosaurs.filter(dino => dino.danger > 5);
console.log("Niebezpieczne dinozaury:");
dangerous.forEach(dino => console.log(`  - ${dino.name} (zagrożenie: ${dino.danger}/10)`));

// Map - lista nazw
const names = dinosaurs.map(dino => dino.name);
console.log("\nWszystkie gatunki:", names.join(', '));

// Reduce - średni poziom zagrożenia
const avgDanger = dinosaurs.reduce((sum, dino) => sum + dino.danger, 0) / dinosaurs.length;
console.log(`\nŚrednie zagrożenie: ${avgDanger.toFixed(1)}/10`);

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 metoda .then() na Promise?

  2. 2. Do czego służy metoda .catch() w Promise?

Zadania praktyczne w grze

  • Edytor kodu

    Przepisz callback hell na Promise chain - połącz trzy operacje asynchroniczne za pomocą .then() i dodaj obsługę błędów przez .catch().

  • Układanie w pionie

    Uporządkuj etapy narastania zagnieżdżeń callback (callback hell):

  1. PytaniePromise.then()
  2. PytaniePromise.catch()
  3. Zadanie z kodemPraktyka: Łańcuch Promise (then/catch)
  4. Ułóż w kolejnościEtapy callback hell

Przydatne artykuły