ECMAScript 6 proporciona de forma nativa el objeto Promise.

El objeto Promise representa eventos que ocurrirán en el futuro y se utiliza para transmitir mensajes de operaciones asíncronas.

El objeto Promise tiene las siguientes dos características:

1. El estado del objeto no se ve afectado por el exterior. El objeto Promise representa una operación asíncrona y tiene tres estados:

  • pending: estado inicial, no es un estado de éxito ni de fracaso.
  • fulfilled: significa que la operación se completó con éxito.
  • rejected: significa que la operación falló.

Solo el resultado de la operación asíncrona puede determinar cuál es el estado actual; ninguna otra operación puede cambiar este estado. Este es también el origen del nombre Promise, cuyo significado en inglés es 'promesa', indicando que otros medios no pueden cambiarlo.

2. Una vez que el estado cambia, no volverá a cambiar, y este resultado se puede obtener en cualquier momento. El cambio de estado del objeto Promise solo tiene dos posibilidades: de Pending a Resolved y de Pending a Rejected. En cuanto ocurre cualquiera de estas dos situaciones, el estado se solidifica, no cambiará más y mantendrá este resultado. Incluso si el cambio ya ha ocurrido, si agregas una función de callback al objeto Promise, obtendrás este resultado de inmediato. Esto es completamente diferente de los eventos (Event); la característica de los eventos es que si te los pierdes y luego intentas escucharlos, no obtendrás el resultado.

Ventajas y desventajas de Promise

Con el objeto Promise, se pueden expresar las operaciones asíncronas con el flujo de operaciones síncronas, evitando funciones de callback anidadas capa tras capa. Además, el objeto Promise proporciona una interfaz unificada, lo que hace que controlar operaciones asíncronas sea más fácil.

Promise también tiene algunas desventajas. En primer lugar, no se puede cancelar; una vez creado, se ejecuta inmediatamente y no se puede cancelar a mitad de camino. En segundo lugar, si no se establece una función de callback, los errores lanzados dentro de Promise no se reflejarán al exterior. En tercer lugar, cuando está en estado Pending, no se puede saber en qué etapa se encuentra actualmente (si acaba de comenzar o está por completarse).

Creación de Promise

Para crear un objeto promise, se puede usar new para invocar el constructor de Promise y realizar la instanciación.

A continuación se muestran los pasos para crear un promise:

var promise = new Promise(function(resolve, reject) { //Procesamiento asíncrono //Después de que finalice el procesamiento, se llama a resolve o reject. });

El constructor de Promise contiene un parámetro y una función de callback con dos parámetros: resolve (resolver) y reject (rechazar). En la función de callback se ejecutan algunas operaciones (por ejemplo, asíncronas); si todo es normal, se llama a resolve; de lo contrario, se llama a reject.

Ejemplo

var myFirstPromise = new Promise(function(resolve, reject){ //Cuando el código asíncrono se ejecuta con éxito, llamamos a resolve(...); cuando el código asíncrono falla, llamamos a reject(...). //En este ejemplo, usamos setTimeout(...) para simular código asíncrono; en la codificación real podría ser una solicitud XHR o algunos métodos de API de HTML5. setTimeout(function(){ resolve("¡Éxito!"); //¡El código se ejecutó correctamente! }, 250); }); myFirstPromise.then(function(successMessage){ //El valor de successMessage es el valor pasado al llamar al método resolve(...) anteriormente. //El parámetro successMessage no tiene por qué ser de tipo cadena; esto es solo un ejemplo. document.write("Yay! " + successMessage); });

Pruébalo »

Para un objeto promise ya instanciado, se puede llamar al método promise.then(), pasando los métodos resolve y reject como funciones de callback.

promise.then() es el método más utilizado de promise.

promise.then(onFulfilled, onRejected)

promise simplifica el manejo de errores; el código anterior también se puede escribir así:

promise.then(onFulfilled).catch(onRejected)

Promise Ajax

A continuación se muestra un ejemplo de una operación Ajax implementada con el objeto Promise.

Ejemplo

function ajax(URL) { return new Promise(function (resolve, reject) { var req = new XMLHttpRequest(); req.open('GET', URL, true); req.onload = function () { if (req.status === 200) { resolve(req.responseText); } else { reject(new Error(req.statusText)); } }; req.onerror = function () { reject(new Error(req.statusText)); }; req.send(); }); } var URL = "/try/ajax/testpromise.php"; ajax(URL).then(function onFulfilled(value){ document.write('El contenido es:' + value); }).catch(function onRejected(error){ document.write('Error:' + error); });

Pruébalo »

En el código anterior, los métodos resolve y reject se llaman con parámetros. Sus parámetros se pasan a la función de callback. El parámetro del método reject suele ser una instancia del objeto Error, mientras que el parámetro del método resolve, además de un valor normal, también puede ser otra instancia de Promise, como se muestra a continuación.

var p1 = new Promise(function(resolve, reject){ // ... some code }); var p2 = new Promise(function(resolve, reject){ // ... some code resolve(p1); })

En el código anterior, tanto p1 como p2 son instancias de Promise, pero el método resolve de p2 toma p1 como parámetro; en este caso, el estado de p1 se transmitirá a p2. Si al momento de la llamada el estado de p1 es pending, la función de callback de p2 esperará a que el estado de p1 cambie; si el estado de p1 ya es fulfilled o rejected, la función de callback de p2 se ejecutará de inmediato.


Método Promise.prototype.then: operaciones en cadena

El método Promise.prototype.then devuelve un nuevo objeto Promise, por lo que se puede usar la escritura en cadena.

getJSON("/posts.json").then(function(json) { return json.post; }).then(function(post) { // proceed });

El código anterior usa el método then para especificar dos funciones de callback en secuencia. Después de que la primera función de callback se completa, su resultado de retorno se pasa como parámetro a la segunda función de callback.

Si la función de callback anterior devuelve un objeto Promise, la siguiente función de callback esperará a que ese objeto Promise tenga un resultado de ejecución antes de continuar llamándose.

getJSON("/post/1.json").then(function(post) { return getJSON(post.commentURL); }).then(function(comments) { //Procesar comments });

Este diseño hace que las operaciones asíncronas anidadas se puedan reescribir fácilmente, pasando del 'desarrollo horizontal' de las funciones de callback al 'desarrollo vertical'.


Método Promise.prototype.catch: captura de errores

El método Promise.prototype.catch es un alias de Promise.prototype.then(null, rejection) y se utiliza para especificar la función de callback cuando ocurre un error.

getJSON("/posts.json").then(function(posts) { // some code }).catch(function(error) { //Manejar errores que ocurren durante la ejecución de la función de callback anterior. console.log('¡Ocurrió un error!', error); });

Los errores del objeto Promise tienen una naturaleza de 'burbujeo'; se transmiten hacia delante hasta que son capturados. Es decir, el error siempre será capturado por la siguiente declaración catch.

getJSON("/post/1.json").then(function(post) { return getJSON(post.commentURL); }).then(function(comments) { // some code }).catch(function(error) { //Manejar los errores de las dos funciones de callback anteriores. });

Método Promise.all, método Promise.race

El método Promise.all se utiliza para envolver múltiples instancias de Promise en una nueva instancia de Promise.

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

En el código anterior, el método Promise.all acepta un array como parámetro; p1, p2 y p3 son instancias del objeto Promise. (El parámetro del método Promise.all no tiene que ser un array, pero debe tener una interfaz iterator, y cada miembro devuelto debe ser una instancia de Promise).

El estado de p está determinado por p1, p2 y p3, y se divide en dos casos.

  • (1) Solo cuando los estados de p1, p2 y p3 se vuelven fulfilled, el estado de p se vuelve fulfilled; en ese momento, los valores de retorno de p1, p2 y p3 forman un array que se pasa a la función de callback de p.
  • (2) En cuanto uno de p1, p2 o p3 sea rechazado, el estado de p se vuelve rejected; en ese momento, el valor de retorno de la primera instancia rechazada se pasa a la función de callback de p.

A continuación se muestra un ejemplo concreto.

//Generar un array de objetos Promise var promises = [2, 3, 5, 7, 11, 13].map(function(id){ return getJSON("/post/" + id + ".json"); }); Promise.all(promises).then(function(posts) { // ... }).catch(function(reason){ // ... });

El método Promise.race también envuelve múltiples instancias de Promise en una nueva instancia de Promise.

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

En el código anterior, en cuanto una de las instancias p1, p2 o p3 cambia de estado primero, el estado de p cambia en consecuencia. El valor de retorno de esa instancia de Promise que cambió primero se pasa al valor de retorno de p.

Si los parámetros de los métodos Promise.all y Promise.race no son instancias de Promise, primero se llamará al método Promise.resolve, que se explicará más adelante, para convertir los parámetros en instancias de Promise y luego procesarlos.


Método Promise.resolve, método Promise.reject

A veces es necesario convertir un objeto existente en un objeto Promise; el método Promise.resolve cumple esta función.

var jsPromise = Promise.resolve($.ajax('/whatever.json'));

El código anterior convierte el objeto deferred generado por jQuery en un nuevo objeto Promise de ES6.

Si el argumento del método Promise.resolve no es un objeto con un método then (también llamado objeto thenable), se devuelve un nuevo objeto Promise, y su estado es fulfilled.

var p = Promise.resolve('Hello'); p.then(function (s){ console.log(s) }); // Hello

El código anterior genera una nueva instancia p de un objeto Promise; su estado es fulfilled, por lo que la función de retorno se ejecuta inmediatamente. El argumento de Promise.resolve es el argumento de la función de retorno.

Si el argumento del método Promise.resolve es una instancia de un objeto Promise, se devuelve tal cual.

El método Promise.reject(reason) también devuelve una nueva instancia de Promise, cuyo estado es rejected. El argumento reason del método Promise.reject se pasa a la función de retorno de la instancia.

var p = Promise.reject('Se produjo un error.'); p.then(null, function (s){ console.log(s) }); //Se produjo un error.

El código anterior genera una instancia de objeto Promise, con estado rejected, y la función de retorno se ejecuta inmediatamente.

Enlaces de referencia:

  • https://wohugb.gitbooks.io/ecmascript-6/content/docs/promise.html
  • https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise
  • http://qingtong234.github.io/2016/01/14/javascript%E4%B8%AD%E7%9A%84promise%E5%BC%82%E6%AD%A5%E7%BC%96%E7%A8%8B-1/