Gewusst wie: synchronisieren von einer Sequenz von verspricht?

Hier sind einige einfache Beispiele dafür, wie Sie die Sequenz durch eine Reihe Ausführung jeder async-Betrieb Seriell (eins nach dem anderen).

Nehmen wir an, Sie haben ein array von Elementen:

var arr = [...];

Und Sie wollen zu tragen eine bestimmte asynchrone operation auf jedes Element im array, jeweils abwechselnd, so dass die nächste Aktion nicht zu starten, bis die Vorherige fertig ist.

Und, nehmen wir an, Sie haben ein Versprechen der Rückkehr-Funktion für die Bearbeitung eines der Elemente im array fn(item):

Manuelle Iteration

function processItem(item) {
    //do async operation and process the result
    //return a promise
}

Dann können Sie etwas wie das hier tun:

function processArray(array, fn) {
    var index = 0;

    function next() {
        if (index < array.length) {
            fn(array[index++]).then(next);
        }
    }
    next();
}

processArray(arr, processItem);

Manuelle Iteration Rückkehr Versprechen

Wenn Sie wollte ein Versprechen zurück von processArray() so würden Sie wissen, wenn es gemacht wurde, könnte man hinzufügen, diese es:

function processArray(array, fn) {
    var index = 0;

    function next() {
        if (index < array.length) {
            return fn(array[index++]).then(function(value) {
                //apply some logic to value
                //you have three options here:
                //1) Call next() to continue processing the result of the array
                //2) throw err to stop processing and result in a rejected promise being returned
                //3) return value to stop processing and result in a resolved promise being returned
                return next();
            });
        }
    } else {
        //return whatever you want to return when all processing is done
        //this returne value will be the ersolved value of the returned promise.
        return "all done";
    }
}

processArray(arr, processItem).then(function(result) {
    //all done here
    console.log(result);
}, function(err) {
    //rejection happened
    console.log(err);
});

Hinweis: dies wird verhindern, dass die Kette auf der ersten Ablehnung und der pass, der Grund zurück an den processArray zurückgegeben Versprechen.

Iteration mit .reduce()

Wenn Sie das tun wollten mehr von der Arbeit mit dem Versprechen, Sie könnten die Kette der Verheißungen:

function processArray(array, fn) {
   return array.reduce(function(p, item) {
       return p.then(function() {
          return fn(item);
       });
   }, Promise.resolve());
}

processArray(arr, processItem).then(function(result) {
    //all done here
}, function(reason) {
    //rejection happened
});

Hinweis: dies wird verhindern, dass die Kette auf die erste Ablehnung, und übergeben Sie deshalb zurück zu der Verheißung zurück von processArray().

Erfolg Szenario, das Versprechen zurück von processArray() gelöst werden mit dem letzten aufgelöst Wert Ihrer fn Rückruf. Wenn Sie wollten, zu sammeln eine Liste der Ergebnisse und die Entschlossenheit, mit Sie sammeln konnte, die Ergebnisse einer Schließung array von fn und weiter zurück, das array wird jedes mal, so dass die endgültige Behebung wäre ein array der Ergebnisse.

Iteration mit .reduce (), die Löst sich Mit der Array -

Und da scheint es nun offensichtlich, dass Sie wollen, dass die endgültige Versprechen zu Folge werden eine Reihe von Daten (in der Reihenfolge), hier ist eine überarbeitung der bisherigen Lösung, die produziert:

function processArray(array, fn) {
   var results = [];
   return array.reduce(function(p, item) {
       return p.then(function() {
           return fn(item).then(function(data) {
               results.push(data);
               return results;
           });
       });
   }, Promise.resolve());
}

processArray(arr, processItem).then(function(result) {
    //all done here
    //array of data here in result
}, function(reason) {
    //rejection happened
});

Arbeiten demo: http://jsfiddle.net/jfriend00/h3zaw8u8/

Sowie eine funktionierende demo, die zeigt, dass eine Ablehnung: http://jsfiddle.net/jfriend00/p0ffbpoc/

Iteration mit .reduce (), die Löst sich Mit der Array mit Verzögerung

Und, wenn Sie möchten, legen Sie eine kleine Verzögerung zwischen Vorgängen:

function delay(t, v) {
    return new Promise(function(resolve) {
        setTimeout(resolve.bind(null, v), t);
    });
}

function processArrayWithDelay(array, t, fn) {
   var results = [];
   return array.reduce(function(p, item) {
       return p.then(function() {
           return fn(item).then(function(data) {
               results.push(data);
               return delay(t, results);
           });
       });
   }, Promise.resolve());
}

processArray(arr, 200, processItem).then(function(result) {
    //all done here
    //array of data here in result
}, function(reason) {
    //rejection happened
});

Iteration mit Bluebird Versprechen Bibliothek

Bluebird Versprechen-Bibliothek hat eine Menge von Parallelität controlling-Funktionen direkt in Sie integriert. Zum Beispiel, um die Sequenz iteration durch ein array verwenden, können Sie Promise.mapSeries().

Promise.mapSeries(arr, function(item) {
    //process each individual item here, return a promise
    return processItem(item);
}).then(function(results) {
    //process final results here
}).catch(function(err) {
    //process array here
});

Oder legen Sie eine Verzögerung zwischen Iterationen:

Promise.mapSeries(arr, function(item) {
    //process each individual item here, return a promise
    return processItem(item).delay(100);
}).then(function(results) {
    //process final results here
}).catch(function(err) {
    //process array here
});

Mit ES7 async/await

Wenn Sie die Kodierung in einer Umgebung, unterstützt async/await, können Sie auch einfach einen regulären for Schleife und dann await ein Versprechen in der Schleife und es wird dazu führen, die for Schleife zu unterbrechen, bis ein Versprechen behoben ist, bevor Sie fortfahren. Dies wird effektiv die Reihenfolge Ihrer asynchronen Operationen, so dass die nächste nicht erst beginnen, wenn die Vorherige erledigt ist.

async function processArray(array, fn) {
    let results = [];
    for (let i = 0; i < array.length; i++) {
        let r = await fn(array[i]);
        results.push(r);
    }
    return results;    //will be resolved value of promise
}

//sample usage
processArray(arr, processItem).then(function(result) {
    //all done here
    //array of data here in result
}, function(reason) {
    //rejection happened
});

---

FYI, ich glaube, meine processArray() - Funktion ist hier sehr ähnlich Versprechen.map() in der Bluebird Versprechen-Bibliothek, die nimmt ein array und ein Versprechen Produktionsfunktion und gibt ein Versprechen, dass löst sich mit einem array gelöst, Ergebnisse.

---

@vitaly-t - Hier einige detailliertere Kommentare auf Ihrem Ansatz. Sie sind herzlich eingeladen zu den gewünschten code scheint am besten zu Ihnen. Als ich begann, mit Versprechungen, die ich eher verwenden Sie verspricht, nur für die einfachsten Dinge, die Sie haben und schreiben viele der Logik selbst, wenn eine erweiterte Nutzung der verspricht noch viel mehr von ihm für mich. Sie verwenden nur das, was Sie sind völlig bequem mit und darüber hinaus, Sie würde lieber sehen, Ihre eigenen Codes, die Sie innig kennen. Das ist wohl die menschliche Natur.

Werde ich vorschlagen, dass ich, als ich Verstand mehr und mehr von dem, was verspricht für mich tun kann, die ich jetzt gerne schreiben Sie code, der verwendet, mehr über die erweiterten features von Verheißungen und scheint es ganz natürlich zu mir und ich fühle mich wie ich bin, aufbauend auf erprobten Infrastruktur, hat viele nützliche Funktionen. Ich würde Sie nur bitten, halten Sie Ihren Geist offen, wie Sie mehr und mehr potenziell gehen, die Richtung. Es ist meine Meinung, dass es eine nützliche und produktive Richtung zu migrieren, da sich Ihr Verständnis verbessert.

Hier sind einige spezifische Punkte des feedback auf Ihr Konzept:

Erstellen Sie verspricht an sieben stellen

Als Kontrast in Stilen, mein code hat nur zwei Orte, wo ich explizit erstellen Sie eine neue Versprechen - einmal in der factory-Funktion und einmal zum initialisieren der .reduce() Schleife. Überall sonst bin ich nur auf die Versprechen bereits erstellt durch die Verkettung von Ihnen oder zurückgeben von Werten, die in Ihnen oder einfach wieder direkt von Ihnen. Dein code hat sieben einzigartige Orte, an denen Sie erstellen ein Versprechen. Jetzt, gute Codierung ist nicht ein Wettbewerb, um zu sehen, wie wenige Orte, die Sie erstellen können, ein Versprechen, aber das könnte auf den Unterschied in den nutzen der Verheißungen, die bereits angelegt sind gegen das testen von Bedingungen und die Schaffung von neuen Versprechungen.

Werfen-Sicherheit ist ein sehr nützliches feature

Versprechen zu werfen-sicher ist. Das bedeutet, dass eine Ausnahme geworfen, die innerhalb ein Versprechen handler wird automatisch abzulehnen, die das Versprechen. Wenn Sie wollen einfach nur die Ausnahme zu einer Ablehnung, dann ist dies ein sehr nützliches feature zu nutzen. In der Tat, Sie werden feststellen, dass nur das werfen selbst ist eine nützliche Methode, um ablehnen, die aus einer handler erstellen ohne noch ein weiteres Versprechen.

Viele Promise.resolve() oder Promise.reject() ist wohl eine Möglichkeit für die Vereinfachung

Wenn Sie sehen, dass code, der mit viel Promise.resolve() oder Promise.reject() Aussagen, dann gibt es wahrscheinlich Möglichkeiten zu nutzen, die vorhandenen verspricht besser, anstatt all diese neuen Versprechungen.

Stimmen, um ein Versprechen

Wenn Sie nicht wissen, ob etwas zurückgegeben, ein Versprechen, dann können Sie werfen Sie es einem Versprechen. Das Versprechen-Bibliothek wird dann Mach es selbst prüft, ob es ein Versprechen ist oder nicht und auch ob es die Art von Versprechen, das entspricht dem Versprechen, die Bibliothek, die Sie verwenden, und wenn nicht, wickeln Sie es in einem. Dies kann sparen Sie umschreiben eine Menge von dieser Logik selbst.

Vertrag Zurück ein Versprechen

In vielen Fällen sind diese Tage, es ist ganz sinnvoll einen Vertrag für eine Funktion, die können Sie etwas tun, asynchrone zurückzukehren ein Versprechen. Wenn Sie die Funktion nur etwas tun will, synchron, dann kann es einfach nur wieder gelöst Versprechen. Sie scheinen zu fühlen, wie das ist belastend, aber es ist definitiv die Art und Weise der wind weht, und ich bereits eine Menge Quellcode schreiben muss und es fühlt sich sehr natürlich, wenn Sie machen Sie sich vertraut mit dem Versprechen. Es abstrahiert entfernt, ob die operation sync oder async und Aufrufer muss nicht wissen, oder etwas besonderes tun oder so. Dies ist eine schöne Nutzung verspricht.

Die factory-Funktion geschrieben werden können, erstellen Sie ein Versprechen nur

Die factory-Funktion geschrieben werden können, erstellen Sie ein Versprechen nur und dann beheben oder ablehnen. Dieser Stil macht es auch werfen sicher, so dass keine Ausnahme Auftritt in der factory-Funktion wird automatisch eine Ablehnung. Es macht auch den Vertrag immer wieder ein Versprechen automatisch.

Während ich erkenne, dass dieser factory-Funktion ist ein Platzhalter-Funktion (es muss nicht einmal etwas tun, async), hoffentlich können Sie sehen, der Stil, halten es:

function factory(idx) {
    //create the promise this way gives you automatic throw-safety
    return new Promise(function(resolve, reject) {
        switch (idx) {
            case 0:
                resolve("one");
                break;
            case 1:
                resolve("two");
                break;
            case 2:
                resolve("three");
                break;
            default:
                resolve(null);
                break;
        }
    });
}

Wenn alle diese Operationen waren, async, dann könnten Sie einfach nur wieder Ihre eigenen Verheißungen, die würde automatisch die Kette zu einem zentralen Versprechen wie dieses:

function factory(idx) {
    //create the promise this way gives you automatic throw-safety
    return new Promise(function(resolve, reject) {
        switch (idx) {
            case 0:
                resolve($.ajax(...));
            case 1:
                resole($.ajax(...));
            case 2:
                resolve("two");
                break;
            default:
                resolve(null);
                break;
        }
    });
}

Mit einem ablehnen handler nur return promise.reject(reason) ist nicht erforderlich

Wenn Sie diese Körper-code:

    return obj.then(function (data) {
        result.push(data);
        return loop(++idx, result);
    }, function (reason) {
        return promise.reject(reason);
    });

Ablehnen-handler ist nicht jede Zugabe Wert. Stattdessen können Sie genau dies tun:

    return obj.then(function (data) {
        result.push(data);
        return loop(++idx, result);
    });

Sind Sie bereits und gibt das Ergebnis zurück von obj.then(). Wenn entweder obj ablehnt oder wenn irgendetwas angekettet an obj oder zurückgegeben wird, dann .then() handler ablehnt, dann obj ablehnen wird. So müssen Sie nicht erstellen Sie ein neues Versprechen mit den ablehnen. Die einfacheren code ohne die reject-hf macht das gleiche mit weniger code.

---

Hier ist eine version in der Allgemeinen Architektur Ihrer code, der versucht zu integrieren, und die meisten dieser Ideen:

function factory(idx) {
    //create the promise this way gives you automatic throw-safety
    return new Promise(function(resolve, reject) {
        switch (idx) {
            case 0:
                resolve("zero");
                break;
            case 1:
                resolve("one");
                break;
            case 2:
                resolve("two");
                break;
            default:
                //stop further processing
                resolve(null);
                break;
        }
    });
}


//Sequentially resolves dynamic promises returned by a factory;
function sequence(factory) {
    function loop(idx, result) {
        return Promise.resolve(factory(idx)).then(function(val) {
            //if resolved value is not null, then store result and keep going
            if (val !== null) {
                result.push(val);
                //return promise from next call to loop() which will automatically chain
                return loop(++idx, result);
            } else {
                //if we got null, then we're done so return results
                return result;
            }
        });
    }
    return loop(0, []);
}

sequence(factory).then(function(results) {
    log("results: ", results);
}, function(reason) {
    log("rejected: ", reason);
});

Arbeiten demo: http://jsfiddle.net/jfriend00/h3zaw8u8/

Einige Kommentare zu dieser Umsetzung:

1. Promise.resolve(factory(idx)) im wesentlichen wirft das Ergebnis factory(idx) ein Versprechen. Wenn es nur einen Wert, dann wird es gelöst, das Versprechen, dass der Rückgabewert als die Entschlossenheit Wert. Wenn es schon ein Versprechen, dann ist es eben Ketten zu diesem Versprechen. Also, es ersetzt alle Ihre Typ-Prüfung-code auf der Rückgabewert der factory() Funktion.

2. Die factory-Funktion signalisiert, dass es gemacht wird-durch Rücksendung entweder null oder ein Versprechen, der ' s gelöst Wert endet als null. Die oben Besetzung ordnet diese beiden Bedingungen die gleiche resultierende code.

3. Die factory-Funktion Ausnahmen erfasst automatisch und verwandelt Sie in lehnt die werden dann automatisch abgewickelt, indem die sequence() Funktion. Dies ist ein wesentlicher Vorteil, dass verspricht eine Menge tun, Ihre Fehler-handling wenn Sie nur wollen, zu Abbrechen, Verarbeitung und füttern die Fehler zurück auf die erste Ausnahme oder Ablehnung.

4. Die factory-Funktion in dieser Implementierung kann wieder entweder ein Versprechen oder einen statischen Wert (für eine synchrone operation) und es wird funktionieren just fine (pro Ihr design-Anforderung).

5. Getestet hab ich es mit einer geworfenen Ausnahme an die Verheißung, die callback in der factory-Funktion und es ist ja nur abzulehnen und zu propagieren, dass die Ausnahme zur Ablehnung der Sequenz Versprechen, mit der Ausnahme als der Grund.

6. Dieser verwendet eine ähnliche Methode, wie Sie (auf den Zweck, zu versuchen, bleiben Sie mit Ihrer Allgemeinen Architektur) für die Verkettung mehrerer Anrufe zu loop().

InformationsquelleAutor jfriend00

Kann man nicht einfach X-asynchrone Operationen und dann will, dass Sie aufgelöst werden in eine Bestellung.

Den richtigen Weg, so etwas zu tun, ist die Ausführung des neuen async-Betrieb nur nach der einen, bevor Sie aufgelöst wurde:

doSomethingAsync().then(function(){
   doSomethingAsync2().then(function(){
       doSomethingAsync3();
       .......
   });
});

Bearbeiten
Scheint, wie Sie wollen, warten Sie, bis alle Versprechungen und rufen Sie dann die Rückrufe, die in einer bestimmten Reihenfolge. So etwas wie dieses:

var callbackArr = [];
var promiseArr = [];
promiseArr.push(doSomethingAsync());
callbackArr.push(doSomethingAsyncCallback);
promiseArr.push(doSomethingAsync1());
callbackArr.push(doSomethingAsync1Callback);
.........
promiseArr.push(doSomethingAsyncN());
callbackArr.push(doSomethingAsyncNCallback);

dann:

$.when(promiseArr).done(function(promise){
    while(callbackArr.length > 0)
    {
       callbackArr.pop()(promise);
    }
});

Die Probleme, die auftreten können, mit diesem ist, wenn eine oder mehrere Versprechungen scheitern.

InformationsquelleAutor Amir Popovich

Nehme ich zwei Ansätze zum Umgang mit dieser Frage:

1. Erstellen Sie mehrere zusagen und verwenden Sie die allWithAsync-Funktion wie folgt:

let allPromiseAsync = (...PromisesList) => {
return new Promise(async resolve => {
    let output = []
    for (let promise of PromisesList) {
        output.push(await promise.then(async resolvedData => await resolvedData))
        if (output.length === PromisesList.length) resolve(output)
    }
}) }
const prm1= Promise.resolve('first');
const prm2= new Promise((resolve, reject) => setTimeout(resolve, 2000, 'second'));
const prm3= Promise.resolve('third');

allPromiseAsync(prm1, prm2, prm3)
    .then(resolvedData => {
        console.log(resolvedData) //['first', 'second', 'third']
    });

1. Verwenden Sie die Versprechen.alle Funktion statt:

  (async () => {
  const promise1 = new Promise(resolve => {
    setTimeout(() => { resolve() }, 2500)
  })

  const promise2 = new Promise(resolve => {
    setTimeout(() => { resolve() }, 5000)
  })

  const promise3 = new Promise(resolve => {
    setTimeout(() => { resolve() }, 1000)
  })

  const promises = [promise1, promise2, promise3]

  await Promise.all(promises)

  console.log('This line is shown after 8500ms')
})()

InformationsquelleAutor Iman Bahrampour