6
votes

Noeud async parallèle à l'intérieur de la cascade

Je construis un serveur dans NodeJS pour récupérer des données d'une base de données. J'ai travaillé avec la bibliothèque ASYNC depuis un certain temps et j'ai compris certaines choses comme mettre une cascade à l'intérieur d'une fonction parallèle.

J'ai trébuché sur un problème où je dois d'abord exécuter une requête puis utiliser ce résultat de cette requête requêtes qui peuvent être exécutées simultanément. Le code ressemble à ceci: xxx

Mon problème est d'accéder au résultat de la fonction de cascade et de l'utiliser dans les fonctions parallèles.


0 commentaires

3 Réponses :


1
votes

Essayez ceci ..

    async.waterfall([

  function(callback) {
    connection.query(query,
      function(err, rows, fields) {
        if (!err) {
          callback(null, rows);
        } else {
          callback(null, "SORRY");
        }
      }
    );
  },
  function(resultFromWaterfall, callback) {
    async.parallel([

      function() {
        connection.query(query,
          function(err, rows, fields) {
            if (!err) {
              callback(null, rows);
            } else {
              callback(null, "SORRY");
            }
          }
        );
      },
      function() {
        connection.query(query,
          function(err, rows, fields) {
            if (!err) {
              callback(null, rows);
            } else {
              callback(null, "SORRY");
            }
          }
        );
      }
    ]);
  }

], finalCallback);


3 commentaires

Ne fonctionne pas non plus non plus, RésultatFromwatefall détient la fonction de rappel dans ce cas.


Qu'est-ce que vous obtenez dans rappel ?


Pas besoin de passer un autre Callback dans parallèle , je viens de mettre à jour la réponse, il doit fonctionner



5
votes
async.waterfall([
    function(callback) {
        connection.query(query,
            function(err, rows, fields) {
                if (!err) {
                    callback(null, rows);
                } else {
                    callback(null, "SORRY");
                }
            }
        );
    },
    function(prevData,callback){
      console.log(prevData);//Use it whereever you want.
      async.parallel([
          function(callbackOfAsyncParallel) {
              connection.query(query1,
                  function(err, rows1, fields1) {
                      if (!err) {
                          callbackOfAsyncParallel(null, rows1);
                      } else {
                          callbackOfAsyncParallel(null, "SORRY1");
                      }
                  }
              );
          },
          function(callback) {
              connection.query(query2,
                  function(err, rows2, fields2) {
                    if (!err) {
                        callbackOfAsyncParallel(null, rows2);
                    } else {
                        callbackOfAsyncParallel(null, "SORRY2");
                    }
                  }
              );
          }
      ],function mainCBOfParallel(err,reuslts){
        if(!err){
          //this will be done after tasks in async.parallel are finished.
          callback(null,results);
          //results[0]===>rows1
          //results[1]===>rows2
        }
      });
    }
], finalCallback);
You have two mistakes in your code,
tasks should be a function to execute.
async.parallel has only callbacks in its task functions.
Update
  There are callbacks (callbackOfAsyncParallel) which will be called
  when a task in async.parallel is finished.
  
  It should not invoke callback (callback) of async.waterfall.If
  done probably there may be error/unexpected results.

3 commentaires

Donc, il n'y a vraiment aucun moyen de transmettre l'argument sur les fonctions de tâche ASYNC.PARALLES? :(


Non!! Il est disponible partout dans async.parallel ...! Pourquoi tu as besoin de passer ??


Oui, j'ai remarqué maintenant qu'il est disponible dans les fonctions et je n'ai pas besoin de le transmettre. Ça marche.



1
votes
  doWhatever(callback) {
    async.waterfall([
      (waterfallCallback) => {
        connection.query(query, waterfallCallback);
      },
      (rows, fields, waterfallCallback) => {
        async.parallel([
          (parallelCallback) => {
            connection.query(query, parallelCallback);
          },
          (parallelCallback) => {
            connection.query(query, parallelCallback);
          }
        ], waterfallCallback);
      }
    ], callback);
  },
That's just me trying to make it clearer…Anyway, my exemple is not taking into account parameters and arguments of query. It's just a scaffold

0 commentaires