async pour la boucle dans node.js

J'ai réduit l'exemple de code pour les lignes suivantes pour le rendre plus facile à comprendre l'explication de ce concept.

var results = [];
var config = JSON.parse(queries);
for (var key in config) {
    var query = config[key].query;
    search(query, function(result) {
        results.push(result);
    });
}
res.writeHead( ... );
res.end(results);

Le problème avec le code précédent est que le search fonction est asynchrone, donc quand la boucle est terminée, aucune des fonctions de rappel ont été appelés. Par conséquent, la liste de results est vide.

Pour résoudre le problème, vous devez mettre le code après la boucle dans la fonction de callback.

    search(query, function(result) {
        results.push(result);
        //Put res.writeHead( ... ) and res.end(results) here
    });

Cependant, puisque la fonction de rappel est appelée plusieurs fois (une fois pour chaque itération), vous devez en quelque sorte savoir que tous les rappels ont été appelés. Pour ce faire, vous devez compter le nombre de rappels, et de vérifier si le nombre est égal au nombre de fonctions asynchrones appels.

Pour obtenir une liste de toutes les touches, utilisez de l'Objet.les touches. Ensuite, pour itérer sur cette liste, j'utilise .forEach (vous pouvez également utiliser for (var i = 0, key = keys[i]; i < keys.length; ++i) { .. }, mais qui pourrait donner des problèmes, voir JavaScript à l'intérieur fermeture à boucle – simple exemple pratique).

Voici un exemple complet:

var results = [];
var config = JSON.parse(queries);
var onComplete = function() {
    res.writeHead( ... );
    res.end(results);
};
var keys = Object.keys(config);
var tasksToGo = keys.length;
if (tasksToGo === 0) {
   onComplete();
} else {
    //There is at least one element, so the callback will be called.
    keys.forEach(function(key) {
        var query = config[key].query;
        search(query, function(result) {
            results.push(result);
            if (--tasksToGo === 0) {
                //No tasks left, good to go
                onComplete();
            }
        });
    });
}

Remarque: Le code asynchrone dans l'exemple précédent, sont exécutées en parallèle. Si les fonctions doivent être appelées dans un ordre spécifique, vous pouvez utiliser la récursivité pour obtenir l'effet désiré:

var results = [];
var config = JSON.parse(queries);
var keys = Object.keys(config);
(function next(index) {
    if (index === keys.length) { //No items left
        res.writeHead( ... );
        res.end(results);
        return;
    }
    var key = keys[index];
    var query = config[key].query;
    search(query, function(result) {
        results.push(result);
        next(index + 1);
    });
})(0);

Ce que j'ai indiqué sont les concepts, vous pouvez utiliser l'un des nombreux (troisième partie) NodeJS modules de la mise en œuvre, tels que async.

J'aime utiliser le modèle récursif pour ce scénario. Par exemple, quelque chose comme ceci:

//If config is an array of queries
var config = JSON.parse(queries.querrryArray);   

//Array of results
var results;

processQueries(config);

function processQueries(queries) {
    var searchQuery;

    if (queries.length == 0) {
        //All queries complete
        res.writeHead(200, {'content-type': 'application/json'});
        res.end(JSON.stringify({results: results}));
        return;
    }

    searchQuery = queries.pop();

    search(searchQuery, function(result) {
        results.push(JSON.stringify({result: result}); 
        processQueries();            
    });

}

processQueries est une fonction récursive qui va tirer une requête élément d'un tableau de requêtes à traiter. La fonction de rappel des appels processQueries de nouveau lorsque la requête est terminée. Le processQueries sait à la fin quand il n'y a pas de requêtes de gauche.

Il est plus facile de le faire à l'aide de tableaux, mais il pourrait être modifié pour fonctionner avec l'objet de clés/valeurs, j'imagine.