El modo de programación de promesa también se llama entonces, que puede entenderse como ejecución después del retraso. Cada promesa tiene una interfaz única llamada entonces, y cuando la promesa falla o tiene éxito, será una devolución de llamada. Representa un resultado de la operación que puede funcionar durante mucho tiempo y no necesariamente tiene que completarse. Este patrón no bloquea y espera que las operaciones a largo plazo completen, pero devuelve un objeto que representa el resultado prometido.
Muchas bibliotecas actuales de JavaScript (como JQuery y Dojo, Angularjs) agregan esta abstracción llamada Promise. A través de estas bibliotecas, los desarrolladores pueden usar el modo de promesa en la programación real.
A continuación, usaremos jQuery como ejemplo para discutir cómo las bibliotecas de JavaScript usan el modo prometedor para manejar el procesamiento asíncrono, que en realidad es proporcionar soporte tolerante a fallas a través de devoluciones de llamada. Cuando una operación tiene éxito o falla o en cualquier caso, la devolución de llamada correspondiente se ejecuta e intente manejar cualquier situación posible en una cierta lógica.
Primero, echemos un vistazo a cómo funciona JQuery generalmente:
La copia del código es la siguiente:
var $ info = $ ("#info");
$ .AJAX ({
URL: "/ECHO/JSON/",
Datos: {json: json.stringify ({"nombre": "SomeValue"})},
Tipo: "Publicar",
éxito: función (respuesta)
{
$ info.text (respuesta.name);
}
});
En este ejemplo, puede ver que cuando la configuración es exitosa, se especificará una devolución de llamada, que es un buen método de devolución de llamada. Esta no es una promesa, y la documentación oficial de jQuery ya no recomienda este método (http://api.jquery.com/jquery.ajax/#jqxhr). Cuando se completa la llamada AJAX, ejecuta la función de éxito. Dependiendo de las operaciones asincrónicas utilizadas por la biblioteca, puede usar varias devoluciones de llamada diferentes (es decir, si la tarea es exitosa o no, se volverá a llamar y responder). Usando el modo Promise simplifica este proceso, las operaciones asíncronas solo requieren devolver una llamada de objeto. Esta promesa le permite llamar a un método llamado y luego le permite especificar el número de funciones de la devolución de llamada.
Echemos un vistazo a cómo JQuery desarrolla una promesa:
La copia del código es la siguiente:
var $ info = $ ("#info");
$ .AJAX ({
URL: "/ECHO/JSON/",
datos: {
json: json.stringify ({
"Nombre": "Somevalue"
})
},
Tipo: "Publicar"
})
.Then (función (respuesta) {
$ info.text (respuesta.name);
});
El objeto jQuery AJAX implementa el modo de promesa devolviendo el objeto XHR, para que podamos llamar al método entonces. La ventaja de hacer esto es que puede encadenar llamadas e implementar operaciones independientes, como se muestra a continuación:
La copia del código es la siguiente:
var $ info = $ ("#info");
$ .AJAX ({
URL: "/ECHO/JSON/",
datos: {
json: json.stringify ({
"Nombre": "Somevalue"
})
},
Tipo: "Publicar"
})
.Then (función (respuesta) {
$ info.text (respuesta.name);
})
.Then (function () {
$ info.append ("... más");
})
.done (function () {
$ info.append ("... finalmente!");
});
Las operaciones asincrónicas se vuelven muy fáciles ya que muchas bibliotecas comienzan a usar el modo de promesa. Pero si piensas desde la perspectiva opuesta, ¿cómo sería la promesa? Uno de los patrones muy importantes es que la función puede aceptar dos funciones, una es una devolución de llamada cuando tiene éxito y el otro es una devolución de llamada cuando falla.
La copia del código es la siguiente:
var $ info = $ ("#info");
$ .AJAX ({
// Cambiar URL para ver que ocurra un error
URL: "/ECHO/JSON/",
datos: {
json: json.stringify ({
"Nombre": "Somevalue"
})
},
Tipo: "Publicar"
})
.Then (función (respuesta) {
// éxito
$ info.text (respuesta.name);
},
función () {
// falla
$ info.text ("Las cosas malas les pasan a los buenos desarrolladores");
})
.always (function () {
$ info.append ("... finalmente");
});
Cabe señalar que en jQuery, ya sea exitoso o fallido, usaremos una llamada para especificar a lo que queremos llamar.
De hecho, también puede escribir esto aquí, que también es el método recomendado en el documento oficial de JQuery:
La copia del código es la siguiente:
var $ info = $ ("#info");
$ .AJAX ({
// Cambiar URL para ver que ocurra un error
URL: "/ECHO/JSON/",
datos: {
json: json.stringify ({
"Nombre": "Somevalue"
})
},
Tipo: "Publicar"
})
.done (función (respuesta) {
// éxito
$ info.text (respuesta.name);
}). fail (function () {
// falla
$ info.text ("Las cosas malas les pasan a los buenos desarrolladores");
})
.always (function () {
$ info.append ("... finalmente");
});
Echemos un vistazo a cómo AngularJS usa el modo de promesa:
La copia del código es la siguiente:
var m = angular.module ("myApp", []);
M.Factory ("DataService", function ($ Q) {
función _callMe () {
var d = $ q.defer ();
setTimeOut (function () {
d.resolve ();
//defer.reject ();
}, 100);
regreso d.promise;
}
devolver {
CallMe: _callme
};
});
function myctrl ($ alcance, servicio de datos) {
$ Scope.name = "Ninguno";
$ scope.isbusy = true;
DataService.callMe ()
.Then (function () {
// Exitoso
$ scope.name = "éxito";
},
función () {
// falla
$ scope.name = "falla";
})
.Then (function () {
// como una cláusula finalmente
$ scope.isbusy = false;
});
}
Puede probar estos ejemplos en JSFIDDLE y ver qué efectos se producirán. Usar Promise para operar asíncrono es una manera muy simple, y también puede simplificar su código. De hecho, es una buena forma de matar a dos pájaros de un solo piedra.
Para obtener más presentaciones y ejemplos sobre Promise, puede ir al sitio web oficial (http://www.promisejs.org/).