Node.js中如何避免回调地狱？附嵌套回调代码示例

Hey, I feel your pain—callback hell like this is such a nightmare to read and maintain. Let's walk through a couple of clean, modern ways to fix this in Node.js, using features that'll make your code way easier to follow.

First, let's recap what's going on in your original code: you're nesting three Mongoose queries inside each other, which creates that messy "pyramid of doom" structure. The good news is Mongoose fully supports Promises, so we can leverage that to flatten things out.

1. Use Async/Await (Cleanest & Most Readable) #

Async/await lets you write asynchronous code that reads like synchronous code—no more nesting. Here's how to refactor your route:

/* GET main page */
router.get('/', async (req, res, next) => {
  try {
    // Fetch employer accounts
    const employers = await Account.find({ accType: 'Employer' }).exec();
    
    // Fetch banner data
    const banner = await Banner.findOne().exec();
    
    // Check for any awaiting accounts
    const awaitingAccount = await Account.findOne({ accType: 'Awaiting' }).exec();
    const awaiting = awaitingAccount !== null;

    // Render the admin page with all data
    res.render('admin/', { title: 'Admin Dashboard', employers, banner, awaiting });
  } catch (err) {
    // Handle all errors in one place
    console.error(err);
    // Pass the error to Express's built-in error handler
    next(err);
  }
});

Why this works: #

• The async keyword marks the route handler as asynchronous, letting us use await inside it.
• Each await pauses execution until the Mongoose query (wrapped in .exec() to return a proper Promise) resolves.
• All errors are caught in a single try/catch block—no more repeating if (err) { console.log(err); } in every callback.
• The code flows linearly, making it way easier to follow the logic at a glance.

2. Use Promise Chaining (Alternative if You Prefer .then() Syntax) #

If you'd rather not use async/await, you can chain Promises to avoid nesting. Plus, we can use Promise.all() to run independent queries in parallel (which speeds things up, since your banner and awaiting account queries don't depend on each other):

/* GET main page */
router.get('/', (req, res, next) => {
  // Start with the employer account query
  Account.find({ accType: 'Employer' }).exec()
    .then(employers => {
      // Run banner and awaiting account queries in parallel
      return Promise.all([
        employers,
        Banner.findOne().exec(),
        Account.findOne({ accType: 'Awaiting' }).exec()
      ]);
    })
    .then(([employers, banner, awaitingAccount]) => {
      const awaiting = awaitingAccount !== null;
      res.render('admin/', { title: 'Admin Dashboard', employers, banner, awaiting });
    })
    .catch(err => {
      console.error(err);
      next(err);
    });
});

Why this works: #

• Promise.all() takes an array of Promises and resolves when all of them are done—this cuts down on waiting time since we don't have to wait for one query to finish before starting the next independent one.
• The chain flattens the nesting, so each step is a separate .then() block instead of being nested inside the previous callback.
• Errors from any query are caught in the final .catch() block.

Quick Notes for Mongoose #

• Mongoose queries are "thenable" (they work with .then()), but using .exec() ensures you get a standard ES6 Promise, which is more reliable for async/await and chaining.
• If you're using an older version of Mongoose (pre-4.0), you might need to promisify the methods manually with util.promisify, but modern versions handle this out of the box.

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