如何处理Node中多个异步回调的结果

Question

I'm working on a scenario in Node which involves multiple async.map calls, one of which is nested in an _.map function as I need access to nested arrays. I'm struggling to properly combine the results of these calls into an array which I return in the end.

More specifics on the scenario:

I start with a userId and query my games db to find all games which this userId is associated with. I pull gameId and description for each game.

I then query the gameId of each of these games to find all userId s associated with each game. I filter the original userId out of these results.

Next I query my users db for each of these userId s in order to get details such as user email and name . (Note: this is where _.map comes into play as the userId s are nested in an array of arrays; each inner array representing a game).

The last step, and where I'm struggling, is how to combine these results and return them. My final desired array looks like the below. An array of game objects. Each game object has a gameId , description , and users property. users is an array of users associated with that game and has id , email , and name properties.

[
  {
    gameId: 'dfh48643hdgf',
    description: 'lorem ipsum...',
    users: [
      {
        id: 1,
        email: 'test@example.com',
        name: 'John Doe'
      },
      {
        id: 7,
        email: 'sample@example.com',
        name: 'Jane Smith'
      }, ...
    ]
  }, ...
]

Below is the code I currently have (Note: this code block is actually part of a larger async.series call):

sharedGames: function(next) {
  db.games.index({userId: userId},
    function(err, gamesData) {
      if (err) {
        logger.warn('Error retrieving games for userId %d', userId, err);
        next(err, null);
      } else {
        gamesData = _.map(gamesData, function(game) {
          return {
            gameId: game.id,
            description: game.description,
            users: []
          };
        });
        async.map(gamesdata,
          function(item, callback) {
            db.gameDetails.getGameUsers({gameId: item.gameId},
              function(err, users) {
                if (err) {
                  callback(err, null);
                } else {
                  callback(null, _.without(users.userIds, Number(userId)));
                }
              }
            );
          },
          function(err, results) {
            if (err) {
              next(null, null);
            } else {
              var flattenedResults = _.chain(results)
                .flatten()
                .uniq()
                .value();
              async.map(flattenedResults, function(user, callback) {
                db.users.getById(user, function(err, userDetails) {
                  if (err) {
                    callback(err, null);
                  } else {
                    callback(null, _.pick(userDetails, 'id', 'email', 'name'));
                  }
                });
              }, function(err, users) {
                if (err) {
                  next(null, null);
                } else {
                  _.each(results, function(result, index) {
                    _.each(result, function(user) {
                      var customerDetails = _.find(customers, function(u) {
                        return u.id === user;
                      });
                      gamesData[index].users.push(userDetails);
                    });
                  });
                  console.log(gamesData);
                  next(null, gamesdata);
                }
              });
            }
          }
        );
        next(null, []);
      }
    }
  );
}

Answer 1

So you can definitely accomplish what you're describing with async.auto . Check this from their docs:

async.auto({
get_data: function(callback){
    console.log('in get_data');
    // async code to get some data
    callback(null, 'data', 'converted to array');
},
make_folder: function(callback){
    console.log('in make_folder');
    // async code to create a directory to store a file in
    // this is run at the same time as getting the data
    callback(null, 'folder');
},
write_file: ['get_data', 'make_folder', function(callback, results){
    console.log('in write_file', JSON.stringify(results));
    // once there is some data and the directory exists,
    // write the data to a file in the directory
    callback(null, 'filename');
}],
email_link: ['write_file', function(callback, results){
    console.log('in email_link', JSON.stringify(results));
    // once the file is written let's email a link to it...
    // results.write_file contains the filename returned by write_file.
    callback(null, {'file':results.write_file, 'email':'user@example.com'});
}]
}, function(err, results) {
    console.log('err = ', err);
    console.log('results = ', results);
});

So if you follow the same approach, you can get the array of game objects by injecting more info every call. You can also use async.waterfall . Hope it helps