Des Appels asynchrones et la Récursivité avec Node.js

Dans votre exemple, vous n'avez pas d'appels récursifs. Si je comprends bien, vous voulez dire que recurse(point, otherFunc); est le début d'un appel récursif.

Puis il suffit de revenir à la définition de l'appel récursif (que vous n'avez pas indiqué dans votre post) et le faire (ajouter un troisième argument en faveur d'une fonction de rappel à appeler à la fin de la récursivité; l'appelant va passer comme paramètre):

function recurse(startingPlace, otherFunc, callback_one) {
    //code you may have ...
    if (your_terminating_criterion === true) {
         return callback_one(val); //where val is potentially some value you want to return (or a json object with results)
    }
    //more code you may have
}

Puis dans le premier code que vous avez posté, faire appel à la place (dans le plus intérieur de la partie):

recurse(startingPlace, otherFunc, function (results) {
    //results is now a variable with the data returned at the end of recursion
    console.log ("Recursion finished with results " + results);
    callback();   //the callback that you wanted to call right from the beginning
});

Juste passer un peu de temps et d'essayer de comprendre mon explication. Quand vous comprenez, alors vous connaîtrez ce nœud. C'est le nœud de la philosophie dans un post. J'espère que c'est clair. Votre premier exemple devrait ressembler à ceci:

var start = function(callback) {
  request.get({
    url: 'aaa.com'
  }, function (error, response, body) {
    var startingPlace = JSON.parse(body).id;
    recurse(startingPlace, otherFunc, function (results) {
        console.log ("Recursion finished with results " + results);
        callback();
    });
  });
};

Ci-dessous est uniquement des informations supplémentaires dans le cas où vous êtes intéressé. Sinon, vous avez défini ci-dessus.

Généralement dans node.js cependant, les gens retournent une valeur d'erreur, de sorte que l'appelant sait si la fonction a été appelée a terminé avec succès. Il n'y a pas de grand mystère ici. Au lieu de retourner à seulement results les gens font un appel de la forme

return callback_one(null, val);

Puis dans l'autre fonction, vous pouvez avoir:

recurse(startingPlace, otherFunc, function (recError, results) {
    if (recErr) {
         //treat the error from recursion
         return callback(); //important: use return, otherwise you will keep on executing whatever is there after the if part when the callback ends ;)
    }

    //No problems/errors
    console.log ("Recursion finished with results " + results);
    callback();   //writing down `return callback();` is not a bad habit when you want to stop execution there and actually call the callback()
});

Mise à jour avec ma suggestion

C'est ma suggestion pour la fonction récursive, mais avant cela, il semble que vous devez définir vos propres get:

function myGet (a, callback) {
request.get(a, function (error, response, body) {
var nextPlace = JSON.parse(body).place;
return callback(null, nextPlace); //null for no errors, and return the nextPlace to async
});
}
var recurse = function(startingPlace, callback2) {
request.get({
url: 'bbb'
}, function(error1, response1, body1) {
//store body somewhere outside these funtions
//make second request
request.get({
url: 'ccc'
}, function(error2, response2, body2) {
var anArray = JSON.parse(body2).stuff;
if (anArray) {
//The function that you want to call for each element of the array is `get`.
//So, prepare these calls, but you also need to pass different arguments
//and this is where `bind` comes into the picture and the link that I gave earlier.
var theParallelCalls = [];
for (var i = 0; i < anArray.length; i++) {
theParallelCalls.push(myGet.bind(null, {url: 'ddd'})); //Here, during the execution, parallel will pass its own callback as third argument of `myGet`; this is why we have callback and callback2 in the code
}
//Now perform the parallel calls:
async.parallel(theParallelCalls, function (error3, results) {
//All the parallel calls have returned
for (var i = 0; i < results.length; i++) {
var nextPlace = results[i];
recurse(nextPlace, callback2);
}
});
} else {
return callback2(null);
}
});
});
};

Remarque que je suppose que la get demande de " bbb "est toujours suivi par un get demande de "ccc". En d'autres termes, vous n'avez pas caché un point de retour pour les appels récursifs où vous avez les commentaires.

OriginalL'auteur MightyMouse

Je pense que vous pourriez trouver caolan/async utile. Regardez surtout dans async.waterfall. Il vous permettra de passer des résultats à partir d'un rappel de l'autre et quand c'est fait, faire quelque chose avec les résultats.

Exemple:

async.waterfall([
function(cb) {
request.get({
url: 'aaa.com'
}, function(err, res, body) {
if(err) {
return cb(err);
}
cb(null, JSON.parse(body).id);
});
},
function(id, cb) {
//do that otherFunc now
//...
cb(); //remember to pass result here
}
], function (err, result) {
//do something with possible error and result now
});

OriginalL'auteur Juho Vepsäläinen

Construire votre code à partir de cet exemple:

var udpate = function (callback){
//Do stuff
callback(null);
}
function doUpdate() {
update(updateDone)
}
function updateDone(err) {
if (err)
throw err;
else
doUpdate()
}
doUpdate();

OriginalL'auteur Augusto Federico Lemble