Комбінатори Promise

const delay = (value, milliseconds) =>
  new Promise((resolve) => {
    setTimeout(() => resolve(value), milliseconds);
  });

async function runInParallel() {
  console.time("Паралельно");

  const firstPromise = delay("Перша операція", 1000);
  const secondPromise = delay("Друга операція", 1000);

  const first = await firstPromise;
  const second = await secondPromise;

  console.log(first);
  console.log(second);

  console.timeEnd("Паралельно");
}

runInParallel();

const delay = (value, milliseconds) =>
  new Promise((resolve) => {
    setTimeout(() => resolve(value), milliseconds);
  });

async function loadData() {
  const promises = [
    delay("Профіль", 1000),
    delay("Повідомлення", 500),
    delay("Налаштування", 800),
  ];

  const results = await Promise.all(promises);

  console.log(results);
}

loadData();

[ 'Профіль', 'Повідомлення', 'Налаштування' ]

const successfulRequest = Promise.resolve("Дані отримано");

const failedRequest = Promise.reject(new Error("Сервер недоступний"));

async function loadData() {
  try {
    const results = await Promise.all([
      successfulRequest,
      failedRequest,
    ]);

    console.log(results);
  } catch (error) {
    console.error("Не вдалося завантажити всі дані:", error.message);
  }
}

loadData();

async function loadPage() {
  const [user, products, notifications] = await Promise.all([
    fetchUser(),
    fetchProducts(),
    fetchNotifications(),
  ]);

  return {
    user,
    products,
    notifications,
  };
}

const requests = [
  Promise.resolve("Профіль завантажено"),
  Promise.reject(new Error("Не вдалося завантажити аватар")),
  Promise.resolve("Налаштування завантажено"),
];

async function loadOptionalData() {
  const results = await Promise.allSettled(requests);

  for (const result of results) {
    if (result.status === "fulfilled") {
      console.log("Успіх:", result.value);
    } else {
      console.log("Помилка:", result.reason.message);
    }
  }
}

loadOptionalData();

async function getSuccessfulResults(promises) {
  const results = await Promise.allSettled(promises);

  return results
    .filter((result) => result.status === "fulfilled")
    .map((result) => result.value);
}

getSuccessfulResults([
  Promise.resolve(10),
  Promise.reject(new Error("Помилка")),
  Promise.resolve(30),
]).then(console.log);

[ 10, 30 ]

const delay = (value, milliseconds, shouldReject = false) =>
  new Promise((resolve, reject) => {
    setTimeout(() => {
      if (shouldReject) {
        reject(new Error(value));
      } else {
        resolve(value);
      }
    }, milliseconds);
  });

async function runRace() {
  try {
    const result = await Promise.race([
      delay("Повільна операція", 1500),
      delay("Швидка операція", 500),
    ]);

    console.log(result);
  } catch (error) {
    console.error("Перша завершена операція завершилася помилкою:", error.message);
  }
}

runRace();

Швидка операція

const delay = (milliseconds) =>
  new Promise((resolve) => {
    setTimeout(() => resolve("Запит завершено"), milliseconds);
  });

const timeout = (milliseconds) =>
  new Promise((_, reject) => {
    setTimeout(() => {
      reject(new Error("Час очікування вичерпано"));
    }, milliseconds);
  });

async function requestWithTimeout() {
  try {
    const result = await Promise.race([
      delay(3000),
      timeout(1000),
    ]);

    console.log(result);
  } catch (error) {
    console.error(error.message);
  }
}

requestWithTimeout();

const delay = (value, milliseconds, shouldReject = false) =>
  new Promise((resolve, reject) => {
    setTimeout(() => {
      if (shouldReject) {
        reject(new Error(value));
      } else {
        resolve(value);
      }
    }, milliseconds);
  });

async function getDataFromReplicas() {
  try {
    const result = await Promise.any([
      delay("Репліка 1 недоступна", 300, true),
      delay("Дані з репліки 2", 800),
      delay("Дані з репліки 3", 1200),
    ]);

    console.log(result);
  } catch (error) {
    if (error instanceof AggregateError) {
      console.error("Усі джерела завершилися помилкою:");

      for (const reason of error.errors) {
        console.error(reason.message);
      }
    }
  }
}

getDataFromReplicas();

Дані з репліки 2

Promise.race([
  Promise.reject(new Error("Швидка помилка")),
  delay("Повільний успіх", 1000),
]);
// Відхилення через швидку помилку

Promise.any([
  Promise.reject(new Error("Швидка помилка")),
  delay("Повільний успіх", 1000),
]);
// Успіх через повільний успішний Promise

async function example() {
  const results = await Promise.all([
    10,
    "текст",
    Promise.resolve(true),
  ]);

  console.log(results);
}

example();

[ 10, 'текст', true ]

Promise.all([]).then(console.log);
// []

Promise.allSettled([]).then(console.log);
// []

Promise.race([]).then(console.log);
// Promise залишається в стані pending

Promise.any([]).catch((error) => {
  console.log(error instanceof AggregateError);
  console.log(error.errors);
});
// true
// []

async function loadResources() {
  try {
    const [user, orders] = await Promise.all([
      fetchUser(),
      fetchOrders(),
    ]);

    return { user, orders };
  } catch (error) {
    console.error("Помилка завантаження:", error.message);
    throw error;
  }
}

async function loadWidgets() {
  const results = await Promise.allSettled([
    loadWeatherWidget(),
    loadNewsWidget(),
    loadRecommendationsWidget(),
  ]);

  return results.map((result) => {
    if (result.status === "fulfilled") {
      return result.value;
    }

    return {
      error: result.reason.message,
    };
  });
}

async function loadUsers(ids) {
  const users = ids.map(async (id) => {
    return fetchUser(id);
  });

  return users;
}

async function loadUsers(ids) {
  const userPromises = ids.map((id) => fetchUser(id));

  return Promise.all(userPromises);
}

async function loadUsers(ids) {
  return Promise.all(ids.map((id) => fetchUser(id)));
}

async function loadUsersSequentially(ids) {
  const users = [];

  for (const id of ids) {
    const user = await fetchUser(id);
    users.push(user);
  }

  return users;
}

const delay = (value, milliseconds, shouldReject = false) =>
  new Promise((resolve, reject) => {
    setTimeout(() => {
      if (shouldReject) {
        reject(new Error(`${value}: помилка завантаження`));
      } else {
        resolve(value);
      }
    }, milliseconds);
  });

async function loadDashboard() {
  const [user, statistics] = await Promise.all([
    delay("Користувач", 500),
    delay("Статистика", 700),
  ]);

  const optionalResults = await Promise.allSettled([
    delay("Рекомендації", 300, true),
    delay("Останні новини", 400),
  ]);

  const optionalData = optionalResults
    .filter((result) => result.status === "fulfilled")
    .map((result) => result.value);

  return {
    user,
    statistics,
    optionalData,
  };
}

loadDashboard()
  .then((dashboard) => {
    console.log(dashboard);
  })
  .catch((error) => {
    console.error("Критична помилка:", error.message);
  });

const first = await loadFirst();
const second = await loadSecond();

const [first, second] = await Promise.all([
  loadFirst(),
  loadSecond(),
]);

try {
  await Promise.any([
    Promise.reject(new Error("Помилка A")),
    Promise.reject(new Error("Помилка B")),
  ]);
} catch (error) {
  console.log(error.errors);
}