ES6 Promises - so etwas wie async.jeder?

Bild zu versuchen-heraus, wie um etwas zu finden, die funktional genau wie async.eachSeries, ich brauche eine Liste von asynchronen Aktionen nacheinander ablaufen (nicht parallel), aber kann nicht einen Weg finden, es zu tun im einheitlichen ES6, kann mir jemand raten, bitte?

p.s. Gedanken über Generatoren/yield, haben aber nicht die Erfahrung, aber ich bin mir nicht klar, wie genau Sie mir helfen können.

Bearbeiten 1

pro Anfrage, hier ein Beispiel:

Ausgehen, dass sich dieser code:

let model1 = new MongooseModel({prop1: "a", prop2: "b"});
let model2 = new MongooseModel({prop1: "c", prop2: "d"});

let arr = [model1 , model2];

Nun, ich will laufen über Sie in einer Reihe, nicht parallel, also mit der "async" - NPM ist es ganz einfach:

async.eachSeries(arr, (model, next)=>{
    model.save.then(next).catch(next);
}, err=>{
    if(err) return reject(error);
    resolve();
})

Meine Frage ist: mit ES6, kann ich es nativ? ohne die NPM 'async' - Paket?

Edit 2

Mit async/await-es kann leicht gemacht werden:

let model1 = new MongooseModel({prop1: "a", prop2: "b"});
let model2 = new MongooseModel({prop1: "c", prop2: "d"});    

let arr = [model1 , model2];

for(let model of arr){
    await model.save();
}
  • Du meinst, die zweite Funktion hängt vom Ergebnis der ersten Funktion?
  • Es ist nicht, muss es abhängen, sondern muss ausgeführt werden, nachdem der Vorherige getan hat.
  • Sie sollten ein Beispiel geben und den sample-input und erwarteten output, um das problem zu erklären richtig.
  • Zugegeben ein Beispiel, danke!
InformationsquelleAutor Shlomi Sasson | 2015-08-15
  1. 47

    Für diejenigen, die gerne kurze Antworten:

    [func1, func2].reduce((p, f) => p.then(f), Promise.resolve());
    • warum die Versprechen.resolve() den zweiten parameter?
    • Der zweite parameter ist die Anfangswert von der Reduktion. E. g. dieses Beispiel ist äquivalent zu Promise.resolve().then(func1).then(func2).
    • Du bist ein Magier. Genau das, was ich brauchte.
    • Danke, wo würdest du den code, der ausgeführt wird, wenn die Letzte Versprechen löst?
    • Setzen .then(resultFromFunc2 => console.log("all done")) am Ende, bevor ;.
    • Genial, danke @jib
    • Ich hatte gerade einen kleinen Orgasmus
    • Interessant, aber ich bin mir nicht sicher, wie das ist sehr Verschieden von Promise.all([func1, func2]);.
    • Die async Funktionen laufen nacheinander, nicht parallel.
    • Ah, dass ist richtig. Gut zu wissen.

    InformationsquelleAutor jib
  2. 14

    Lassen Sie uns sagen Sie, dass Sie möchten, um eine async-Funktion auf ein array von Daten, und Sie wollen, dass Sie genannt sequentiell, nicht parallel.

    Schnittstelle für async.eachSeries() ist wie folgt:

    eachSeries(arr, iterator, [callback])

    Hier ist, wie um zu simulieren, dass mit dem Versprechen:

    //define helper function that works kind of like async.eachSeries
function eachSeries(arr, iteratorFn) {
    return arr.reduce(function(p, item) {
        return p.then(function() {
            return iteratorFn(item);
        });
    }, Promise.resolve());
}

    Dies setzt Voraus, dass iteratorFn nimmt die Sache zu verarbeiten, wie ein argument und es gibt ein Versprechen.

    Hier ein Verwendungs-Beispiel (vorausgesetzt, dass Sie eine promisified fs.readFileAsync()) und haben eine Funktion namens speak(), die eine Zusage zurückgibt, wenn Sie fertig:

     var files = ["hello.dat", "goodbye.dat", "genericgreeting.dat"];
 eachSeries(files, function(file) {
     return fs.readFileAsync(file).then(function(data) {
         return speak(data);
     });
 });

    Diese können das Versprechen, Infrastruktur-Sequenz, die alles für Sie.

    Ist es auch möglich für Sie, um die Sequenz, die Dinge manuell (obwohl ich nicht sicher bin, warum):

    function eachSeries(arr, iteratorFn) {
    return new Promise(resolve, reject) {
        var index = 0;

        function next() {
            if (index < arr.length) {
                try {
                    iteratorFn(arr[index++]).then(next, reject);
                } catch(e) {
                    reject(e);
                }
            } else {
                resolve();
            }
        }
        //kick off first iteration
        next();
    });
}

    Oder eine einfachere version, die manuell Ketten der verspricht zusammen:

    function eachSeries(arr, iteratorFn) {
    var index = 0;

    function next() {
        if (index < arr.length) {
            return iteratorFn(arr[index++]).then(next);
        }
    }
    return Promise.resolve().then(next);
}

    Beachten Sie, wie einer der manual-Versionen hat zu umgeben iteratorFn() mit try/catch um sicherzustellen, dass es ist, werfen-sicher (konvertieren Ausnahmen in einer Ablehnung). .then() automatisch werfen-sicher, so dass die anderen Systeme nicht haben, um manuell abfangen von Ausnahmen, da .then() schon fängt Sie für Sie.

    • Präzise und elegant.
    • Als ich dachte, es muss rekursiven Teil zu Holen das array bis zum Ende.. in diesem Fall, ich nehme an, ich werde halten, verwenden aync.eachSeries..
    • es gibt nichts rekursiv in meinem ersten Beispiel also eine rekursive Teil ist nicht notwendig. Es verwendet einfach array.reduce() zum Durchlaufen des Arrays und verwendet verspricht Kette zusammen, alle Vorgänge.
    • Ja, du hast Recht, war nicht vertraut mit der recude Methode und jetzt ich verstehe, dass. Also für dein Beispiel, wie ich jetzt weiter, wenn alle asynchronen Aktionen gemacht hat? ich sehe nicht eine Stelle, die Sie berufen sich auf die Allgemeinen "Rückruf"..
    • Könnten Sie dies erläutern? Zum Beispiel, in der EachSeries Funktion, rufen Sie Promise.resolve()); ohne Angabe Promise überall. Auch, was sind die p, item aus array.reduce?
    • akzeptiert zwei Argumente. Die erste ist eine Funktion, der zweite ist der erste Wert von dem, was Sie reduzieren. Promise.resolve() ist die Herstellung, der Ausgangswert. Die callback übergeben Sie dann mit zwei Argumenten aufgerufen. Das erste argument der aktuelle Wert in der Reduktion. Ich habe benannt, dass p in meinem code, und es ist der erste Wert der Promise.resolve(). Nachfolgende Werte wird der Rückgabewert von meinen Rückruf return p.then(...) was andere Versprechen. Das zweite argument an den callback ist der nächste Wert in dem array, das wir reduzieren.
    • Siehe hier auf MDN für den doc auf .reduce(). Sie nennen es wie folgt: var reducedValue = array.reduce(fn, initialValue). Meine Promise.resolve() ist, dass initialValue. Es ist nur ein Weg, um ein Versprechen Kette initialisieren, um ein bereits gelöst Versprechen. Es ist wie eine Art Promise.resolve().then(fn1).then(fn2).then(fn3).
    • Ich Schätze wirklich Ihre Umsetzung. Ist dies so einfach wie möglich aber? Ich dachte, die Versprechungen waren, soll dabei helfen, etwas zu schaffen, wie dies mehr leicht aber das ist viel komplizierter als nur die Verwendung des async-Bibliothek.
    • Wenn Sie Faktor in die richtige Fehlerbehandlung und mögliche geschachtelte Operationen, verspricht sind die Hände nach unten die beste Möglichkeit zum verwalten von Dingen. Plus Sie sind der Kern async und await im ES7 so sind Sie die Zukunft der Sprache zu. Wenn ich wollte, um die Sequenz durch eine Reihe asynchron, ich würde so etwas wie Promise.mapSeries() im Bluebird Versprechen-Bibliothek ist die Bibliothek, die ich verwenden in der Regel zum hinzufügen von erweiterten Fähigkeiten Versprechen.
    • Ich sehe aber gerade auf der Suche an diesem code will ich eine Schleife durch ein array von Elementen, und die Summe der insgesamt durch den Suche Sie in einer Datenbank, dann senden Sie eine Antwort mit der Summe. Dieser code hier benötigt 5 return Aussagen zu tun. Es scheint wie eine Menge, wie ich bin immer noch versuchen, wickeln Sie meinen Kopf herum alle von Ihnen.
    • Vielleicht solltest du die Frage posten mit einer guten Beschreibung, was Sie zu tun versuchen, und Fragen, wie die beste Weg, es zu tun mit Verspricht ist. Ich kann nicht sehen, Ihre tatsächliche problem in meinem Kopf aus, nur die Wörter, die Sie verwenden, so würde es besser sein, zu sehen deinen code und dann die Leute anbieten könnte, die bessere/andere Möglichkeiten, es zu tun. Ich habe nie gefunden, eine situation, wo mit Versprechungen benötigt mehr code, als nicht mit Versprechungen. Wie bei vielen Dingen gibt es gute Möglichkeiten, um zu schreiben, Versprechen code und nicht so gute Möglichkeiten.
    • Bitte korrigieren Sie mich, wenn ich falsch Liege. Der Unterschied zwischen den beiden Methoden ist, dass die zuerst erstellt man ein Versprechen Vorderseite für jedes Element in der Liste, während der zweite Ansatz schafft verspricht auf Nachfrage. Ich versuche zum Ausstieg aus der zweite Ansatz, aber ich möchte sicherstellen, dass ich verstehen, das der realen Welt Kompromisse. Hat der zweite Ansatz skaliert besser, mehr Listen als die erste?
    • Ja, der erste Ansatz legt eine erste Versprechen Kette über die gesamte Länge der iteration im Voraus und dann lässt Sie laufen. Die anderen Ansätze Kette ein neues Versprechen in einer Zeit, als die vorherigen behebt und die älteren können GCed. Wenn Sie hatte eine wirklich lange iteration (wie Millionen), dann die letzten Optionen verwenden könnte, einen deutlich geringeren Betrag von peak Speicher.

    InformationsquelleAutor jfriend00
  3. 1

    Als eine Erweiterung der Antwort von @jib... man kann auch die Karte eine Reihe von Elementen, um asynchrone Funktionen wie:

    [item1, item2]
    .map(item => async (prev_result) => await something_async(item))
    .reduce((p, f) => p.then(f), Promise.resolve())
    .then(() => console.log('all done'));

    Bemerken, wie prev_result wird der Wert zurückgegeben, der durch die bisherige Auswertung der something_async dies entspricht etwa einem hybrid zwischen async.eachSeries und async.waterfall.

    InformationsquelleAutor Blake Regalia
  4. 0

    Können Sie die Kette von der Rückkehr in die then Rückruf. Zum Beispiel:

    new Promise(function(resolve, reject){ 
  resolve(1)
}).then(function(v){
  console.log(v);
  return v + 1;
}).then(function(v){
  console.log(v)
});

    Drucken:

    1

    2

    Diese natürlich Arbeit, wenn asynchron Lösung verspricht:

    new Promise(function(resolve, reject){
  setTimeout(function(){
    resolve(1);
  }, 1000)
}).then(function(result){
   return new Promise(function(resolve, reject){
     setTimeout(function(){
       console.log(result);
       resolve(result + 1);
     }, 1000)
   });
}).then(function(results){
  console.log(results);
});

    Druck:

    1

    2

    • Danke, aber ich brauche es für eine dynamische Sammlung von Daten, die nicht für einige statische bekannten Menge von Iterationen..
    • Es ist nur ein Beispiel. Alle then tut, ist die Rückkehr ein Versprechen, übergeben Sie Rückrufe und erstellen Sie verspricht, wie gebraucht.
    • Kit, also was Sie sagen ist erstellen Sie eine rekursive Funktion, lege mehr und mehr Rückrufe zu der "dann" - Methode?
    • Auch du solltest nicht rekursiv durchsuchen, genau das, was jfriend00 getan hat, mit reduzieren. Es ist ein ES7 Vorschlag zu machen, in diesem speziellen Fall einfacher btw: github.com/lukehoban/ecmascript-asyncawait
    InformationsquelleAutor Kit Sunde
  5. 0

    //Hochladen dies für Systeme, die laufen tiefer nodejs-version (Azure :/)
    Nicht die kürzeste aber die schönste die ich mir denken kann

    zum Beispiel können sagen, "functionWithPromise" gibt einige Versprechen, und erwartet, dass einige Artikel.

    functionWithPromise(item);

promisesArray =[];

//syncornized
itemsArray.forEach(function (item){
   promisesArray.push(functionWithPromise(item));
});

Promise.all(promisesArray).then(function (values){
//profit
});
    • Diese läuft die Versprechen, die parallel dazu nicht in der Reihenfolge
    InformationsquelleAutor adi ben
Schreibe einen Kommentar