[ Leksykon ] [ JavaScript ] [ Metody ] [ Promise() ]

Promise.race()

[_] [A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]

Promise.race(iterable)

  

Przykłady:

const promiseA = new Promise((resolve, reject) => {
   setTimeout(resolve, 400, "zadanie A"); // obietnica resolve
});
const promiseB = new Promise((resolve, reject) => {
   setTimeout(reject, 200, "zadanie B"); // obietnica reject
});

Promise.race([promiseA, promiseB])
   .then((value) => {
      console.log("zadanie spełnione:", value);
   })
   .catch((reason) => {
      console.error("zadanie niespełnione:", reason);
   });
// zadanie A będzie spełnione, ale zadanie B wykona pierwsze

 

function pauza(time, value, state) {
 return new Promise((resolve, reject) => {
 setTimeout(() => {
 if (state === "fulfill") {
 return resolve(value);
 } else {
 return reject(new Error(value));
 }
 }, time);
 });
}

const zadanie3 = pauza(3000, "A", "fulfill");
const zadanie4 = pauza(2500, "B", "reject");

Promise.race([zadanie3, zadanie4]).then(
 (value) => {
 console.log(value);
 },
 (error) => {
 console.error(error.message); // B
 },
);

const zadanie5 = pauza(1000, "C", "fulfill");
const zadanie6 = pauza(500, "D", "reject");

Promise.race([zadanie5, zadanie6]).then(
 (value) => {
 console.log(value);
 },
 (error) => {
 console.error(error.message); // D
 },
);

 

const promiseA = new Promise((resolve) => setTimeout(() => resolve("zadanie A"), 1000));
const promiseB = new Promise((resolve) => setTimeout(() => resolve("zadanie B"), 5000));
const promiseC = new Promise((resolve, reject) => setTimeout(() => reject("zadanie C"), 1000));
const promiseD = new Promise((resolve, reject) => setTimeout(() => reject("zadanie D"), 5000));

function zadanie(zad) {
   const stat = { status: "pending" };

   return Promise.race([zad, stat]).then(
      (value) => value === stat ? value : { status: "fulfilled", value },
      (reason) => ({ status: "rejected", reason })
   );
}

async function zadania() {
   console.log(await zadanie(promiseA));
   console.log(await zadanie(promiseB));
   console.log(await zadanie(promiseC));
   console.log(await zadanie(promiseD));
}

zadania();

setTimeout(() => {
   console.log("Wykonane zadania po dwóch sekundach");
   zadania();
}, 2000);

// { status: 'pending' }
// { status: 'pending' }
// { status: 'pending' }
// { status: 'pending' }
// Wykonane zadania po dwóch sekundach
// { status: 'fulfilled', value: zadanie A }
// { status: 'pending' }
// { status: 'rejected', reason: zadanie C }
// { status: 'pending' }

 

const zadanieA = Promise.race([
   fetch("zadania.php"),
   new Promise((resolve, reject) => {
      setTimeout(() => reject(new Error("Koniec czasu!")), 1000);
   }),
])
   .then((resolve) => resolve.json())
   .catch((error) => {
      console.error(error); // serwer nie zdązył wykonac zadania
   });

  

 

Opis:
Metoda Promise.race() statyczna przyjmuje jako dane wejściowe iterowalne obietnice i zwraca pojedynczy element Promise. Ta zwrócona obietnica jest zgodna z ostatecznym stanem pierwszej obietnicy, która została rozwiązana. Parametry iterable - Iterowalna jak Array obietnica. Wartość zwracana Promise, który asynchronicznie rozlicza się z ostatecznym stanem pierwszej obietnicy w iterable rozliczeniu. Innymi słowy, spełnia, jeśli pierwsza obietnica rozliczenia zostanie spełniona, odrzuca, jeśli pierwsza obietnica rozliczenia zostanie odrzucona. Zwrócona obietnica pozostaje oczekująca na zawsze, jeśli iterable przekazana obietnica jest pusta. Jeśli iterable przekazana obietnica nie jest pusta, ale nie zawiera żadnych oczekujących obietnic, zwrócona obietnica jest nadal rozliczana asynchronicznie zamiast synchronicznie. Metoda ta Promise.race() należy do metod obiecującej współbieżności.

Jest to przydatne, gdy chcesz, aby pierwsze zadanie asynchroniczne zostało ukończone, ale nie przejmuj się jego ostatecznym stanem tzn. może zakończyć się sukcesem lub niepowodzeniem. Jeśli iterowalność zawiera jedną lub więcej wartości niebędących obietnicą i/lub już ustaloną obietnicę, wówczas Promise.race() zostanie wybrana pierwsza z tych wartości znalezionych w iteracji. Jeśli iterowalna wartość zawiera jedną lub więcej wartości niebędących obietnicą i/lub już ustaloną obietnicę, wówczas Promise.race zostanie wybrana pierwsza z tych wartości znalezionych w tablicy.

Ta zwrócona obietnica zostaje rozliczona wraz z ostatecznym stanem pierwszej rozliczonej obietnicy. Spełnia się, gdy którakolwiek z obietnic zakończy jako pierwsza; odrzuca, gdy którakolwiek z obietnic zostaje odrzucona. Jeśli element iterowalny zawiera jedną lub więcej wartości niezwiązanych z obietnicą i/lub już rozliczoną obietnicę, wówczas Promise.race() zostanie rozliczona na podstawie pierwszej z tych wartości znalezionych w tablicy. Pusta iteracja powoduje, że zwrócona obietnica jest na zawsze oczekująca Promise { <state>: "pending" }. Promise.race() jest zawsze asynchroniczna: nigdy nie jest rozliczana synchronicznie, nawet gdy iterable jest pusta.

Promise.race bierze pierwszy ustalony Promise.
Promise.any bierze pierwszy spełniony Promise.

Linki: