前言：

我理解的它就是Python中的Coroutine。

一、为什么要用 Promise

想象一下，你去一家非常慢的餐厅点餐。

• 同步模式（老式做法）：
  你：“服务员，我要一份牛排。”
  服务员：“好的，我去厨房做。”
  然后……你就站在柜台前死死盯着厨房，一动不动，直到牛排做好端出来。
  后果：在这 30 分钟里，你不能玩手机，不能聊天，不能去洗手间。整个餐厅（程序）都卡死了，直到这道菜做完。

• 异步模式（现代做法）：
  你：“服务员，我要一份牛排。”
  服务员：“好的，这是您的取餐号小票（Promise），做好了叫您。”
  然后……你回到座位上玩手机、聊天（执行其他代码）。
  后果：餐厅继续接待其他客人，效率极高。等牛排好了，服务员会拿着小票来找你。

二、Promise 是什么

Promise 是 JavaScript 中处理异步操作的一种标准机制。

只有三种状态，而且一旦改变就无法回头：
Pending（进行中）：刚拿到小票，厨房正在做菜。
Fulfilled（已成功）：菜做好了，服务员把菜端给你（resolve）。
Rejected（已失败）：厨房没食材了，服务员告诉你做不了（reject）。

代码示例：

// 1. 创建 Promise (厨师接单)
const cookSteak = new Promise((resolve, reject) => {
  console.log('👨‍🍳 厨师：开始做牛排... (状态：Pending)');

  setTimeout(() => {
    const success = true; // 假设今天有食材

    if (success) {
      // 2. 成功了，调用 resolve，把“牛排”交出去
      resolve('🥩 热腾腾的牛排'); 
    } else {
      // 3. 失败了，调用 reject，把“错误原因”交出去
      reject('❌ 抱歉，牛肉卖完了');
    }
  }, 2000); // 模拟做饭耗时 2 秒
});

三、怎么使用 Promise

1. .then() —— 成功的回调

cookSteak.then((result) => {
  console.log('😋 顾客：太棒了！我吃到了：' + result);
  // 输出：😋 顾客：太棒了！我吃到了：🥩 热腾腾的牛排
});

2. .catch() —— 失败的回调

cookSteak.catch((error) => {
  console.log('😡 顾客：什么？' + error);
  // 如果上面 success = false，这里会输出：😡 顾客：什么？❌ 抱歉，牛肉卖完了
});

3. .finally() —— 无论成败都执行

cookSteak.finally(() => {
  console.log('🚶 顾客：用餐结束，我走了。');
});

四、Promise 的超能力（链式调用）

场景：做饭流程
买菜 (异步)
洗菜 (依赖买菜的结果)
炒菜 (依赖洗菜的结果)
上桌 (依赖炒菜的结果)
❌ 没有 Promise 时（回调地狱）：
代码会缩进成金字塔，根本没法看：

buyVegetables((veg) => {
  washVegetables(veg, (cleanVeg) => {
    cookVegetables(cleanVeg, (dish) => {
      serveDish(dish, () => {
        console.log('吃上了！');
      });
    });
  });
});

有了 Promise 后（链式调用）：
代码像流水账一样清晰！上一个 .then() 返回的数据，会自动传给下一个 .then()。

buyVegetables() 
  .then((veg) => {
    console.log('1. 买到了：' + veg);
    return washVegetables(veg); // ⭐关键：返回一个新的 Promise
  })
  .then((cleanVeg) => {
    console.log('2. 洗干净了：' + cleanVeg);
    return cookVegetables(cleanVeg); // ⭐关键：继续返回
  })
  .then((dish) => {
    console.log('3. 炒好了：' + dish);
    return serveDish(dish);
  })
  .then(() => {
    console.log('🎉 终于吃上了！');
  })
  .catch((err) => {
    // ⭐关键：中间任何一步出错，都会直接跳到这里
    console.log('💥 出错了：' + err);
  });

五、终极神器 Async/Await

虽然链式调用很好，但写多了 .then() 还是有点烦。
ES6 后来推出了 async/await，它是基于 Promise 的语法糖，让异步代码写得像同步代码一样丝滑。

Promise 版

getData()
  .then(data => getMoreData(data))
  .then(more => getFinalData(more))
  .then(final => console.log(final))
  .catch(err => console.error(err));

Async/Await 版（推荐⭐）：

// 加上 async 关键字
async function run() {
  try {
    // 加上 await 关键字，意思是“在这里等一下，拿到结果再往下走”
    const data = await getData(); 
    const more = await getMoreData(data);
    const final = await getFinalData(more);
    
    console.log(final);
  } catch (err) {
    // 这里的 catch 能捕获上面任何一行 await 的错误
    console.error(err);
  }
}

run();