Node.js Bluebird Promise使用咨询：如何规避回调地狱

嘿，太懂这种被回调地狱绕晕的感觉了！尤其是第三个回调还得拿第一个的结果，嵌套起来简直像套娃，看着就头疼。别慌，咱们用原生Promise和async/await来彻底理顺这个逻辑，要是你还想用Bluebird，我也给你整理了优化方案～

首先把每个异步操作都包装成Promise，然后通过.then()链式传递，关键是把需要后续用到的结果一起返回，这样就不用嵌套了：

// 模拟第一个异步操作：获取用户信息
function getUser() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ userId: 123, name: "Alice" });
    }, 1000);
  });
}

// 第二个异步操作：用用户ID获取订单
function getOrders(userId) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ orderId: 456, userId: userId, total: 99.9 });
    }, 1000);
  });
}

// 第三个异步操作：需要用户ID + 订单ID获取物流状态
function getShippingStatus(userId, orderId) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ userId: userId, orderId: orderId, status: "已发货" });
    }, 1000);
  });
}

// 链式调用，完美传递依赖
getUser()
  .then(user => {
    // 把用户信息和订单结果一起返回，供下一个then使用
    return getOrders(user.userId).then(order => ({ user, order }));
  })
  .then(({ user, order }) => {
    // 这里同时拿到了第一个和第二个的结果，直接传给第三个函数
    return getShippingStatus(user.userId, order.orderId);
  })
  .then(shippingStatus => {
    console.log("最终物流状态：", shippingStatus);
  })
  .catch(error => {
    console.error("过程出错啦：", error);
  });

ES7的async/await可以让异步代码看起来像同步逻辑，完全没有嵌套，可读性拉满：

// 复用上面的三个Promise函数

async function fetchFullShippingInfo() {
  try {
    // 按顺序执行，直接拿到每个步骤的结果
    const user = await getUser();
    const order = await getOrders(user.userId);
    const shippingStatus = await getShippingStatus(user.userId, order.orderId);
    
    console.log("最终物流状态：", shippingStatus);
  } catch (error) {
    // 统一捕获所有错误
    console.error("过程出错啦：", error);
  }
}

// 调用执行
fetchFullShippingInfo();

Bluebird的优势是可以快速把回调风格的老代码转成Promise，比如用promisify处理Node.js错误优先的回调函数：

const Bluebird = require('bluebird');

// 假设你原来的函数是回调风格的
function getUserCallback(callback) {
  setTimeout(() => {
    callback(null, { userId: 123, name: "Alice" });
  }, 1000);
}

function getOrdersCallback(userId, callback) {
  setTimeout(() => {
    callback(null, { orderId: 456, userId: userId, total: 99.9 });
  }, 1000);
}

function getShippingStatusCallback(userId, orderId, callback) {
  setTimeout(() => {
    callback(null, { userId: userId, orderId: orderId, status: "已发货" });
  }, 1000);
}

// 用Bluebird转成Promise
const getUser = Bluebird.promisify(getUserCallback);
const getOrders = Bluebird.promisify(getOrdersCallback);
const getShippingStatus = Bluebird.promisify(getShippingStatusCallback);

// 然后用async/await直接写逻辑，和原生写法一样清爽
async function run() {
  try {
    const user = await getUser();
    const order = await getOrders(user.userId);
    const status = await getShippingStatus(user.userId, order.orderId);
    console.log(status);
  } catch (err) {
    console.error(err);
  }
}

run();

这样不管是原生Promise还是Bluebird，都能彻底摆脱回调地狱，而且依赖传递的逻辑非常清晰～

内容的提问来源于stack exchange，提问作者erwinnandpersad