nodejs concatenare con async

Question

nodejs concatenare con async

#1 da (4 voti)

5

Sto provando a concatenare una serie di metodi asincroni. Ho sentito parlare di promesse e futures, ma quello che sto cercando è:

obj.setup()
    .do_something()
    .do_another_thing()
    .end()

e non:

obj.setup()
    .then(...)
    .then(....)

Ho trovato un tutorial che spiega come farlo, ma sfortunatamente il centesimo non è stato cancellato: link Quindi sto cercando un modulo. Questo modulo, link , sembra avere chainify nella sua API ma non c'è documentazione su come usarlo. In effetti non riesco a trovare alcuna documentazione su come utilizzare i moduli per ottenere ciò che sto cercando, ma molto sull'usare promesse per ottenere then().then().then() che non è quello che mi serve.

Attualmente il mio modulo assomiglia a:

var obj = function(){
   this.async_method = function(){}
   this.async_method_thingy = function(){}
   this.async_method_foo = function(){}
}
var o = new obj()

var _ = {
   "setup" : function(){
      ...
      return this
   },
   "do_something" : function(){
      o.async_method()
      return this
   },
   "do_another_thing" : function(){
      o.async_method_thingy()
      return this
   },
   "end" : function(){
      o.async_method_foo()
      return this
   }
}

module.exports = _

qualsiasi aiuto è apprezzato;)

node.js method-chaining

posta Daithí 07.01.2014 - 10:38

fonte

1 risposta

Leggi altre domande sui tag node.js method-chaining

Python: come decidere quali metodi di classe devono fornire un comportamento (funzionalità) che influenza più classi Come risolvere questo problema - Rete neurale? Fuzzy? Altro?

score 4 · Answer 1

Penso che tu stia cercando il modulo async su npm .

Trovalo su github al link .

Questo modulo supporta molte utility per fare cose in modo asincrono che sono tipicamente sincrone, come una ricerca lineare attraverso un array.

Ancora più importante per te, consente di concatenare le funzioni asincrone. Ha 2 modalità che è possibile utilizzare: parallele o seriali. In modalità parallela, esegue le funzioni asincrone in parallelo (questa è una bugia come nulla in parallelo in node.js, ma si limiterà semplicemente a cambiare contesto in base alle chiamate I / O come qualsiasi roba asincrona funziona nel nodo). In modalità seriale, esegue ogni funzione dopo la precedente, concatenando i callback insieme.

Dai rapidi esempi sul loro README:

async.parallel([
    function(){ ... },
    function(){ ... }
], callback);

async.series([
    function(){ ... },
    function(){ ... }
]);

Quindi, se ho capito bene la tua domanda, quello che vuoi fare è questo:

async.series([
  obj.setup.bind(obj),
  obj.do_something.bind(obj),
  obj.do_another_thing.bind(obj),
  obj.end.bind(obj)
]);

Questo è il modo in cui async theCook gestisce questo e puoi farlo tu stesso se non vuoi usare il modulo:

obj.setup(function () {
  obj.do_something(function () {
    obj.do_another_thing(function () {
      obj.end();
    });
  });
});

Come puoi vedere, questo diventa complicato quando aggiungi sempre più funzioni alla catena. Ecco perché la chiamata async.series è più gestibile.

Devi anche aggiornare le tue funzioni per utilizzare le callback. Non importa quali strumenti o framework usi, se le tue funzioni asincrone non passano una richiamata, non c'è modo di sapere se il siero ha finito e quindi non c'è modo di passare alla funzione successiva nella catena.

Modifiche delle funzioni:

var _ = {
   "setup" : function(callback){
      ...
      return this
   },
   "do_something" : function(callback){
      o.async_method(callback)
      return this
   },
   "do_another_thing" : function(callback){
      o.async_method_thingy(callback)
      return this
   },
   "end" : function(callback){
      o.async_method_foo(callback)
      return this
   }
}