comment déclencher un processus asynchrone l'un après l'autre

Question

Comment je devrais modifier le code suivant, afin que je puisse m'assurer que Process3 est déclenché après Process2.update ou Process2.create terminé?

Le but principal pour le code suivant est que je veux faire

Process1 terminé. Ensuite, vérifiez si ID existe, si oui, Process2.update est déclenché. sinon, Process2.create est déclenché.

Une fois Process2 terminé, vérifiez si cmd existait. si oui, déclenché Process3.

run: function (req, res) { 
    if (req.session) { 
     const values = req.params.all(); 
     const id = values.id; 
     const cmd = values.cmd; 
     const param = _.omit(values, ['cmd', 'id']); 

     const cb1 = (e, d) => { 
     if (e) { 
      console.log(e); 
      res.status(400).send({ e }); 
     } else { 
      Process1(values); 
      res.status(200).send({ d }); 
     } 
     }; 
     const cd2 = (id, param, cb1) => { 
     if (id) { 
      Process2.update({ id }, param, cb1); 
     } else { 
      Process2.create(param, cb1); 
     } 
     }; 

     if (cmd) { 
     cd2(id, param, cb1, Process3(values, cmd)); 
     } 
     else { 
     cd2(id, param, cb1); 
     } 

    } else { 
     res.status(403).send({ e: 'Forbidden access.' }); 
    } 
    } 

approche

d'essai en suivant, mais ne sais pas comment je peux passer argument id, params à Process2 et processus3

let async = require('async'); 
const Process1 = (value, cb) => { 
    console.log("Process1()"); 
    console.log(value); 
    cb(null, value + 1); 
}; 
const Process2 = (value, cb) => { 
    console.log("value(): wait 5 sec"); 
    console.log(value); 
    cb(null, value+10); 
}; 
const Process3 = (value, cb) => { 
    console.log(value); 
    console.log("Process3(): wait 5 sec"); 
    cb(null, value+100); 
}; 
let Pro_1_2 = async.compose(Process2, Process1); 
let Pro_2_3 = async.compose(Process3, Process2); 
Pro_1_2(1, (e, r) => { 
    Pro_2_3(r, (error, result) => { 
     console.log(result); 
    }); 
}); 

Answer 1

Avez-vous pensé à utiliser "compose", de async.js?

const a = (data, cb) => { 
    var result = 'a'; 
    cb(null, result); 
}; 
const b = (data, id, cb) => { 
    var result = 'b'; 
    cb(null, result); 
}; 
const c = (data, cb) => { 
    // stuff to do with result 
}; 

var aThenC = async.compose(c, a); 
var bThenC = async.compose(c, b); 

if (useA) { 
    aThenC(data, (result) => { 
    // result from c 
    res.status(200).send(result); 
    }); 
} else { 
    bThenC(data, id, (result) => { 
    // result from c 
    res.status(200).send(result); 
    }); 
} 

Dans ce scénario, un et b sont votre Process2 créer et mettre à jour, respectivement, et c est le rappel à processus3, si je comprends bien.

EDIT: Il vous suffit d'entrer les paramètres initiaux (par exemple, ID de registre) sur la fonction composée. Ce que les composes font vraiment, c'est ceci: a (b (c (param))). Ce param est essentiellement tout ce dont vous avez besoin pour démarrer le processus. Les paramètres pour les fonctions suivantes seront définis dans la fonction avant cela.

Je vais ajouter du code pour le prendre en charge dès que je suis sur un clavier.

Answer 2

Le code affiché dans votre question initiale semble assez tordu, donc je ne vais pas essayer de le réécrire, mais en général si vous voulez effectuer des appels asynchrones qui dépendent les uns des autres, async.auto est un bon marche à suivre. Plutôt que de déclarer des variables en haut que vous essayez de muter via certains appels de fonction, il est préférable de faire Process1, Process2 et Process3 des fonctions asynchrones qui appellent leurs rappels avec un nouvel objet values. Quelque chose comme:

async.auto({ 

    doProcess1: function(cb) { 
    // Assuming Process1 calls `cb(undefined, newValues)` when done. 
    Process1(values, cb); 
    return; 
    }, 

    doProcess2: ['doProcess1', function(results, cb) { 
    if (results.doProcess1.id) { 
     Process2.update({id: results.doProcess1.id}, cb); 
     return; 
    } else { 
     Process2.create(_.omit(results.doProcess1, ['cmd', 'id']), cb); 
     return; 
    } 
    }], 

    doProcess3: ['doProcess2', function(results, cb) { 
    if (results.doProcess2.cmd) { 
     Process3(results.doProcess2, cb); 
     return; 
    } 
    else { 
     cb(undefined, results.process2); 
     return; 
    } 

    }] 

}, function afterProcess3(err, results) { 
    // Handler err or process final results. 
}); 

Notez tous les appels return. Ils ne sont pas strictement nécessaires, mais une bonne pratique pour éviter d'exécuter accidentellement plus de code après avoir appelé vos fonctions asynchrones.