Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne
Łączenie Promise (then, catch, finally)
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:
- then(onFulfilled, onRejected) - rejestruje funkcje zwrotne do wykonania, gdy Promise zostanie spełniony lub odrzucony
- catch(onRejected) - rejestruje funkcję zwrotną do wykonania, gdy Promise zostanie odrzucony
- 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:
- Każda funkcja zwraca Promise, który rozwiązuje się z danymi
- Każdy
.then()przejmuje wynik z poprzedniego etapu i przekazuje go do następnej funkcji - Dane są przekazywane przez cały łańcuch, z każdym etapem dodającym nowe informacje
- Pojedynczy
.catch()na końcu przechwytuje błędy z każdego etapu .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
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); })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); });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); });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:
- Zawsze zwracaj Promise z funkcji w
.then()aby kontynuować łańcuch - Używaj
.catch()do jednolitej obsługi błędów - Wykorzystuj
.finally()do operacji czyszczących - Unikaj zagnieżdżania Promise na rzecz łańcuchowania
- 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. Co robi metoda .then() na Promise?
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):