如何在Express中确保异步中间件同步执行？

Hey there! Let's work through this together. The core goal here is to properly handle the asynchronous task in your Express middleware, ensuring we only pass the request to the next handler/middleware when the task succeeds, and return an error response if it fails.

First, let's fix a small syntax issue in your original code: your handler function is missing the function keyword (or arrow function syntax). Now, let's break down the correct implementations:

1. Callback-Based Approach (For Traditional Async APIs) #

If your async task uses a callback pattern (like older Node.js APIs), you can handle the success/failure directly in the callback:

app.use('/route', middleware, handler);

function middleware(req, res, next) {
    // Simulate an async task (e.g., database query, external API call)
    performAsyncTask((error, successData) => {
        if (error) {
            // Task failed: send error response and stop the chain
            return res.status(400).json({ message: 'fail', error: error.message });
        }

        // Optional: Attach the result to the request for the handler to use
        req.taskResult = successData;
        // Task succeeded: pass control to the next handler/middleware
        next();
    });
}

// Fixed handler function
function handler(req, res) {
    res.json({ message: 'done', data: req.taskResult });
}

2. Async/Await + Promise Approach (Recommended for Clean Code) #

Most modern async operations return Promises (or can be wrapped into them). Using async/await makes your code much more readable and avoids callback hell:

app.use('/route', middleware, handler);

// Mark the middleware as async to use await
async function middleware(req, res, next) {
    try {
        // Wait for the async task to complete
        const successData = await performAsyncTaskThatReturnsPromise();
        
        // Attach result to request (optional)
        req.taskResult = successData;
        // Proceed to the next handler
        next();
    } catch (error) {
        // Catch any errors from the async task and send a response
        res.status(500).json({ message: 'fail', error: error.message });
    }
}

function handler(req, res) {
    res.json({ message: 'done', data: req.taskResult });
}

Key Things to Remember #

• Always handle errors: If you don't send a response or pass the error to next(), the request will hang indefinitely, leaving the client waiting.
• Use return after sending responses: This prevents accidental execution of next() after already sending a response (Express ignores next() once a response is sent, but it's a good habit to avoid bugs).
• Global Error Handling Option: If you want centralized error handling, you can pass the error to next(error) instead of sending a response directly, then use a global error middleware:

  async function middleware(req, res, next) {
      try {
          const successData = await performAsyncTaskThatReturnsPromise();
          req.taskResult = successData;
          next();
      } catch (error) {
          // Pass error to global handler
          next(error);
      }
  }
  
  // Global error middleware (place this AFTER all routes/middleware)
  app.use((err, req, res, next) => {
      console.error('Async task failed:', err.stack);
      res.status(500).json({ message: 'fail', error: err.message });
  });
  

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