Die Interaktion von Webseiten wird immer komplexer und JavaScript wird auch immer asynchroner Operationen. Eine gemeinsame AJAX -Anforderung erfordert beispielsweise eine Antwort auf Operationen, wenn die Anfrage abgeschlossen ist. Die Anfrage ist normalerweise asynchron. Während des Anforderungsprozesses kann der Benutzer andere Vorgänge ausführen, ohne die Seite zu blockieren. Dieser asynchrone Interaktionseffekt ist für den Benutzer sehr freundlich. Für Entwickler ist es jedoch sehr unfreundlich, mit dieser Art von Betrieb in großen Mengen umzugehen. Die von asynchronen Anfragen abgeschlossenen Vorgänge müssen in der Rückruffunktion vordefiniert werden, und diese Funktion muss aufgerufen werden, nachdem die Anfrage abgeschlossen ist. Diese nichtlineare asynchrone Programmiermethode wird Entwickler unangenehm machen und bringt auch viele Unannehmlichkeiten mit sich, wodurch die Kopplung und Komplexität des Codes erhöht wird, und die Organisation des Codes wird sehr unelegant sein und die Wartbarkeit des Codes erheblich verringern. Die Situation ist komplizierter. Wenn eine Operation warten muss, bis mehrere asynchrone AJAX -Anfragen abgeschlossen sind, bevor er durchgeführt werden kann, wird die Rückruffunktion verschachtelt. Wenn mehrere Schichten verschachtelt werden müssen, können Sie nur nach Segen bitten.
Schauen wir uns die folgenden allgemeinen asynchronen Funktionen an.
Die Codekopie lautet wie folgt:
var showmsg = function () {
setTimeout (function () {
alarm ('Hallo');
}, 5000);
};
Dies geschieht normalerweise, wenn Sie der Funktion einen Rückruf hinzufügen möchten.
Die Codekopie lautet wie folgt:
var Showmsg = Funktion (Rückruf) {
setTimeout (function () {
alarm ('Hallo');
// hier Rückruf hinzufügen
callback ();
}, 5000);
};
Wenn Sie Easy.js -Versprechen verwenden, ist die Methode zum Hinzufügen von Rückrufen viel eleganter, solange Sie die ursprüngliche Funktion in eine Versprecheninstanz zusammenfassen müssen.
Die Codekopie lautet wie folgt:
var showmsg = function () {
// Versprecheninstanz konstruieren
var dadurch = new e.Promise ();
setTimeout (function () {
alarm ('Hallo');
// den Versprechenszustand ändern
Versprechen.Resolve ('fertig');
}, 5000);
// zur Versprecheninstanz zurückkehren
Rückversprechen;
};
Es gibt 3 wichtige Schritte, um eine gewöhnliche Funktion in eine Versprechungsinstanz zu verringern. Der erste Schritt besteht darin, eine Versprecheninstanz innerhalb der Funktion zu erstellen. Der zweite Schritt besteht darin, den Zustand des Versprechens zu ändern, nach der Ausführung der Bereitstellungsfunktion abgeschlossen zu werden. Der dritte Schritt besteht darin, diese Versprecheninstanz zurückzugeben. Jede Versprechen -Instanz hat 3 Staaten, nämlich anhängig (nicht abgeschlossen), gelöst (abgeschlossen, erfolgreich) und abgelehnt (abgelehnt, fehlgeschlagen). Schauen wir uns an, wie Sie Rückrufe hinzufügen können.
Die Codekopie lautet wie folgt:
Showmsg (). Dann (Funktion (str) {
// Der Rückruf wird hier hinzugefügt
Rückruf (str);
});
Dies trennt die Rückruffunktion vollständig von der ursprünglichen asynchronen Funktion, und aus der Sicht der Codeorganisation ist sie viel eleganter. Resolve akzeptiert einen Parameter, mit dem Daten mithilfe der damaligen Methode leicht auf den Rückruf übertragen werden können.
Für AJAX -Anforderungen fasst Easy.js die AJAX -Methode direkt in ein Versprechensobjekt zusammen, und Sie können die dann zurückgerufene Methode direkt hinzufügen.
Die Codekopie lautet wie folgt:
E.ajax ({{{
URL: 'test1.php',
Typ: 'Get'
})
.then (function () {
// Fügen Sie einen Rückruf mit erfolgreicher Anfrage hinzu
}, function () {
// Fügen Sie einen Rückruf hinzu, der die Anfrage fehlgeschlagen hat
});
Die damalige Methode akzeptiert 2 Funktionen als Parameter. Die erste Funktion ist ein abgeschlossener Rückruf, und die zweite ist ein fehlgeschlagener Rückruf.
Was ist, wenn oben mehrere AJAX -Anfragen erwähnt werden? Dann müssen Sie die WO -Methode verwenden. Diese Methode kann mehrere Promise -Instanzen als Parameter akzeptieren.
Die Codekopie lautet wie folgt:
var requests = e.when (e.ajax ({{{
URL: 'test1.php',
Typ: 'Get'
}), E.ajax ({{{
URL: 'test2.php',
Typ: 'Get'
}));
requests.then (function (arg1, arg2) {
console.log ('Erfolg:' + arg1 [0] + arg2 [0]);
}, function (arg1, arg2) {
console.log ('fehler:' + arg1 + arg2);
});
Die WO -Methode besteht darin, mehrere Versprechensinstanzen in ein Array zu speichern und zu warten, bis alle Versprechensinstanzen des Arrays abgeschlossen sind, bevor der ausgefüllte Rückruf ausgeführt wird. Sobald eine Instanz abgelehnt ist, wird der abgelehnte Rückruf sofort ausgeführt.
Das Versprechenmuster ist eines der Spezifikationen von CommonJs. Viele Mainstream -JavaScript -Bibliotheken haben entsprechende Implementierungen wie JQuery und Dojo, die diese Funktionen implementieren. Hier möchte ich mich immer noch über JQuerys verschobene beschweren. Abgesehen von seiner internen Verwendung sollte dies das Modul mit der niedrigsten Benutzernutzungsrate sein, die eine bestimmte Beziehung zu seiner komplexeren Nutzungsmethode hat.