Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne

Tworzenie i obsługa obiektów Promise

12 min czytania ·
W tej lekcji9

W poprzedniej lekcji przyjrzeliśmy się funkcjom callback i problemowi "callback hell", który może wystąpić przy złożonych operacjach asynchronicznych. Teraz poznamy nowocześniejsze rozwiązanie - obiekty Promise (obietnice), które zapewniają elegantszy sposób obsługi asynchroniczności w JavaScript.

Czym są obiekty Promise?

Promise to obiekt reprezentujący ostateczne zakończenie (lub niepowodzenie) operacji asynchronicznej i jej rezultat. Można o nim myśleć jak o "obietnicy" uzyskania pewnego wyniku w przyszłości.

W kontekście Parku Jurajskiego, Promise jest jak zlecenie badania DNA dinozaura do laboratorium. Laboratoria nie zwracają wyników natychmiast - zamiast tego dają ci bilet z numerem, który reprezentuje "obietnicę" dostarczenia wyników, gdy badanie zostanie zakończone.

Promise może znajdować się w jednym z trzech stanów:

  • Pending (oczekiwanie) - stan początkowy, ani zakończony sukcesem, ani odrzucony
  • Fulfilled (spełniony) - operacja zakończyła się sukcesem, Promise został rozwiązany z wartością
  • Rejected (odrzucony) - operacja nie powiodła się, Promise został odrzucony z powodem (błędem)

Tworzenie Promise

Utworzenie nowego Promise w JavaScript wygląda następująco:

const dnaAnalysisPromise = new Promise((resolve, reject) => {
  // Symulacja badania DNA dinozaura (trwa 3 sekundy)
  console.log("Analizowanie próbki DNA dinozaura...");

  setTimeout(() => {
    const successRate = Math.random();

    if (successRate > 0.2) {
      // Analiza zakończona sukcesem
      const results = {
        species: "Velociraptor",
        age: "Około 68 milionów lat",
        diet: "Mięsożerca",
        geneticMarkers: ["ACGT-237", "TGGC-118", "GACT-339"]
      };

      resolve(results); // Spełnienie obietnicy
    } else {
      // Analiza zakończona niepowodzeniem
      reject(new Error("Próbka DNA uszkodzona lub niewystarczająca")); // Odrzucenie obietnicy
    }
  }, 3000);
});

W powyższym przykładzie:

  1. Tworzymy nowy obiekt Promise, który przyjmuje funkcję executor z dwoma argumentami: resolve i reject
  2. Wewnątrz funkcji executor wykonujemy operację asynchroniczną (symulowaną przez setTimeout)
  3. Jeśli operacja się powiedzie, wywołujemy resolve(wynik) aby spełnić obietnicę
  4. Jeśli operacja się nie powiedzie, wywołujemy reject(powód) aby odrzucić obietnicę

Użycie Promise - then, catch i finally

Aby obsłużyć wynik Promise, używamy metod then(), catch() i finally():

console.log("Wysłanie próbki do laboratorium...");

dnaAnalysisPromise
  .then(results => {
    console.log("Analiza DNA zakończona sukcesem!");
    console.log(`Gatunek: ${results.species}`);
    console.log(`Wiek: ${results.age}`);
    console.log(`Dieta: ${results.diet}`);
    console.log("Markery genetyczne:", results.geneticMarkers.join(", "));
    return results; // Możemy zwrócić wartość, która będzie przekazana do następnego .then()
  })
  .catch(error => {
    console.error("Błąd analizy DNA:", error.message);
    return "Brak danych"; // Zwracamy domyślną wartość w przypadku błędu
  })
  .finally(() => {
    console.log("Procedura analizy DNA zakończona - niezależnie od wyniku.");
    // finally nie przyjmuje żadnych argumentów i nic nie zwraca
  });

console.log("Kontynuacja pracy podczas analizy DNA...");

Wynik wykonania (w przypadku sukcesu):

Wysłanie próbki do laboratorium...
Analizowanie próbki DNA dinozaura...
Kontynuacja pracy podczas analizy DNA...
(po 3 sekundach)
Analiza DNA zakończona sukcesem!
Gatunek: Velociraptor
Wiek: Około 68 milionów lat
Dieta: Mięsożerca
Markery genetyczne: ACGT-237, TGGC-118, GACT-339
Procedura analizy DNA zakończona - niezależnie od wyniku.
  • then() - przyjmuje funkcję callback, która zostanie wywołana, gdy Promise zostanie spełniony (resolved). Callback otrzymuje wartość, z którą Promise został rozwiązany.
  • catch() - przyjmuje funkcję callback, która zostanie wywołana, gdy Promise zostanie odrzucony (rejected). Callback otrzymuje błąd, z którym Promise został odrzucony.
  • finally() - przyjmuje funkcję callback, która zostanie wywołana, gdy Promise zostanie zakończony, niezależnie od tego, czy został spełniony, czy odrzucony. Callback nie otrzymuje żadnych argumentów.

Łańcuchowanie obietnic (promise chaining)

Jedną z największych zalet Promise jest możliwość łańcuchowania operacji asynchronicznych. Każde wywołanie .then() zwraca nowy Promise, co pozwala na tworzenie sekwencji operacji asynchronicznych bez zagnieżdżania.

Wyobraźmy sobie proces tworzenia nowego dinozaura w Parku Jurajskim:

function pobierzDNAZBazyDanych(gatunekId) {
  return new Promise((resolve, reject) => {
    console.log(`Pobieranie DNA dla gatunku ID: ${gatunekId}...`);
    setTimeout(() => {
      if (gatunekId > 0) {
        resolve(`dna_sequence_${gatunekId}`);
      } else {
        reject(new Error("Nieprawidłowe ID gatunku"));
      }
    }, 1000);
  });
}

function przygotujEmbrion(dnaSequence) {
  return new Promise((resolve, reject) => {
    console.log(`Przygotowywanie embriona z sekwencji DNA: ${dnaSequence}...`);
    setTimeout(() => {
      if (dnaSequence.includes("dna_sequence")) {
        resolve(`embryo_${dnaSequence}`);
      } else {
        reject(new Error("Nieprawidłowa sekwencja DNA"));
      }
    }, 1500);
  });
}

function inkubujJajo(embryo) {
  return new Promise((resolve, reject) => {
    console.log(`Inkubacja jaja z embrionem: ${embryo}...`);
    setTimeout(() => {
      if (embryo.includes("embryo_")) {
        resolve(`dino_baby_${embryo.replace("embryo_", "")}`);
      } else {
        reject(new Error("Nieprawidłowy embrion"));
      }
    }, 2000);
  });
}

function wychowajDinozaura(baby) {
  return new Promise((resolve, reject) => {
    console.log(`Wychowywanie młodego dinozaura: ${baby}...`);
    setTimeout(() => {
      if (baby.includes("dino_baby_")) {
        resolve(`adult_dino_${baby.replace("dino_baby_", "")}`);
      } else {
        reject(new Error("Nieprawidłowy młody dinozaur"));
      }
    }, 1500);
  });
}

// Użycie łańcucha obietnic
console.log("Rozpoczynanie procesu tworzenia dinozaura...");

pobierzDNAZBazyDanych(5)
  .then(dna => {
    console.log(`DNA pobrane: ${dna}`);
    return przygotujEmbrion(dna); // Zwrócenie nowej obietnicy
  })
  .then(embryo => {
    console.log(`Embrion przygotowany: ${embryo}`);
    return inkubujJajo(embryo); // Zwrócenie nowej obietnicy
  })
  .then(baby => {
    console.log(`Dinozaur wykluty: ${baby}`);
    return wychowajDinozaura(baby); // Zwrócenie nowej obietnicy
  })
  .then(adultDino => {
    console.log(`Dinozaur gotowy do wprowadzenia do parku: ${adultDino}`);
  })
  .catch(error => {
    console.error("Błąd w procesie tworzenia dinozaura:", error.message);
  })
  .finally(() => {
    console.log("Proces tworzenia dinozaura zakończony.");
  });

Porównajmy to z wersją wykorzystującą callbacki, która wyglądałaby mniej więcej tak:

pobierzDNAZBazyDanych(5, function(error, dna) {
  if (error) {
    console.error("Błąd pobierania DNA:", error.message);
    console.log("Proces tworzenia dinozaura zakończony.");
    return;
  }

  console.log(`DNA pobrane: ${dna}`);
  przygotujEmbrion(dna, function(error, embryo) {
    if (error) {
      console.error("Błąd przygotowania embriona:", error.message);
      console.log("Proces tworzenia dinozaura zakończony.");
      return;
    }

    console.log(`Embrion przygotowany: ${embryo}`);
    inkubujJajo(embryo, function(error, baby) {
      if (error) {
        console.error("Błąd inkubacji jaja:", error.message);
        console.log("Proces tworzenia dinozaura zakończony.");
        return;
      }

      console.log(`Dinozaur wykluty: ${baby}`);
      wychowajDinozaura(baby, function(error, adultDino) {
        if (error) {
          console.error("Błąd wychowywania dinozaura:", error.message);
          console.log("Proces tworzenia dinozaura zakończony.");
          return;
        }

        console.log(`Dinozaur gotowy do wprowadzenia do parku: ${adultDino}`);
        console.log("Proces tworzenia dinozaura zakończony.");
      });
    });
  });
});

Jak widać, wersja z Promise jest znacznie czytelniejsza i łatwiejsza w utrzymaniu.

Przekształcanie funkcji opartych na callbackach na Promise

Często musimy pracować z API lub bibliotekami, które używają funkcji opartych na callbackach. Możemy je przekształcić na Promise za pomocą funkcji opakowującej:

// Funkcja oparta na callbacku (Node-style)
function pobierzDaneWybiegu(wybiegId, callback) {
  setTimeout(() => {
    if (wybiegId <= 0) {
      callback(new Error("Nieprawidłowe ID wybiegu"));
      return;
    }

    const wybiegData = {
      id: wybiegId,
      nazwa: `Wybieg ${wybiegId}`,
      powierzchnia: 1000 * wybiegId,
      typ: wybiegId % 2 === 0 ? "Lądowy" : "Wodny"
    };

    callback(null, wybiegData);
  }, 1000);
}

// Przekształcenie na Promise
function pobierzDaneWybieguPromise(wybiegId) {
  return new Promise((resolve, reject) => {
    pobierzDaneWybiegu(wybiegId, (error, data) => {
      if (error) {
        reject(error); // Odrzucenie Promise w przypadku błędu
      } else {
        resolve(data); // Rozwiązanie Promise z danymi
      }
    });
  });
}

// Użycie wersji z Promise
pobierzDaneWybieguPromise(3)
  .then(data => {
    console.log("Dane wybiegu:", data);
  })
  .catch(error => {
    console.error("Błąd:", error.message);
  });

Ten wzorzec jest tak powszechny, że Node.js oferuje wbudowaną funkcję util.promisify() do automatycznego przekształcania funkcji opartych na callbackach na funkcje zwracające Promise.

Statyczne metody Promise

JavaScript oferuje kilka statycznych metod na obiekcie Promise, które są bardzo przydatne w różnych scenariuszach:

Promise.resolve() i Promise.reject()

Te metody tworzą Promise, który jest natychmiast rozwiązany lub odrzucony z podaną wartością:

// Natychmiastowe rozwiązanie
const resolvedPromise = Promise.resolve("Dane dinozaura");

resolvedPromise.then(data => {
  console.log("Rozwiązane z:", data); // "Rozwiązane z: Dane dinozaura"
});

// Natychmiastowe odrzucenie
const rejectedPromise = Promise.reject(new Error("Brak dostępu do dinozaura"));

rejectedPromise.catch(error => {
  console.error("Odrzucone z:", error.message); // "Odrzucone z: Brak dostępu do dinozaura"
});

Promise.all()

Przyjmuje tablicę obietnic i zwraca nową obietnicę, która rozwiązuje się, gdy wszystkie obietnice w tablicy zostaną rozwiązane, lub odrzuca się, gdy którakolwiek z obietnic zostanie odrzucona:

// Pobieranie danych o trzech dinozaurach równolegle
const dino1Promise = pobierzDaneDinozaura(1);
const dino2Promise = pobierzDaneDinozaura(2);
const dino3Promise = pobierzDaneDinozaura(3);

Promise.all([dino1Promise, dino2Promise, dino3Promise])
  .then(results => {
    // results to tablica wyników w kolejności obietnic
    console.log("Wszystkie dane dinozaurów pobrane:");
    console.log("Dinozaur 1:", results[0]);
    console.log("Dinozaur 2:", results[1]);
    console.log("Dinozaur 3:", results[2]);

    // Możemy teraz zrobić coś z wszystkimi danymi naraz
    const łącznaWaga = results.reduce((sum, dino) => sum + dino.waga, 0);
    console.log(`Łączna waga wszystkich dinozaurów: ${łącznaWaga} kg`);
  })
  .catch(error => {
    // Jeśli choć jedna obietnica zostanie odrzucona, cała operacja się nie powiedzie
    console.error("Nie udało się pobrać danych wszystkich dinozaurów:", error.message);
  });

Promise.race()

Przyjmuje tablicę obietnic i zwraca nową obietnicę, która rozwiązuje się lub odrzuca z wynikiem pierwszej rozwiązanej lub odrzuconej obietnicy:

// Symulacja monitorowania różnych systemów parku
function monitorujOgrodzenie() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.random() > 0.8) {
        reject(new Error("Awaria ogrodzenia w sektorze B!"));
      } else {
        resolve("Ogrodzenie działa prawidłowo");
      }
    }, 1000 + Math.random() * 4000); // 1-5 sekund
  });
}

function monitorujZasilanie() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.random() > 0.9) {
        reject(new Error("Awaria głównego zasilania!"));
      } else {
        resolve("Zasilanie działa prawidłowo");
      }
    }, 1000 + Math.random() * 4000); // 1-5 sekund
  });
}

function monitorujKamery() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.random() > 0.7) {
        reject(new Error("Utrata sygnału z kamer w sektorze D!"));
      } else {
        resolve("Kamery działają prawidłowo");
      }
    }, 1000 + Math.random() * 4000); // 1-5 sekund
  });
}

// Chcemy znać pierwszy alarm, który się pojawi
Promise.race([
  monitorujOgrodzenie(),
  monitorujZasilanie(),
  monitorujKamery()
])
  .then(status => {
    console.log("Pierwszy status systemu:", status);
  })
  .catch(error => {
    console.error("ALARM! Pierwszy wykryty problem:", error.message);
    // Tutaj uruchamiamy procedury awaryjne
    uruchomProceduręAwaryjną();
  });

function uruchomProceduręAwaryjną() {
  console.log("Uruchamianie procedury awaryjnej...");
  // Kod procedury awaryjnej
}

Promise.allSettled()

Wprowadzony w ES2020, przyjmuje tablicę obietnic i zwraca nową obietnicę, która rozwiązuje się, gdy wszystkie obietnice w tablicy zostaną zakończone (rozwiązane lub odrzucone):

// Monitorowanie wszystkich systemów parku
Promise.allSettled([
  monitorujOgrodzenie(),
  monitorujZasilanie(),
  monitorujKamery()
])
  .then(results => {
    console.log("Status wszystkich systemów:");

    // Każdy wynik ma status 'fulfilled' lub 'rejected'
    results.forEach((result, index) => {
      const systemNames = ["Ogrodzenie", "Zasilanie", "Kamery"];

      if (result.status === 'fulfilled') {
        console.log(`${systemNames[index]}: OK - ${result.value}`);
      } else {
        console.log(`${systemNames[index]}: BŁĄD - ${result.reason.message}`);
      }
    });

    // Sprawdzenie, czy jakikolwiek system zgłosił alarm
    const awarie = results.filter(result => result.status === 'rejected');
    if (awarie.length > 0) {
      console.log(`UWAGA: Wykryto ${awarie.length} awarie systemów!`);
      uruchomProceduręAwaryjną();
    }
  });

Obsługa błędów w Promise

Prawidłowa obsługa błędów jest kluczowa, zwłaszcza w asynchronicznym kodzie. Promise zapewniają ujednolicony sposób obsługi błędów za pomocą metody catch():

pobierzDNAZBazyDanych(-1) // Nieprawidłowe ID, spowoduje błąd
  .then(dna => {
    console.log(`DNA pobrane: ${dna}`);
    return przygotujEmbrion(dna);
  })
  .then(embryo => {
    console.log(`Embrion przygotowany: ${embryo}`);
    return inkubujJajo(embryo);
  })
  .then(baby => {
    console.log(`Dinozaur wykluty: ${baby}`);
    return wychowajDinozaura(baby);
  })
  .then(adultDino => {
    console.log(`Dinozaur gotowy do wprowadzenia do parku: ${adultDino}`);
  })
  .catch(error => {
    // Ten catch obsłuży błędy ze wszystkich poprzednich Promise
    console.error("Błąd w procesie tworzenia dinozaura:", error.message);

    // Możemy tu rejestrować błędy, informować użytkownika lub podejmować działania naprawcze
    powiadomLabDoBadania();

    // Możemy też zwrócić wartość, która zostanie przekazana do następnego .then()
    return "Próba utworzenia dinozaura nie powiodła się";
  })
  .then(message => {
    // Ten .then() zostanie wykonany po .catch()
    console.log(message); // "Próba utworzenia dinozaura nie powiodła się"

    // Możemy tu zainicjować procedury czyszczenia lub podjąć alternatywne działania
    return ponowUruchomProcedurę();
  })
  .catch(error => {
    // Ten catch obsłuży błędy z ponowUruchomProcedurę()
    console.error("Błąd ponownego uruchomienia:", error.message);
  });

function powiadomLabDoBadania() {
  console.log("Powiadamianie laboratorium o problemie z DNA...");
}

function ponowUruchomProcedurę() {
  console.log("Ponowne uruchamianie procedury z zapasowym DNA...");
  return "Procedura uruchomiona ponownie";
}

Ważne zasady obsługi błędów w Promise:

  1. Metoda catch() przechwytuje błędy z wszystkich poprzedzających ją metod then()
  2. Jeśli w funkcji wewnątrz .then() zostanie wyrzucony wyjątek, Promise zostanie odrzucony z tym wyjątkiem
  3. Możesz mieć wiele metod catch() w łańcuchu Promise, aby obsłużyć różne typy błędów
  4. Po catch() można kontynuować łańcuch z kolejnymi metodami then()

Powszechne pułapki związane z Promise

1. Zapominanie o zwracaniu Promise

Częstym błędem jest zapominanie o zwracaniu Promise z funkcji, co prowadzi do nieoczekiwanego zachowania:

// Błędnie - nie zwracamy Promise z funkcji
function pobierzIZapiszDane(id) {
  pobierzDaneDinozaura(id) // To zwraca Promise, ale nie przekazujemy go dalej
    .then(data => {
      return zapiszDane(data); // Ten Promise nie jest widoczny na zewnątrz
    });

  // Funkcja nie zwraca jawnie wartości, więc domyślnie zwraca undefined
}

// Poprawnie - zwracamy Promise
function pobierzIZapiszDane(id) {
  return pobierzDaneDinozaura(id) // Zwracamy Promise
    .then(data => {
      return zapiszDane(data); // Ten Promise jest teraz częścią łańcucha
    });
}

2. Nieobsługiwanie błędów

Nieobsłużone odrzucone Promise mogą powodować trudne do zdiagnozowania problemy:

// Źle - brak obsługi błędów
pobierzDaneDinozaura(999) // ID nie istnieje
  .then(data => {
    // Ten kod nie zostanie wykonany, gdy Promise zostanie odrzucony
    wyświetlDane(data);
  });
// Jeśli Promise zostanie odrzucony, błąd nie zostanie obsłużony!

// Dobrze - zawsze obsługuj błędy
pobierzDaneDinozaura(999)
  .then(data => {
    wyświetlDane(data);
  })
  .catch(error => {
    console.error("Nie udało się pobrać danych:", error.message);
    wyświetlBłąd(error);
  });

3. Promise Hell

Choć Promise pomagają uniknąć Callback Hell, można wpaść w podobną pułapkę, zagnieżdżając Promise zamiast ich łańcuchowania:

// Źle - zagnieżdżanie Promise (Promise Hell)
pobierzDaneDinozaura(1)
  .then(dino => {
    pobierzDaneWybiegu(dino.wybiegId) // Zagnieżdżony Promise
      .then(wybieg => {
        pobierzPracowników(wybieg.id) // Kolejny zagnieżdżony Promise
          .then(pracownicy => {
            console.log("Dane dinozaura:", dino);
            console.log("Dane wybiegu:", wybieg);
            console.log("Pracownicy:", pracownicy);
          });
      });
  });

// Dobrze - łańcuchowanie Promise
pobierzDaneDinozaura(1)
  .then(dino => {
    dinoData = dino; // Zachowaj dane do późniejszego użycia
    return pobierzDaneWybiegu(dino.wybiegId); // Zwróć Promise
  })
  .then(wybieg => {
    wybiegData = wybieg; // Zachowaj dane do późniejszego użycia
    return pobierzPracowników(wybieg.id); // Zwróć Promise
  })
  .then(pracownicy => {
    console.log("Dane dinozaura:", dinoData);
    console.log("Dane wybiegu:", wybiegData);
    console.log("Pracownicy:", pracownicy);
  })
  .catch(error => {
    console.error("Wystąpił błąd:", error.message);
  });

Podsumowanie

Promise to potężny mechanizm JavaScript do obsługi operacji asynchronicznych, który oferuje wiele zalet w porównaniu z tradycyjnymi callbackami:

  1. Lepsza czytelność - Łańcuchowanie zamiast zagnieżdżania
  2. Lepsze zarządzanie błędami - Jednolity mechanizm obsługi błędów za pomocą .catch()
  3. Bardziej przewidywalny przepływ - Łatwiejsze sekwencjonowanie operacji asynchronicznych
  4. Łatwiejsze operacje równoległe - Metody takie jak Promise.all() i Promise.race()

Promise stanowią podstawę dla jeszcze nowszego mechanizmu asynchronicznego w JavaScript - async/await, który poznamy w przyszłych lekcjach. W Parku Jurajskim, jak i w prawdziwym programowaniu, dobre zarządzanie operacjami asynchronicznymi jest kluczem do tworzenia niezawodnych i łatwych w utrzymaniu systemów.

W kolejnym ćwiczeniu zobaczymy, jak łączyć Promise i tworzyć bardziej złożone przepływy asynchroniczne.

Kod do tej lekcji: index.js
// Multi-Species Counter - Licznik gatunków
console.log("LICZNIK GATUNKÓW DINOZAURÓW\n");

// Funkcja zliczająca dinozaury według gatunku
function countSpecies(dinosaurs) {
  const counter = {};

  for (let dino of dinosaurs) {
    if (counter[dino]) {
      counter[dino]++;
    } else {
      counter[dino] = 1;
    }
  }

  return counter;
}

// Funkcja wyświetlająca raport
function displaySpeciesReport(counter) {
  console.log("=== RAPORT GATUNKÓW ===\n");

  for (let species in counter) {
    const count = counter[species];
    const emoji = getSpeciesEmoji(species);
    console.log(`${emoji} ${species}: ${count} osobników`);
  }

  const total = Object.values(counter).reduce((sum, count) => sum + count, 0);
  console.log(`\nŁącznie: ${total} dinozaurów`);
}

function getSpeciesEmoji(species) {
  const emojis = {
    'T-Rex': '',
    'Velociraptor': '',
    'Triceratops': '',
    'Brachiosaurus': '',
    'Stegosaurus': '◆'
  };
  return emojis[species] || '';
}

// Test
const parkDinosaurs = [
  'T-Rex', 'T-Rex', 'T-Rex',
  'Velociraptor', 'Velociraptor', 'Velociraptor', 'Velociraptor',
  'Triceratops', 'Triceratops',
  'Brachiosaurus',
  'Stegosaurus', 'Stegosaurus', 'Stegosaurus'
];

const speciesCount = countSpecies(parkDinosaurs);
displaySpeciesReport(speciesCount);

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 funkcja setTimeout?

  2. 2. Co to jest callback hell?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj etapy obsługi asynchronicznej operacji w JavaScript:

  • Edytor kodu

    Napisz funkcję, która przyjmuje callback i wywołuje go z danymi dinosaura.

  • Układanie w poziomie

    Ułóż elementy opóźnionego wywołania funkcji:

  • Edytor kodu

    Stwórz Promise, który resolve'uje po opóźnieniu z danymi o statusie dinozaura, lub reject'uje jeśli czujnik nie odpowiada.

  1. Ułóż w kolejnościEtapy obsługi asynchronicznej operacji
  2. PytaniesetTimeout
  3. PytanieCallback hell
  4. PytaniePromise states
  5. Zadanie z kodemPraktyka: Funkcje callback
  6. Ułóż w kolejnościSkładnia setTimeout
  7. Zadanie z kodemPraktyka: Tworzenie Promise

Przydatne artykuły