Antes de comenzar la introducción formal, queremos ver cómo se ve JavaScript Promise:
La copia del código es la siguiente:
var p = nueva promesa (function (resolve, rechazar) {
resolve ("hola mundo");
});
p.then (función (str) {
alerta (str);
});
1. Entonces () devuelve una promesa bifurcada
¿Cuál es la diferencia entre los siguientes dos códigos?
La copia del código es la siguiente:
// exhibir un
var p = nueva promesa (/*...*/);
P.THEN (FUNC1);
P.THEN (FUNC2);
// Anexo B
var p = nueva promesa (/*...*/);
P.THEN (FUNC1)
.Then (func2);
Si considera cuidadosamente las dos piezas de código anteriores equivalentes, las promesas son solo una variedad unidimensional de funciones de devolución de llamada. Sin embargo, este no es el caso. Cada entonces () Llame devuelve una promesa bifurcada. Por lo tanto, en exhibita, si func1 () lanza una excepción, func2 () todavía se llama normalmente.
En exhibitb, si Func1 () arroja un error, no se llamará a Fun2 () porque la primera llamada devuelve una nueva promesa, que será rechazada en func1 (). El resultado se está omitiendo func2 ().
Resumen: las promesas pueden ser la bifurcación en múltiples rutas, similares a los complejos diagramas de flujo.
2. La devolución de llamada debe pasar el resultado
¿Qué recibirá una advertencia cuando ejecute el siguiente código?
La copia del código es la siguiente:
var p = nueva promesa (function (resolve, rechazar) {
resolve ("hola mundo");
});
p.then (function (str) {})
.Then (function (str) {
alerta (str);
});
La alerta en el segundo entonces () no muestra nada. Esto se debe a que la función de devolución de llamada, en el contexto de la promesa, no hay función de devolución de llamada porque el resultado cambia. Promise espera que su devolución de llamada devuelva el mismo resultado o un resultado de reemplazo, que luego se pasa a la próxima devolución de llamada.
Similar al uso de ADPATER para cambiar los resultados, como sigue:
La copia del código es la siguiente:
var feettometRes = function (ft) {return ft*12*0.0254};
var p = nueva promesa (/*...*/);
P.THEN (Feettometres)
.Then (función (metros) {
alerta (medidores);
});
3. Solo se pueden atrapar excepciones de la capa anterior
¿Cuál es la diferencia entre estas dos piezas de código?
La copia del código es la siguiente:
// exhibir un
nueva promesa (function (resolve, rechazar) {
resolve ("hola mundo");
})
.entonces(
función (str) {
arrojar un nuevo error ("Uh OH");
},
indefinido
)
.entonces(
indefinido,
función (error) {
alerta (error);
}
);
// Anexo B
nueva promesa (function (resolve, rechazar) {
resolve ("hola mundo");
})
.entonces(
función (str) {
arrojar un nuevo error ("Uh OH");
},
función (error) {
alerta (error);
}
);
En la primera pieza de código, la excepción en el primero entonces () se lanza y será atrapada por el segundo que (), y la advertencia "UH OH" se activará. Esta guía solo se atraparán las excepciones en el nivel anterior.
En la segunda pieza de código, la función de devolución de llamada y la función de devolución de llamada de error están en el mismo nivel, lo que significa que cuando se lanza una excepción en la devolución de llamada, no se atrapará. De hecho, la devolución de llamada de error del segundo código solo se arrojará si la promesa es rechazada o si la promesa en sí misma está mal.
4. Los errores se pueden restaurar
En una función de devolución de llamada de error, si no vuelve a retirar el error, Promise supone que ha recuperado del error e invertido a un estado resuelto. En el siguiente ejemplo, "I'm Saveed" se mostrará porque la devolución de llamada de error en el primero y luego () no rehizo la excepción.
La copia del código es la siguiente:
var p = nueva promesa (function (resolve, rechazar) {
rechazar (nuevo error ("Pebkac"));
});
P.THEN (
indefinido,
función (error) {}
)
.entonces(
función (str) {
alerta ("¡Estoy salvado!");
},
función (error) {
alerta ("¡mala computadora!");
}
);
La promesa puede verse como una capa en una cebolla. Cada entonces () agrega otro nivel a la cebolla. Cada nivel representa una actividad procesada. Cuando se termina la jerarquía, se considera que el resultado ha sido arreglado y listo para la próxima jerarquía.
5. Las promesas se pueden suspender
Debido a que está listo para ejecutar en un método que (), no significa que no pueda hacer una pausa y ejecutar otros por adelantado. Para detener la promesa actual, o dejar que espere otra promesa que complete, simplemente devuelva otra promesa en entonces ().
La copia del código es la siguiente:
var p = nueva promesa (/*...*/);
p.then (función (str) {
if (! loggedin) {
devolver nueva promesa (/*...*/);
}
})
.Then (function (str) {
alerta ("hecho");
})
En el código anterior, el aviso no aparecerá hasta que se analice la nueva promesa. Esta es una forma conveniente de introducir más dependencias en la ruta del código asíncrono existente. Por ejemplo, puede encontrar que la sesión del usuario tiene tiempo de espera y es posible que desee inicializar el segundo inicio de sesión antes de continuar con la ruta de código anterior.
6. Las promesas resueltas no se ejecutarán de inmediato
¿Obtendrá un cuadro de solicitud al ejecutar el siguiente código?
La copia del código es la siguiente:
función runMe () {
var i = 0;
nueva promesa (function (resolve) {
resolver();
})
.Then (function () {
i += 2;
});
alerta (i);
}
Debido a que la promesa se analiza de inmediato y luego () se ejecuta el método de inmediato, puede pensar que se sondeará la solicitud 2. Sin embargo, la definición de la promesa requiere que todas las llamadas sean forzadas asíncronas. Por lo tanto, el aviso se generará antes de que se modifique.