Wie Sie sich synchron, lösen eine Kette von es6 verspricht?

Habe ich eine Funktion aus einer Bibliothek, die eine Zusage zurückgibt. Ich muss zur Ausführung dieser Funktion mehrere Male, aber jeder iteration muss warten, bis der Vorherige Vorgang abgeschlossen ist.

Meine Vermutung war, dass ich dies tun könnte:

promiseReturner(1)
  .then(promiseReturner(2)
  .then(promiseReturner(3)
  .then(...)

Könnte vereinfacht mit einer Schleife:

var p = Promise.resolve();
for (var i=1; i<=10; i++) {
  p = p.then(promiseReturner(i));
}

Jedoch, wenn ich dies tun jedes Versprechen in der Kette ausgeführt wird, zur gleichen Zeit, anstatt eine nach der anderen als .then() scheint zu implizieren. Klar fehlt mir etwas grundlegendes über das, was Sie Versprechen-aber nach der Lektüre einige tutorials und blog-posts ich bin immer noch verloren.

Hier ist ein codepen ich schrieb, um zu demonstrieren, dass mein Versuch.

Tut promiseReturner(n) Gegenzug ein Versprechen oder eine Verheißung-Rückkehr-Funktion?

InformationsquelleAutor Ben Davis | 2015-02-23

javascript promise

23

Ihre "nicht-loop" - Lösung sollte nicht funktionieren. Sie haben, um einen Funktion zu .then, nicht ein Versprechen:
```
var p = Promise.resolve();
for (var i=1; i<=10; i++) {
  (function(i) {
      p = p.then(function() {
          return promiseReturner(i);
      });
  }(i));
}
```
Wenn, die Funktion gibt ein Versprechen, dann bekommen Sie, dass die Verkettung Wirkung.

Mehr Infos über verspricht auf MDN.

Kann vereinfacht werden, mit let (und die Pfeil-Funktionen):
```
var p = Promise.resolve();
for (let i=1; i<=10; i++) {
    p = p.then(() => promiseReturner(i));
}
```
Oder .bind (das ist ES5):
```
var p = Promise.resolve();
for (var i=1; i<=10; i++) {
    p = p.then(promiseReturner.bind(null, i));
}
```
- Vielleicht verständlicher: "Sie müssen übergeben Sie eine Funktion die Rückkehr ein Versprechen"?
- nie Verstand Sie erklären, dass später auf
- Ich hatte versucht, wickeln Sie es in eine Funktion aus früheren siehe hier, aber es schien nur die Letzte laufen Versprechen. Warum wickeln, dass der block, den er in einem sich selbst aufrufenden Funktion scheinen, um es zu beheben?
- href="http://stackoverflow.com/q/750486/218196">JavaScript-Verschluss in Schleifen – einfache praktische Beispiel. tl;dr: JavaScript hat nur die Funktion, Umfang, nicht blockieren Umfang, so ist jede Funktion verweist auf das gleiche i. Dieser ist fest mit let btw.
- Ah, danke! Ich denke, dass ich auch verwirrt mich, wie ich dachte, dass meine promiseReturner Funktion ist selbst eine Funktion, aber wusste nicht, ich war vorbei, das Ergebnis dieser Funktion (und nicht die Funktion selbst). Sie würden denken, dass jemand die Codierung für die 15 Jahre fangen würde, dass. Gehen Abbildung.
- Wenn promiseReturner würde nicht brauchen einen parameter, die Sie tun könnten p = p.then(promiseReturner); (beachten Sie, dass ich nicht den Aufruf der Funktion). Aber tatsächlich, es ist eine alternative zu den IIFE (sofort aufgerufen function expression), die .bind: p = p.then(promiseReturner.bind(null, i));.
- Ich hatte keine Ahnung, Sie könnte tun Teiltöne wie das in js. Genial.
InformationsquelleAutor Felix Kling

Wenn Sie mit es6, können Sie erreichen dies mit array.reduce. Ich denke ganz ordentlich.

const functions = [/* array of functions which return promises */];
const finalPromise = functions.reduce(async (promise, asyncFn) => {
  await promise;
  return asyncFn();
}, Promise.resolve());

InformationsquelleAutor Alastair Brayne

Können Sie async/await mit es6-Generatoren und eine Bibliothek, wie co.

co(function* () {
  while(upto < 10) {
    var result = yield Promise.resolve(true);
  }
  return result;
}).then(function (value) {
  console.log(value);
}, function (err) {
  console.error(err.stack);
});

Hier einige detail, wie dies funktioniert: http://davidwalsh.name/async-generators

InformationsquelleAutor eguneys

Hier ist eine Lösung, die ich verwendet, um dasselbe problem zu lösen:

var recursiveFunction = function(values) {
  return new Promise(function(resolve, reject) {
    if (values.length <= 0) {
        return resolve();
    } else {
        return promiseReturner(values[0]).then(function() {
            values.shift();
            return recursiveFunction(values).then(function() {
              resolve();
            });
        });
      }
  });
}

recursiveFunction([1,2]).then(function(r) {
 console.warn('Finished solving promises sequentially');
})

InformationsquelleAutor Bilal Soomro

-1

Können Sie ausführen von code über nsynjs, pausiert die Ausführung jeder Funktion, die Renditen Versprechen, und warten Sie, bis das Versprechen aufgelöst wird:

JS:

var promiseReturner = function(i) {
    return new Promise(function(resolve, reject) {
        setTimeout(function(){
            resolve("result is "+i)
        }, 1000);
    });
};

function synchronousCode() {
    for (var i=1; i<=10; i++) {
        var p=promiseReturner(i); //nsynjs will pause here until promise is resolved
        console.log(p.data); //`data` will contain result of the promise
    }
};
	
nsynjs.run(synchronousCode, null, function(){
	console.log("finish");
});

HTML:

<script src="https://rawgit.com/amaksr/nsynjs/master/nsynjs.js"></script>

Nach dem Lesen der npm-readme-Seite, es klingt wie diese Bibliothek ist im wesentlichen eine allzu komplizierte benutzerdefinierte Implementierung des es6 "warten" - Befehl. Bitte korrigieren Sie mich, wenn ich falsch bin, aber ich bin wirklich nicht davon überzeugt, dass das schreiben einer benutzerdefinierten Auswertung-engine in javascript javascript ist eine gute Idee.

InformationsquelleAutor amaksr

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.