Статычныя метады класа Promise:

1. Promise.all(iterable)
2. Promise.allSettled(iterable)
3. Promise.race(iterable)
4. Promise.any(iterable)
5. Promise.resolve(value)
6. Promise.reject(reason)
7. Promise.withResolvers()
8. Promise.try()

1. Promise.all(iterable) Атрымлівае на уваход масіў промісаў, вяртае адзін проміс, які ўтрымлівае:

а) масіў паспяхова выкананых промісаў (у выпадку, калі ўсе яны завяршыліліся паспяхова):

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, "foo");
});

Promise.all([promise1, promise2, promise3]).then((values) => {
  console.log(values);
});
// Expected output: Array [3, 42, "foo"]

б) проміс з памылкай (калі хоць адзін з іх завяршыўся з памылкай). Ужо паспяхова выкананыя дагэтуль промісы будуць праігнараваныя.

const promise1 = 42;
const promise2 = Promise.reject(3);
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, "foo");
});

Promise.all([promise1, promise2, promise3]).catch(err => console.log(err));
// Expected output: 3

2. Promise.allSettled(iterable)

Прымае масіў промісаў і вяртае проміс з масівам адказаў на кожны з перададзеных промісаў.

Для паспяхова выкананага проміса вернецца адказ у выглядзе:

{status: fulfilled, value: <your_value>}

Для проміса з памылкай:

{status: rejected, reason: <error_message>}

Promise.allSettled([
  Promise.resolve(33),
  new Promise((resolve) => setTimeout(() => resolve(66), 0)),
  99,
  Promise.reject(new Error("an error")),
]).then((values) => console.log(values));

// [
//   { status: 'fulfilled', value: 33 },
//   { status: 'fulfilled', value: 66 },
//   { status: 'fulfilled', value: 99 },
//   { status: 'rejected', reason: Error: an error }
// ]

3. Promise.race(iterable)

Прымае масіў промісаў, вяртае проміс з першым выкананым промісам (няма разніцы - паспяховым, ці з памылкай) з перададзеных промісаў.

const promise1 = new Promise((resolve, reject) => {
  setTimeout(resolve, 500, "one");
});

const promise2 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, "two");
});

Promise.race([promise1, promise2]).then((value) => {
  console.log(value);
  // паспяховы promise2 выканаецца першым
});
// Expected output: "two"

const promise1 = new Promise((resolve, reject) => {
  setTimeout(resolve, 500, "one");
});

const promise2 = new Promise((resolve, reject) => {
  setTimeout(reject, 100, "two");
});

Promise.race([promise1, promise2]).catch((err) => {
  console.log(err);
  // promise2 з памылкай выканаецца першым
});
// Expected output: "two"

4. Promise.any(iterable)

Прымае масіў промісаў, вяртае проміс:

а) з першым паспяхова выкананым промісам

const promise1 = Promise.reject(0);
const promise2 = new Promise((resolve) => setTimeout(resolve, 100, "quick"));
const promise3 = new Promise((resolve, reject) => setTimeout(reject, 500, "slow"));

const promises = [promise1, promise2, promise3];

Promise.any(promises)
.then((value) => console.log('value', value))
.catch((err) => console.log('error', err));

// Expected output: "quick"

б) з масівам адказаў няўдала выкананых промісаў, калі ўсе яны завяршыліся няўдала:

const promise1 = Promise.reject(0);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, "quick"));
const promise3 = new Promise((resolve, reject) => setTimeout(reject, 500, "slow"));

const promises = [promise1, promise2, promise3];

Promise.any(promises)
.then((value) => console.log('value', value))
.catch((err) => console.log('error', err));

// Expected output: error [AggregateError: All promises were rejected] {
//   [errors]: [ 0, 'quick', 'slow' ]
// }

5. Promise.resolve(value)

Статычны метад, які паспяхова завяршае promise. Калі перадаецца нейкае значэнне, то яго можна атрымаць праз .then

const promise1 = Promise.resolve(123);

promise1.then((value) => {
  console.log(value);
  // Expected output: 123
});

6. Promise.reject(reason)

Статычны метад, які завяршае promise з памылкай. Памылку можна атрымаць праз .catch

function resolved(result) {
  console.log("Resolved");
}

function rejected(result) {
  console.error(result);
}

Promise.reject(new Error("fail")).then(resolved, rejected);
// Expected output: Error: fail

7. Promise.withResolvers() (2024)

Вяртае instance ад new Promise і 2 функцыі - resolve і reject:

const { promise, resolve, reject } = Promise.withResolvers();

Дазваляе выкарыстоўваць больш лаканічны сінтаксіс, чым звычайны new Promise(). Больш зразумела гэта будзе на прыкладах.

// Код без выкарыстоўвання Promise.withResolvers()

let outerResolve;
let outerReject;

const promise = new Promise((resolve, reject) => {
  outerResolve = resolve;
  outerReject = reject;
});

// Settled from _outside_ the promise!
setTimeout(() => {
  if (Math.random() < 0.5) {
    outerResolve("Resolved!")      
  } else {
    outerReject("Rejected!");
  }
}, 1000);

promise
  .then((resolvedValue) => {
    console.log(resolvedValue);
  })
  .catch((rejectedValue) => {
    console.error(rejectedValue);
  });

// Код з выкарыстаннем Promise.withResolvers()

const { promise, resolve, reject } = Promise.withResolvers();

setTimeout(() => {
  if (Math.random() < 0.5) {
    resolve('Resolved!');
  } else {
    reject('Rejected!');
  }
}, 1000);

promise
  .then((resolvedValue) => {
    console.log(resolvedValue);
  })
  .catch((rejectedValue) => {
    console.error(rejectedValue);
  });

8. Promise.try(func, arg1, arg2) (2025)

Статычны метад Promise.try() прымае любы callback (з return, альбо throw, сінхронны альбо асінхронны) і абгортвае яго вынік у promise. Гэты проміс:

• Заўжды паспяхова выкананы (fullfilled), калі сінхронны callback вяртае value.
• Заўжды выкананы з памылкай (rejected), калі сінхронны callback выкідвае выключэнне (throw).
• Выконваецца асінхронна паспяхова (fullfilled), ці з памылкай (rejected), калі callback утрымлівае promise.

У выніку маем больш лаканічны сінтаксіс:

// замест
new Promise((resolve) => resolve(func()));

//маем
Promise.try(func);

func у прыкладзе выконваецца сінхронна. То бок, не з'яўляецца эквівалентам наступнага кода:

Promise.resolve().then(func);

Вось яшчэ прыклад выкарыстоўвання:

function doSomething(action) {
  return Promise.try(action)
    .then((result) => console.log(result))
    .catch((error) => console.error(error))
    .finally(() => console.log("Done"));
}

doSomething(() => "Sync result");

doSomething(() => {
  throw new Error("Sync error");
});

doSomething(async () => "Async result");

doSomething(async () => {
  throw new Error("Async error");
});

Спадзяюся, каму-небудзь гэтая інфармацыя будзе карыснай! Стаўце падабайкі, пішыце каментары!

З выкарастанай літэратуры:

• MDN
• Control JavaScript Promises from Anywhere Using Promise.withResolvers()