Запропонувати правку

Покращити цю статтю

Допрацюйте відповідь до «Що робить Promise.any()?». Ваші зміни проходять модерацію перед публікацією.

Потрібне підтвердження

Контент

Що ви змінюєте

Заголовок (UA)

Коротка відповідь (UA)

Показується над повною відповіддю для швидкого нагадування.

Відповідь (UA)

## Що робить `Promise.any()`

`Promise.any(iterable)` приймає **масив (або будь-який ітерований об'єкт)** промісів
і повертає **новий проміс**, який:

- **виконується (**`fulfilled`**)**, щойно **перший проміс успішно завершиться (**`resolve`**)**;
- **відхиляється (**`rejected`**)**, якщо **всі проміси відхилені**.

> Тобто: "дай мені перший успішний результат - помилки ігноруй".

---

## Синтаксис

```javascript
Promise.any(iterable)
```

### Повертає:

новий **Promise**, який:

- завершиться зі значенням **першого** `fulfilled` **промісу**;
- відхилиться зі спеціальною помилкою `AggregateError`, якщо всі проміси впали.

---

## Приклад 1 - перший успішний "перемагає"

```javascript
const p1 = Promise.reject('Помилка 1');
const p2 = new Promise(resolve => setTimeout(() => resolve('Успіх 2'), 1000));
const p3 = new Promise(resolve => setTimeout(() => resolve('Успіх 3'), 2000));

Promise.any([p1, p2, p3])
  .then(result => console.log('Результат:', result))
  .catch(err => console.error('Помилка:', err));
```

**Вивід через 1 секунду:**

```javascript
Результат: Успіх 2
```

Перший успішний (`p2`) "перемагає",
навіть якщо решта все ще виконуються або впадуть пізніше.

---

## Приклад 2 - якщо всі проміси відхиляються

```javascript
const p1 = Promise.reject('Помилка A');
const p2 = Promise.reject('Помилка B');

Promise.any([p1, p2])
  .then(console.log)
  .catch(err => console.error(err));
```

**Вивід:**

```javascript
AggregateError: All promises were rejected
```

Помилка містить **список усіх причин**:

```javascript
err.errors // ['Помилка A', 'Помилка B']
```

---

## Як це працює під капотом

1. Усі проміси запускаються **паралельно**.
2. Якщо хоча б один із них **виконався успішно (**`resolve`**)** →
`Promise.any()` **негайно завершується з цим результатом**.
3. Якщо **всі** виявилися `rejected` →
повертається **помилка типу** `AggregateError` з масивом усіх причин.

---

## Приклад 3 - комбінація успіхів і помилок

```javascript
const slow = new Promise(resolve => setTimeout(() => resolve('Повільний успіх'), 2000));
const fail = Promise.reject('Помилка!');
const fast = new Promise(resolve => setTimeout(() => resolve('Швидкий успіх'), 500));

Promise.any([slow, fail, fast])
  .then(console.log)
  .catch(console.error);
```

**Результат через 0.5 сек:**

```javascript
Швидкий успіх
```

Навіть якщо `fail` впав раніше, `Promise.any()` чекає перший **успішний** проміс.

---

## Відмінність від інших методів

| Метод | Що повертає | Завершується коли | Помилка при |
|---|---|---|---|
| `Promise.all()` | Масив результатів усіх успішних | Усі проміси `fulfilled` | Перший `reject` |
| `Promise.allSettled()` | Масив статусів (`fulfilled` / `rejected`) | Усі проміси завершені | Ніколи |
| `Promise.race()` | Перший завершений проміс (успіх чи помилка) | Будь-який `resolve` або `reject` | Завершується при першому `reject` |
| `Promise.any()` | Перший успішний результат | Перший `fulfilled` | Коли **всі** `rejected` |

Тобто:

- `Promise.race()` реагує на **перший завершений** проміс (включно з помилками),
- `Promise.any()` реагує тільки на **перший успішний**.

---

## Приклад 4 - "резервне копіювання" (fallback)

Уяви, що в тебе три сервери:
ти хочеш отримати дані **з першого, який відповість успішно**,
навіть якщо два інших недоступні.

```javascript
const fetchFromA = fetch('/api/a'); // може впасти
const fetchFromB = fetch('/api/b');
const fetchFromC = fetch('/api/c');

Promise.any([fetchFromA, fetchFromB, fetchFromC])
  .then(res => console.log('Відповідь отримано'))
  .catch(() => console.error('Усі сервери недоступні'));
```

Таким чином ти реалізуєш стратегію "fallback" -
**успіху будь-якого джерела достатньо**.

---

## Приклад 5 - поведінка `AggregateError`

```javascript
Promise.any([
  Promise.reject('Помилка 1'),
  Promise.reject('Помилка 2')
]).catch(err => {
  console.error(err.name);   // AggregateError
  console.error(err.errors); // ['Помилка 1', 'Помилка 2']
});
```

---

## Проста аналогія

> Уяви, що ти відправляєш трьох кур'єрів на велосипеді, авто та ракеті.
>
> - `Promise.any()` каже: "хто **першим успішно доставить**, того результат я прийму;
> помилки решти - неважливі".
> - Тільки якщо **всі** загубляться - тоді ти дізнаєшся про помилку.

---

## ПІДСУМОК

| Властивість | Значення |
|---|---|
| **Що робить** | Повертає перший **успішно виконаний** проміс |
| **Якщо всі відхилені** | Повертає `AggregateError` з причинами |
| **Тип значення, що повертається** | `Promise` |
| **Схожий на** | `Promise.race()`, але ігнорує `reject` |
| **Типові сценарії** | fallback-запити, резервні джерела даних, надлишкові API-запити |

Markdown · перетягуйте зображення · ⌘B / ⌘I шорткати591 слів

Для рев’юера

Примітка для модератора (необов’язково)

Бачить лише модератор. Прискорює рев’ю.