Node.js中Google联系人接口返回空数据的异步问题求助

Hey there! Let's break down what's going on here and fix that async timing issue once and for all. The core problem you're facing is that you're either not properly collecting your database query promises, or you're trying to send the response before those promises have resolved. Here's how to get this right:

First, Let's Diagnose the Common Mistake #

It sounds like your original code might look something like this (the problematic version):

// ❌ Wrong approach: Either serial awaits (slow) or unawaited promises
router.post('/social/google', auth, async (req, res, next) => {
  try {
    // Get Google token and contact list
    const googleToken = /* your token logic */;
    const nameArray = /* fetched Google contacts */;
    
    const promises = [];
    // Mistake: Either using await inside loop (serial, slow) or not collecting promises correctly
    for (const name of nameArray) {
      // If you use await here, queries run one after another (slow)
      const user = await socialHandler.getUser(name);
      promises.push(user); // Or maybe you pushed the promise but didn't await the array?
    }
    
    // Mistake: Sending response before promises resolve
    req.data = promises;
    res.send(req.data);
  } catch (err) {
    next(err);
  }
});

This either makes your queries run serially (super slow for large contact lists) or sends the response before the database queries finish, resulting in empty req.data.

The Correct Async Approach with Promise.all #

To fix this, we need to collect all database query promises first, then wait for all of them to resolve in parallel before sending the response. Here's the fixed code:

// ✅ Correct approach: Parallelize queries with Promise.all
router.post('/social/google', auth, async (req, res, next) => {
  try {
    // 1. Fetch Google token and contact list as before
    const googleToken = /* your existing token retrieval logic */;
    const nameArray = /* your Google contacts fetch logic */;
    
    // 2. Create an array of promises (don't await yet!)
    // This runs all database queries in parallel
    const userCheckPromises = nameArray.map(contactName => {
      return socialHandler.getUser(contactName);
    });
    
    // 3. Wait for ALL promises to resolve
    // This line blocks until every database query is done
    const userCheckResults = await Promise.all(userCheckPromises);
    
    // 4. Process the results (e.g., filter out contacts not in your DB)
    // Assuming socialHandler.getUser returns null/undefined if no match
    const existingContacts = userCheckResults.filter(user => user !== null);
    
    // 5. Assign to req.data and send response
    req.data = existingContacts;
    res.send(req.data);
  } catch (err) {
    next(err);
  }
});

Why This Works: #

• nameArray.map(...) creates an array of unresolved promises for each database query. This tells Node.js to start all queries at the same time (parallel execution), which is way faster than running them one after another.
• await Promise.all(userCheckPromises) pauses the function until every promise in the array has resolved. Only then do we get the full results of all queries.
• We process the results and send the response after all queries are done, so req.data will never be empty (unless no contacts are in your DB, which is expected).

Bonus: Optimize Further with Batch Database Queries #

If you have a lot of contacts, even parallel individual queries can be slow because of multiple round-trips to the database. A better optimization is to modify socialHandler to support batch queries (fetch all matching users in one DB call):

// Add this method to socialHandler if possible
async getUsersByNames(names) {
  // Example with MongoDB: Use $in operator to fetch all matching users
  return UserModel.find({ name: { $in: names } });
  // Example with SQL: Use WHERE name IN (?, ?, ...) with parameterized queries
}

Then update your route code to use this batch query:

// ✅ Even better: Batch database query (single round-trip)
router.post('/social/google', auth, async (req, res, next) => {
  try {
    const googleToken = /* your logic */;
    const nameArray = /* your contacts */;
    
    // Single database call to get all existing users
    const existingUsers = await socialHandler.getUsersByNames(nameArray);
    
    // Map existing users to their names for quick lookup
    const existingNames = new Set(existingUsers.map(user => user.name));
    
    // Filter contacts to find which are already in your DB
    req.data = nameArray.filter(contactName => existingNames.has(contactName));
    
    res.send(req.data);
  } catch (err) {
    next(err);
  }
});

This cuts down your database interactions from N queries to 1, which will drastically improve performance for large contact lists.

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