如何在Node.js中正确实现500错误处理并解决路由问题

You've got two key problems to solve: getting errors to properly propagate up to your handler, and fixing the routing so your index.js controller loads correctly. Let's break them down.

1. Fixing the Routing Problem (index.js not rendering) #

Looking at your app.js code, I see a duplicate setup for your index controller that's causing conflicts:

// First you import and mount the controller
const index = require('./controllers/index');
app.use('/', index);

// Then later you call it again with the app instance
require('./controllers/index.js')(app);

You only need one of these approaches—using both will clash and prevent your routes from working as expected. Here's how to fix it based on how your index.js is structured:

If your index.js uses an Express Router (recommended): #

If your index.js looks like this (using express.Router()):

// controllers/index.js
const express = require('express');
const router = express.Router();

router.get('/', (req, res) => {
  res.render('index', { /* your page data */ });
});

module.exports = router;

Keep only this line in app.js and remove the require('./controllers/index.js')(app) line:

const index = require('./controllers/index');
app.use('/', index);

If your index.js uses the "pass app" pattern: #

If your index.js is written to accept the app instance directly:

// controllers/index.js
module.exports = (app) => {
  app.get('/', (req, res) => {
    res.render('index', { /* your page data */ });
  });
};

Remove the first two lines (const index = ... and app.use('/', index);) and keep only this:

require('./controllers/index.js')(app);

Pick the approach that matches your index.js structure, and your controller routes should start rendering properly.

2. Proper Error Catching & Propagation #

Express relies on calling next(err) to pass errors up to your error-handling middleware. Let's refine your setup to make errors propagate correctly, and make your error handler more robust.

First: Ensure errors are passed to next() #

In your routes/controllers, always catch errors and pass them to next(). For async functions, use try/catch to capture promise errors:

// Example in index.js controller
router.get('/', async (req, res, next) => {
  try {
    // Example of an operation that might fail (e.g., database query)
    const data = await someAsyncDatabaseCall();
    res.render('index', { data });
  } catch (err) {
    // Add a custom status code (optional but helpful for clarity)
    err.status = 500;
    // Pass the error to your error-handling middleware
    next(err);
  }
});

For synchronous code, you can either throw the error directly (Express will catch it) or pass it to next():

router.get('/sync-example', (req, res, next) => {
  try {
    if (!req.query.id) {
      const err = new Error('ID parameter is required');
      err.status = 400;
      throw err; // Express will auto-pass this to next(err)
    }
    // ... rest of your synchronous logic
  } catch (err) {
    next(err);
  }
});

Second: Improve your error-handling middleware #

Your current handler works for 404 and 500, but we can make it more flexible and secure (hiding sensitive stack traces in production):

// error handler (make sure this is the LAST middleware in app.js!)
app.use(function(err, req, res, next) {
  // Set default values if the error doesn't define them
  const statusCode = err.status || 500;
  const errorMessage = err.message || (statusCode === 404 ? "Sorry, we can't find that page" : "Internal Server Error");
  
  // Only show stack trace in development (avoid exposing sensitive info in production)
  const stackTrace = process.env.NODE_ENV === 'development' ? err.stack : undefined;

  // Log 500 errors for debugging purposes
  if (statusCode === 500) {
    console.error('Server Error:', err);
  }

  // Render the error page with dynamic data
  res.status(statusCode);
  res.render('error', {
    err: statusCode,
    message: errorMessage,
    stack: stackTrace
  });
});

Critical Reminder: #

Your error-handling middleware must be the last middleware you define in app.js—after all routes, controllers, and other middleware. Your current code has this right, but double-check that no new routes are added after this handler.

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