Das Artefakt in Javascript – Versprechen

Versprechen in js

Das eigentliche Problem mit der Callback-Funktion besteht darin, dass sie uns die Fähigkeit nimmt, die Schlüsselwörter return und throw zu verwenden. Und Promise löst das alles sehr gut.

Im Juni 2015 wurde endlich die offizielle Version von ECMAScript 6 veröffentlicht.

ECMAScript ist der internationale Standard für die JavaScript-Sprache und JavaScript ist die Implementierung von ECMAScript. Das Ziel von ES6 besteht darin, die Verwendung der JavaScript-Sprache zum Schreiben großer und komplexer Anwendungen zu ermöglichen und eine Entwicklungssprache auf Unternehmensebene zu werden.

Konzept

ES6 stellt nativ Promise-Objekte bereit.

Das sogenannte Promise ist ein Objekt, das zur Übermittlung von Nachrichten für asynchrone Vorgänge verwendet wird. Es stellt ein Ereignis dar (normalerweise eine asynchrone Operation), dessen Ergebnis erst in der Zukunft bekannt ist, und dieses Ereignis stellt eine einheitliche API für die weitere Verarbeitung bereit.

Promise-Objekte haben die folgenden zwei Eigenschaften.

(1) Der Zustand des Objekts wird von der Außenwelt nicht beeinflusst. Das Promise-Objekt stellt einen asynchronen Vorgang dar und hat drei Zustände: Ausstehend (in Bearbeitung), Gelöst (abgeschlossen, auch als „Erfüllt“ bezeichnet) und Abgelehnt (fehlgeschlagen). Nur das Ergebnis der asynchronen Operation kann den aktuellen Status bestimmen, und keine andere Operation kann diesen Status ändern. Daher stammt auch der Name Promise, der auf Englisch „Verpflichtung“ bedeutet und bedeutet, dass er nicht auf andere Weise geändert werden kann.

(2) Sobald sich der Status ändert, ändert er sich nicht mehr und dieses Ergebnis kann jederzeit abgerufen werden. Es gibt nur zwei Möglichkeiten, den Status eines Promise-Objekts zu ändern: von „Ausstehend“ zu „Gelöst“ und von „Ausstehend“ zu „Abgelehnt“. Solange diese beiden Situationen auftreten, wird der Zustand gefestigt und wird sich nicht mehr ändern und dieses Ergebnis immer beibehalten. Selbst wenn die Änderung bereits erfolgt ist, erhalten Sie das Ergebnis sofort, wenn Sie dem Promise-Objekt eine Rückruffunktion hinzufügen. Das ist etwas völlig anderes als ein Ereignis. Das Besondere an einem Ereignis ist, dass man das Ergebnis nicht erhält, wenn man es verpasst und noch einmal zuhört.

Mit dem Promise-Objekt können asynchrone Vorgänge als synchroner Vorgangsprozess ausgedrückt werden, wodurch Schichten verschachtelter Rückruffunktionen vermieden werden. Darüber hinaus bieten Promise-Objekte eine einheitliche Schnittstelle, die die Steuerung asynchroner Vorgänge erleichtert.

Versprechen hat auch einige Nachteile. Erstens kann Promise nicht storniert werden. Sobald es erstellt wurde, wird es sofort ausgeführt und kann nicht auf halbem Weg storniert werden. Zweitens werden von Promise intern ausgelöste Fehler nicht extern reflektiert, wenn die Rückruffunktion nicht festgelegt ist. Drittens ist es im Status „Ausstehend“ unmöglich zu wissen, in welcher Phase sich der aktuelle Fortschritt befindet (gerade begonnen oder kurz vor dem Abschluss).

var promise = new Promise(function(resolve, reject) { if (/* 异步操作成功 */){
 resolve(value);
 } else {
 reject(error);
 }
});

promise.then(function(value) { // success
}, function(value) { // failure
});

Der Promise-Konstruktor akzeptiert eine Funktion als Parameter. Die beiden Parameter der Funktion sind die Auflösungsmethode und die Ablehnungsmethode.

Wenn der asynchrone Vorgang erfolgreich ist, verwenden Sie die Auflösungsmethode, um den Status des Promise-Objekts von „unvollständig“ in „erfolgreich“ zu ändern (d. h. von „ausstehend“ in „gelöst“) Wenn der asynchrone Vorgang fehlschlägt, verwenden Sie dann die Ablehnungsmethode, um den Status des Promise-Objekts von „unvollständig“ in „fehlgeschlagen“ zu ändern (d. h. von „ausstehend“ in „abgelehnt“).

Basis-API

Promise.resolve()
Promise.reject()
Promise.prototype.then()
Promise.prototype.catch()
Promise.all() // Alle abgeschlossen

5.  var p = Promise.all([p1,p2,p3]);

Promise.race() // Rennen, schließe einfach eins ab
Fortgeschritten

Das Wunder von Versprechen ist, dass angesichts unseres vorherigen Returns und Throws jedes Promise eine then()-Funktion und eine Catch()-Funktion bereitstellt, die eigentlich eine then(null, ...)-Funktion ist.

Wir können Machen Sie drei Dinge:

    somePromise().then(functoin(){        // do something
    });

1. Kapseln Sie synchronen und asynchronen Code

1. return 另一个 promise2. return 一个同步的值 (或者 undefined)3. throw 一个同步异常 ` throw new Eror('');`

2. Erfassen Sie synchrone Ausnahmen

"
new Promise(function (resolve, reject) {
 resolve(someValue);
 });
"
写成

"
Promise.resolve(someValue);
"

Wenn es sich um synchronen Code handelt kann geschrieben werden als

 new Promise(function (resolve, reject) { throw new Error('悲剧了，又出 bug 了');
 }).catch(function(err){ console.log(err);
 });

3. Mehrere Ausnahmen erfassen, genauere Erfassung

    Promise.reject(new Error("什么鬼"));

4 Holen Sie sich den Rückgabewert von zwei Versprechen

somePromise.then(function() { return a.b.c.d();
}).catch(TypeError, function(e) { 
//If a is defined, will end up here because //it is a type error to reference property of undefined
}).catch(ReferenceError, function(e) { //Will end up here if a wasn't defined at all
}).catch(function(e) { //Generic catch-the rest, error wasn't TypeError nor //ReferenceError
});

5 . schließlich

1. .then 方式顺序调用2. 设定更高层的作用域3. spread

6. binden

任何情况下都会执行的，一般写在 catch 之后

Oder Sie können dies tun

somethingAsync().bind({})
.spread(function (aValue, bValue) { this.aValue = aValue; this.bValue = bValue; return somethingElseAsync(aValue, bValue);
})
.then(function (cValue) {     return this.aValue + this.bValue + cValue;
});

Es gibt jedoch viele Unterschiede,

var scope = {};
somethingAsync()
.spread(function (aValue, bValue) { scope.aValue = aValue; scope.bValue = bValue;
 return somethingElseAsync(aValue, bValue);
})
.then(function (cValue) {
 return scope.aValue + scope.bValue + cValue;
});

Sie müssen zunächst erklären, dass die Gefahr von Ressourcenverschwendung und Speicherlecks besteht
kann nicht im Kontext eines Ausdrucks verwendet werden
Weniger effizient
alle. Sehr nützlich für die Verarbeitung einer Promise-Liste mit dynamischer Größe

8. Ideal für die Handhabung mehrerer losgelöster Promise

9. Behandeln Sie eine Kartensammlung von Versprechen. Nur eine schlägt fehl und alle Ausführungen enden

"var join = Promise.join;join(getPictures(), getComments(), getTweets(),
 function(pictures, comments, tweets) {
 console.log("in total: " + pictures.length + comments.length + tweets.length);
});
"

10 stack);

"
Promise.props({ pictures: getPictures(),
 comments: getComments(),
 tweets: getTweets()
}).then(function(result) {
 console.log(result.tweets, result.pictures, result.comments);
});
"

});

});;

"Promise.some([
 ping("ns1.example.com"),
 ping("ns2.example.com"),
 ping("ns3.example.com"),
 ping("ns4.example.com")
], 2).spread(function(first, second) { console.log(first, second);
}).catch(AggregateError, function(err) {

11.map(Funktionsmapper [, Objektoptionen])


Option: Parallelität und gefunden

"
有可能，失败的 promise 比较多，导致，Promsie 永远不会 fulfilled

Das Folgende ist eine unbegrenzte Anzahl von Parallelitäts- und Lesedateiinformationen

用于处理一个数组，或者 promise 数组，

Ergebnis

    map(..., {concurrency: 1});

11.reduce(Funktionsreduzierer [ , dynamischer Anfangswert]) -> Promise

var Promise = require("bluebird");
var join = Promise.join;
var fs = Promise.promisifyAll(require("fs"));
var concurrency = parseFloat(process.argv[2] || "Infinity");
var fileNames = ["file1.json", "file2.json"];
Promise.map(fileNames, function(fileName) { 
return fs.readFileAsync(fileName)
 .then(JSON.parse)
 .catch(SyntaxError, function(e) {
 e.fileName = fileName; throw e;
 })
}, {concurrency: concurrency}).then(function(parsedJSONs) { console.log(parsedJSONs);
}).catch(SyntaxError, function(e) { console.log("Invalid JSON in file " + e.fileName + ": " + e.message);
});

.delay(int ms) -> Promise

$ sync && echo 3 > /proc/sys/vm/drop_caches
$ node test.js 1reading files 35ms
$ sync && echo 3 > /proc/sys/vm/drop_caches
$ node test.js Infinity
reading files: 9ms

.timeout(int ms [, String message]) -> Promise

Promise.reduce(["file1.txt", "file2.txt", "file3.txt"], 
function(total, fileName) { 
return fs.readFileAsync(fileName, "utf8").then(
function(contents) { 
return total + parseInt(contents, 10);
 });
}, 0).then(function(total) { //Total is 30
});

Promise-Implementierung

1. q

2. Bluebird

co

1. wann

ASYNC

Die Async-Funktion ist wie die Promise- und Generator-Funktionen eine Methode, die zum Ersetzen von Callback-Funktionen und zum Lösen asynchroner Vorgänge verwendet wird. Es handelt sich im Wesentlichen um syntaktischen Zucker für die Generatorfunktion. Asynchrone Funktionen sind nicht Teil von ES6, aber in ES7 enthalten.

Das Obige ist der Inhalt von Promise, dem Artefakt in Javascript. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).