Der Programmiermodus für den Versprechen wird auch als damals genannt, was als Ausführung nach Verzögerung verstanden werden kann. Jedes Versprechen hat dann eine einzigartige Schnittstelle, die dann nennt, und wenn das Versprechen fehlschlägt oder erfolgreich ist, wird es einen Rückruf tätigen. Es stellt ein Betriebsergebnis dar, das möglicherweise lange ausgeführt wird und nicht unbedingt abgeschlossen werden muss. Dieses Muster blockiert und wartet nicht, bis langfristige Operationen abgeschlossen sind, sondern gibt ein Objekt zurück, das das versprochene Ergebnis darstellt.
Viele aktuelle JavaScript -Bibliotheken (wie JQuery und Dojo, AngularJS) fügen diese Abstraktion hinzu, die als Versprechen bezeichnet wird. Durch diese Bibliotheken können Entwickler den Versprechungsmodus in der tatsächlichen Programmierung verwenden.
Im Folgenden werden wir JQuery als Beispiel verwenden, um zu diskutieren, wie JavaScript-Bibliotheken den Versprechungsmodus verwenden, um die asynchrone Verarbeitung zu verarbeiten, weshalb dies tatsächlich zur Unterstützung von Fehlertoleranten durch Rückrufe liefert. Wenn eine Operation erfolgreich ist oder fehlschlägt oder in jedem Fall der entsprechende Rückruf ausgeführt wird und versuchen, mögliche Situationen in einem bestimmten Stück Logik zu behandeln.
Schauen wir uns zunächst an, wie JQuery im Allgemeinen funktioniert:
Die Codekopie lautet wie folgt:
var $ info = $ ("#info");
$ .ajax ({{{
URL: "/echo/json/",
Daten: {json: json.stringify ({"name": "sympalue"})},
Typ: "Post",
Erfolg: Funktion (Antwort)
{
$ info.text (Antwort.name);
}
});
In diesem Beispiel können Sie feststellen, dass beim Erfolg der Einstellung ein Rückruf angegeben wird, was eine gute Rückrufmethode ist. Dies ist kein Versprechen, und die offizielle JQuery -Dokumentation empfiehlt diese Methode nicht mehr (http://api.jquery.com/jquery.ajax/#jqxhr). Wenn der Ajax -Anruf abgeschlossen ist, wird die Erfolgsfunktion ausgeführt. Abhängig von den von der Bibliothek verwendeten asynchronen Operationen können Sie verschiedene Rückrufe verwenden (d. H. Ob die Aufgabe erfolgreich ist oder nicht, sie wird zurückgerufen und antworten). Durch die Verwendung von Versprechensmodus vereinfacht diese Prozesse. Asynchrone Operationen erfordern nur die Rückgabe eines Objektaufrufs. Mit diesem Versprechen können Sie eine dann aufgerufene Methode aufrufen und dann die Anzahl der Funktionen des Rückrufs angeben.
Schauen wir uns an, wie JQuery ein Versprechen aufbaut:
Die Codekopie lautet wie folgt:
var $ info = $ ("#info");
$ .ajax ({{{
URL: "/echo/json/",
Daten: {
JSON: JSON.Stringify ({{
"Name": "Ein bisschen value"
})
},
Typ: "Post"
})
.then (Funktion (Antwort) {
$ info.text (Antwort.name);
});
Das JQuery AJAX -Objekt implementiert den Versprechungsmodus, indem wir das XHR -Objekt zurückgeben, damit wir die dann die dann Methode aufrufen können. Der Vorteil, dies zu tun, besteht darin, dass Sie Anrufe ketten und unabhängige Vorgänge implementieren können, wie unten gezeigt:
Die Codekopie lautet wie folgt:
var $ info = $ ("#info");
$ .ajax ({{{
URL: "/echo/json/",
Daten: {
JSON: JSON.Stringify ({{
"Name": "Ein bisschen value"
})
},
Typ: "Post"
})
.then (Funktion (Antwort) {
$ info.text (Antwort.name);
})
.then (function () {
$ info.append ("... mehr");
})
.done (function () {
$ info.append ("... endlich!");
});
Asynchrone Operationen werden sehr einfach, da viele Bibliotheken den Versprechungsmodus verwenden. Aber wenn Sie aus der entgegengesetzten Perspektive denken, wie würde es versprechen, dass es aussehen würde? Eines der sehr wichtigen Muster ist, dass die Funktion zwei Funktionen akzeptieren kann, eines bei Erfolg ein Rückruf und das andere ein Rückruf bei Ausfall.
Die Codekopie lautet wie folgt:
var $ info = $ ("#info");
$ .ajax ({{{
// URL ändern, um einen Fehler zu erkennen
URL: "/echo/json/",
Daten: {
JSON: JSON.Stringify ({{
"Name": "Ein bisschen value"
})
},
Typ: "Post"
})
.then (Funktion (Antwort) {
// Erfolg
$ info.text (Antwort.name);
},
function () {
// Versagen
$ info.text ("Schlechte Dinge passieren guten Entwicklern");
})
.always (function () {
$ info.append ("... endlich");
});
Es ist zu beachten, dass wir in JQuery, ob erfolgreich oder gescheitert, einen Anruf verwenden, um anzugeben, was wir anrufen möchten.
Tatsächlich können Sie dies auch hier schreiben, was auch die empfohlene Methode im offiziellen Dokument von JQuery ist:
Die Codekopie lautet wie folgt:
var $ info = $ ("#info");
$ .ajax ({{{
// URL ändern, um einen Fehler zu erkennen
URL: "/echo/json/",
Daten: {
JSON: JSON.Stringify ({{
"Name": "Ein bisschen value"
})
},
Typ: "Post"
})
.Done (Funktion (Antwort) {
// Erfolg
$ info.text (Antwort.name);
}). fail (function () {
// Versagen
$ info.text ("Schlechte Dinge passieren guten Entwicklern");
})
.always (function () {
$ info.append ("... endlich");
});
Schauen wir uns an, wie AngularJS den Versprechungsmodus verwendet:
Die Codekopie lautet wie folgt:
var m = angular.module ("myapp", []);
m.factory ("DataService", Funktion ($ q) {
Funktion _callme () {
var d = $ q.defer ();
setTimeout (function () {
d.resolve ();
//defer.reject ();
}, 100);
Return D. promise;
}
zurückkehren {
Callme: _callme
};
});
Funktion myctrl ($ scope, DataService) {
$ scope.name = "keine";
$ scope.isbusy = true;
DataService.callme ()
.then (function () {
// Erfolgreich
$ scope.name = "Erfolg";
},
function () {
// Versagen
$ scope.name = "fehler";
})
.then (function () {
// wie eine endgültige Klausel
$ scope.isbusy = false;
});
}
Sie können diese Beispiele in JSFiddle ausprobieren und sehen, welche Effekte erzeugt werden. Die Verwendung von Versprechen, um asynchron zu bedienen, ist eine sehr einfache Art und Weise und kann auch Ihren Code vereinfachen. Es ist in der Tat ein guter Weg, zwei Vögel mit einem Stein zu töten.
Weitere Einführungen und Beispiele zum Versprechen finden Sie auf der offiziellen Website (http://www.promisejs.org/).