如何在Express.js函数外部访问MySQL记录？回调地狱优化求助

Hey there! I totally get where you're coming from—callback hell turns code into a messy nested mess, and trying to grab MySQL results outside your query function is such a common async gotcha in Express. Let's fix this properly, step by step.

First, why you can't access results outside the callback #

MySQL queries are asynchronous—when you try to read a variable holding the result outside the query callback, the query hasn't finished running yet, so you'll get undefined or whatever initial value you set. Callback hell happens because we nest these async operations one inside another to handle dependencies between queries.

The fix: Use Promises + Async/Await #

This combo eliminates callback nesting entirely and lets you work with async results as if they were synchronous. Here's how to implement it:

1. Wrap your MySQL queries in Promises (or use a Promise-native library)

If you're using the classic mysql package, create a simple wrapper function to convert callback-based queries into Promises:

// utils/db.js (or wherever you handle DB connections)
const connection = require('./your-connection-setup');

// Generic query wrapper that returns a Promise
const runQuery = (sql, params = []) => {
  return new Promise((resolve, reject) => {
    connection.query(sql, params, (err, results) => {
      if (err) {
        reject(err); // Pass errors to the catch block
      } else {
        resolve(results); // Pass results to the await call
      }
    });
  });
};

module.exports = { runQuery };

Pro tip: If you're starting fresh, use mysql2 instead—it has built-in Promise support, so you can skip the wrapper entirely:

const mysql = require('mysql2/promise');
// Then just use await mysql.query(sql, params) directly

2. Rewrite your Express route with Async/Await

Convert your route handler to an async function, then use await for each query. This makes your code linear and easy to read:

const express = require('express');
const { runQuery } = require('./utils/db');
const app = express();

app.get('/user-details', async (req, res) => {
  try {
    // First query: Get a user's basic info
    const user = await runQuery('SELECT id, name FROM users WHERE email = ?', [req.query.email]);
    
    // Second query: Get their related orders (depends on the first query's result)
    const orders = await runQuery('SELECT * FROM orders WHERE user_id = ?', [user[0].id]);
    
    // Now you can access both results anywhere in this async function
    // Even pass them to other functions
    const formattedData = formatUserAndOrders(user[0], orders);
    
    res.json({ success: true, data: formattedData });
  } catch (err) {
    // Handle all errors in one place
    console.error('DB Error:', err);
    res.status(500).json({ success: false, error: 'Internal server error' });
  }
});

// Example helper function to process data
function formatUserAndOrders(user, orders) {
  return {
    ...user,
    orderCount: orders.length,
    recentOrders: orders.slice(0, 3)
  };
}

app.listen(3000, () => console.log('Server running on port 3000'));

3. Bonus: Run independent queries in parallel

If you have queries that don't depend on each other, use Promise.all() to run them at the same time (faster than running sequentially):

app.get('/dashboard', async (req, res) => {
  try {
    // Run both queries in parallel
    const [totalUsers, totalOrders] = await Promise.all([
      runQuery('SELECT COUNT(*) AS count FROM users'),
      runQuery('SELECT COUNT(*) AS count FROM orders')
    ]);

    res.json({
      totalUsers: totalUsers[0].count,
      totalOrders: totalOrders[0].count
    });
  } catch (err) {
    console.error(err);
    res.status(500).send('Error loading dashboard data');
  }
});

Why this works #

• async/await lets you write async code that reads like synchronous code—no more nested callbacks.
• By waiting for each Promise to resolve with await, you ensure the result is ready before you try to use it.
• All errors are caught in a single catch block, making error handling cleaner.

This approach not only fixes the callback hell but also lets you easily access and manipulate your MySQL results anywhere within the async route handler (or pass them to other functions as needed).

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