const p1 = Promise.resolve('成功1');
const p2 = Promise.reject('錯(cuò)誤2');  // 這個(gè)會(huì)失敗
const p3 = Promise.resolve('成功3');

Promise.all([p1, p2, p3])
  .then(results => {
    console.log('全部成功:', results);
  })
  .catch(error => {
    console.log('有一個(gè)失敗:', error); // 輸出: "錯(cuò)誤2"
    // p1和p3的結(jié)果被丟棄！
  });

const p1 = Promise.resolve('成功1');
const p2 = Promise.reject('錯(cuò)誤2');
const p3 = Promise.resolve('成功3');

Promise.allSettled([p1, p2, p3])
  .then(results => {
    console.log('全部完成:');
    results.forEach((result, index) => {
      if (result.status === 'fulfilled') {
        console.log(`p${index + 1}: 成功 - ${result.value}`);
      } else {
        console.log(`p${index + 1}: 失敗 - ${result.reason}`);
      }
    });
  });
// 輸出:
// 全部完成:
// p1: 成功 - 成功1
// p2: 失敗 - 錯(cuò)誤2
// p3: 成功 - 成功3

// 成功時(shí)返回: [value1, value2, ...]
Promise.all([Promise.resolve(1), Promise.resolve(2)])
  .then(values => console.log(values)); // [1, 2]

// 失敗時(shí)返回: 第一個(gè)錯(cuò)誤
Promise.all([Promise.resolve(1), Promise.reject('錯(cuò)誤')])
  .catch(error => console.log(error)); // "錯(cuò)誤"

Promise.allSettled([
  Promise.resolve(1),
  Promise.reject('錯(cuò)誤'),
  Promise.resolve(3)
])
.then(results => {
  console.log(results);
  /*
  [
    { status: 'fulfilled', value: 1 },
    { status: 'rejected', reason: '錯(cuò)誤' },
    { status: 'fulfilled', value: 3 }
  ]
  */
});

// 場(chǎng)景1: 需要所有數(shù)據(jù)才能渲染頁面
async function loadDashboard() {
  try {
    const [user, orders, notifications] = await Promise.all([
      fetchUser(),
      fetchOrders(),
      fetchNotifications()
    ]);
    
    // 所有數(shù)據(jù)都成功才渲染
    renderDashboard({ user, orders, notifications });
  } catch (error) {
    // 任何一個(gè)失敗就顯示錯(cuò)誤頁面
    showErrorPage('加載數(shù)據(jù)失敗');
  }
}

// 場(chǎng)景2: 并行執(zhí)行但有依賴關(guān)系
async function processOrder(orderId) {
  const [order, inventory, payment] = await Promise.all([
    getOrder(orderId),
    checkInventory(orderId),
    verifyPayment(orderId)
  ]);
  
  // 三個(gè)檢查都通過才能繼續(xù)
  return { order, inventory, payment };
}

// 場(chǎng)景1: 批量操作，需要知道每個(gè)結(jié)果
async function sendNotifications(users) {
  const results = await Promise.allSettled(
    users.map(user => sendNotification(user))
  );
  
  const successful = results
    .filter(r => r.status === 'fulfilled')
    .map(r => r.value);
    
  const failed = results
    .filter(r => r.status === 'rejected')
    .map(r => r.reason);
    
  console.log(`發(fā)送成功: ${successful.length}, 失敗: ${failed.length}`);
  return { successful, failed };
}

// 場(chǎng)景2: 多源數(shù)據(jù)獲取，哪個(gè)快用哪個(gè)
async function getDataFromMultipleSources() {
  const results = await Promise.allSettled([
    fetchFromPrimaryAPI().catch(() => null),    // 主API
    fetchFromBackupAPI1().catch(() => null),    // 備份API1
    fetchFromBackupAPI2().catch(() => null)     // 備份API2
  ]);
  
  // 使用第一個(gè)成功的結(jié)果
  for (const result of results) {
    if (result.status === 'fulfilled' && result.value) {
      return result.value;
    }
  }
  
  throw new Error('所有數(shù)據(jù)源都失敗了');
}

// 場(chǎng)景3: 清理操作，無論單個(gè)成功失敗都要繼續(xù)
async function cleanupResources(resources) {
  const cleanupResults = await Promise.allSettled(
    resources.map(resource => resource.cleanup())
  );
  
  // 記錄所有清理結(jié)果，但不中斷流程
  logCleanupResults(cleanupResults);
}

// 使用 Promise.all 的錯(cuò)誤處理
Promise.all([task1(), task2(), task3()])
  .then(([result1, result2, result3]) => {
    // 成功處理
  })
  .catch(error => {
    // 任何一個(gè)失敗都會(huì)到這里
    // 但不知道哪些成功了，哪些失敗了
    console.error('某個(gè)任務(wù)失敗:', error);
  });

// 使用 Promise.allSettled 的錯(cuò)誤處理
Promise.allSettled([task1(), task2(), task3()])
  .then(results => {
    const errors = results
      .filter(r => r.status === 'rejected')
      .map(r => r.reason);
    
    const successes = results
      .filter(r => r.status === 'fulfilled')
      .map(r => r.value);
    
    if (errors.length > 0) {
      console.log(`${errors.length} 個(gè)任務(wù)失敗，但繼續(xù)處理成功的`);
      // 可以繼續(xù)處理 successes
    }
    
    return { successes, errors };
  });

// 用 Promise.allSettled 模擬 Promise.all
function promiseAll(promises) {
  return Promise.allSettled(promises)
    .then(results => {
      const rejected = results.find(r => r.status === 'rejected');
      if (rejected) {
        throw rejected.reason;  // 拋出第一個(gè)錯(cuò)誤
      }
      return results.map(r => r.value);  // 返回所有值
    });
}

// 用 Promise.all 模擬 Promise.allSettled（不完美）
function promiseAllSettled(promises) {
  // 為每個(gè) Promise 添加錯(cuò)誤處理，確保不會(huì)拋出
  const wrappedPromises = promises.map(p =>
    Promise.resolve(p).then(
      value => ({ status: 'fulfilled', value }),
      reason => ({ status: 'rejected', reason })
    )
  );
  return Promise.all(wrappedPromises);
}