Faire un synchrone boucle de synchrone des rappels avec node.js + Q différé/promesses module

Le populaire JavaScript module Q met en œuvre le différé /promesse /contrats à terme de concept. Je pense que c'est principalement utilisée avec node.js mais il soutien navigateur qu'il utilise. Je l'utilise avec node.js.

Faire séquentielle vous appelle de la chaîne d'une promesse à l'autre à l'aide de then() mais dans une boucle, il peut être contre-intuitif que j'ai du mal à faire la même chose que ce pseudo-code:

forever {
    l = getline();

    if (l === undefined) {
        break;
    } else {
        doStuff(l);
    }
}

Le Q de la documentation inclut un exemple de ce qui semble assez similaire:

var funcs = [foo, bar, baz, qux];

var result = Q.resolve(initialVal);
funcs.forEach(function (f) {
    result = result.then(f);
});
return result;

Mais en essayant de nombreuses façons d'adapter cet exemple à mon problème, je vais avoir pas de succès du tout.

Contrairement à l'exemple de code que je ne suis pas une itération sur un tableau, mais qui souhaitent en boucle jusqu'à ce qu'une condition de fin est rencontré. Aussi j'ai toujours appeler la même fonction. Ma fonction ne prend pas le résultat précédent en tant que paramètre à l'appel suivant. Chaque appel ne prend pas d'arguments, mais la valeur de retour décide de continuer la boucle.

Ces anodin différences sont à l'origine de certains type de insurmontable blocage mental. Maintenant, je peux voir pourquoi beaucoup de gens ont de la difficulté à comprendre promesses.

OriginalL'auteur hippietrail | 2013-02-17

6

L'essentiel à retenir est que si vous retournez une promesse d'un then de rappel, puis il remplacera l'actuel promesse. L'idée est qu'après l'exécution d'une itération de ce que la chaîne de choses que vous voulez faire dans le corps de la boucle, vous pouvez soit retourner une valeur, qui permettra de résoudre la promesse, ou vous renvoyer une nouvelle promesse qui va exécuter le corps de la boucle à nouveau.
```
function iterateUntil(endValue){
  //This line would eventually resolve the promise with something matching
  //the final ending condition.
  return Q.resolve('some value')
    .then(function(value){
      //If the promise was resolved with the loop end condition then you just
      //return the value or something, which will resolve the promise.
      if (value == endValue) return value;

      //Otherwise you call 'iterateUntil' again which will replace the current
      //promise with a new one that will do another iteration.
      else return iterateUntil(endValue);
    });
}
```
Je l'ai fait essayer et ne parviennent pas à obtenir une version récursive de travail ainsi que d'un processus itératif. Je vais essayer cela, mais n'est-il pas un risque de faire exploser la pile? Mon projet sera le traitement des fichiers texte avec plusieurs millions de lignes.
Cette solution récursive devrait fonctionner. Ce ne tuent pas la pile parce que la pile commence frais pour les opérations asynchrones, de sorte que le then de rappel est le début d'une nouvelle pile de départ lors du prochain processus de tique.
Cela semble fonctionner, mais je ne peux pas trouver un moyen de piéger une condition de fin. Je veux dire par cela, je veux du code à exécuter qu'après cette boucle se termine. En fait, je suis sûr que c'est même pas la fin en raison de la ligne de if (value == endValue) return value; parce que si j'ai l'impression qu'il est de mon endValue ne se présente jamais. L'ajout de errbacks dans divers endroits jamais entraîner dans n'importe quel être appelé. Et le pire, c'est que Q semble supprimer toute trace de la pile - lorsqu'elle échoue, elle échoue toujours en silence.
Pouvez-vous ajouter votre tentative de la question? C'est dur de donner de bonnes suggestions avec juste la description.
Vous répondez n'rendre plus facile pour moi de traiter de certains autres asynchrone en boucle des problèmes avec Q donc je l'accepte. Je vais jouer à ce problème spécifique un peu plus et post détaillé code si je n'ai pas encore craquer. Merci.

OriginalL'auteur loganfsmyth
0

Ce n'est pas spécifique à Q: Synchrone pour la boucle.

J'ai été en utilisant ces types de boucles de trop, mais une fois que vous obtenez un peu imbriquées, en particulier avec différentes saveurs de boucles, vous pouvez vous retrouver avec un nouveau type de illisible code spaghetti. J'ai souvent confondu moi-même et a décidé que, dans ce cas, la main-codage sans une sorte de plus lisible l'abstraction était la voie à suivre. Pour les non-boucles imbriquées dans de petits scripts si je suis d'accord avec vous.

OriginalL'auteur Distortum

Vous devez vous connecter pour publier un commentaire.