[MUSIC]
Cuando estábamos hablando de servicios en el módulo anterior, había mencionado
sobre promesas y luego prometí que volvería a las promesas en este módulo.
Así que, aquí estamos voy a cumplir mi promesa que te hice.
Un cálculo sincrónico está por todas partes en la World Wide Web.
Y cómo funciona la web.
Si vienes del mundo de la programación secuencial,
envolver tu cabeza alrededor de un cálculo sincrónico requiere un poco de esfuerzo.
Ha habido muchos intentos de hacer que el cálculo asíncrono sea tan indoloro como
posible para las personas que están en transición a él desde el libro de cálculo secuencial.
Uno de esos intentos son hacer que la computación asíncrona
sea más fácil de lograr son las promesas.
Como nos damos cuenta, cuando hacemos cualquier solicitud a cualquier servicio
o a un servidor back-end,
va a tomar algún tiempo para que los resultados estén disponibles para nosotros.
Si hacemos tal solicitud mientras estamos procediendo con nuestro trabajo,
entonces hay una alta probabilidad de que nuestro cálculo se quede atascado en el punto,
esperando los resultados.
Esto es un no-no en términos de hacer una buena experiencia de usuario.
Así que es importante que cada vez que sus resultados vayan a tomar tiempo
usted pueda seguir adelante sin esperar las reglas.
Y ahí es donde la computación asincrónica viene a su ventaja.
En el cálculo asíncrono cuando envía una solicitud
está esperando que los resultados vuelvan en un momento posterior, y
debería ser capaz de lidiar con el hecho, los resultados base vuelven en un momento
mucho más tarde que donde estaba en el momento en que hizo la solicitud.
Las promesas nos proporcionan una manera de lidiar con esto.
Echemos un vistazo a las promesas con un poco más de detalle en esta conferencia.
Y luego también veremos el uso de promesas
en nuestra aplicación Angular un poco más tarde.
Promesas, el concepto general es un área muy vasta por sí mismo.
Y en este curso, no tengo tiempo para revisar los detalles de las promesas.
Eso se convertirá en un curso completo en sí mismo.
Te daré sólo lo esencial de las promesas que son necesarias para que
nosotros entienda cómo hacer uso de las promesas dentro de nuestra aplicación angular.
Te proporciono muchas pistas a recursos
adicionales donde puedes ir y examinar las promesas con más detalle.
Así que volviendo a esa pregunta, ¿qué es exactamente una promesa?
Una promesa es un mecanismo que admite la computación asíncrona.
Acabo de dar una explicación larga de por qué la computación asíncrona
es esencial para que la web funcione.
Ahora, al usar una promesa, la promesa proporciona un mecanismo o
un proxy para un valor que no está disponible en el momento en que usted lo pide.
Así que una promesa te devolverá una promesa, diciendo que
cuando el resultado esté disponible, volverá y te entregará los resultados.
Entonces, una promesa le devuelve un objeto proxy y se aferra al objeto proxy.
Y ese objeto proxy le dará acceso a los resultados cuando estén disponibles.
Y hay un método en cómo esperas los resultados.
En realidad no suspende su cálculo en ese momento, en su lugar
configura una forma de aceptar los resultados cuando vuelva de esa promesa.
Para decirlo en pocas palabras,
promise representa un valor que estará disponible en un futuro.
También puede estar disponible inmediatamente,
en cuyo caso la promesa devolverá el valor inmediatamente.
Pero en caso de que necesite devolver un valor en una fecha futura, entonces le da
la promesa de que ese valor cuando esté disponible será devuelto a usted.
Siempre existe la posibilidad de que la promesa no se pueda cumplir,
porque los resultados no están disponibles por cualquier razón.
En ese caso, se te entregará un error, o se te entregará un rechazo
, y depende de ti lidiar con el hecho de que la promesa fue rechazada.
Nos fijamos en cómo nos ocupamos de eso en la siguiente diapositiva.
Como aprendimos antes, una promesa es un proxy para
algo que iba a suceder en el futuro o que nunca ocurriría en el futuro.
Así que una promesa cuando se te dé, estará en el estado pendiente.
Ahora, cuando la promesa se resuelva, eso es que los resultados estén disponibles y
la promesa es capaz de entregar los resultados a usted, entonces la promesa se resolverá o
cumplirá.
Y en ese caso la promesa pasará del estado pendiente al estado de resolución o
al estado de cumplimiento.
Así que en ese momento sus resultados están disponibles para usted.
Hay una ligera posibilidad de que la promesa pueda ser rechazada debido a un error,
o cualquiera que sea la razón.
En esa circunstancia remota,
se le entregará un rechazo y en ese caso, la promesa será
considerada como rechazada cuando se entregue el rechazo.
Entonces, cuando generas una promesa, como dije,
una promesa es un objeto proxy que se te entrega.
Entonces, cuando usted entrega una promesa a alguien, la promesa internamente tendrá
una función que tratará tanto con la resolución como
las opciones de rechazo dentro de allí.
Al escribir código,
verá que va a escribir código como nueva promesa (función (resolver, rechazar).
Así que ya sea que se resuelva o sea rechazado, necesitamos poder enviar
de vuelta la información a quien le hayamos entregado la promesa.
¿Cómo hacemos esto en código?
Echemos un vistazo a eso en la siguiente diapositiva.
Aquí hay un ejemplo de cómo se configura promesa en el código.
De hecho, este ejemplo se deriva del ejercicio que harás
un poco más tarde.
Así que aquí, cuando configuramos nuestro servicio, podemos hacer que nuestro servicio
devuelva una promesa a un componente que solicita datos del servicio.
Así que cuando se devuelve la promesa,
entonces la promesa de retorno está disponible para usted como un objeto.
Y esta promesa proporciona dos métodos, el método entonces y el método catch.
Ahora, entonces, la promesa se resuelve con éxito.
Entonces la promesa resultará
en llamar a una resolución.
Como viste, la promesa está construida, y dentro de la promesa,
tienes la función, la resolución y el rechazo, como los dos parámetros.
Entonces, si la promesa es capaz de entregar el resultado,
entonces llamará al método de resolución y luego le devolverá el resultado.
¿De dónde llega el resultado la realidad?
Cuando escribe código esperando
la promesa, entonces especificaría qué hacer cuando la promesa devuelve el resultado
en la opción then para esa promesa.
Así que digamos, por ejemplo, dirías getdishes.Entonces y dentro de entonces
proporcionarías la función que tratará con el resultado cuando llegue.
Si la promesa no puede resolverse correctamente, rechazará
con el error que se le enviará de nuevo.
El error es un objeto de error que se le enviará de vuelta.
Así que cuando su promesa sea rechazada, entonces usted lidia con
el rechazo usando una captura dentro de su código.
Así que dentro de la captura, proporcionará una función que se ocupará del error.
Por ejemplo, puede simplemente enviar el mensaje de error,
el registro de la consola y tratar con el error de esa manera.
O puede que tenga una forma más elaborada de manejar el error.
Eso se proporcionaría en la opción de captura que das para ese código de promesa
de tu lado cuando la promesa te entrega un rechazo.
Así que así es como las dos caras de la moneda tratan con las promesas.
Desde un lado, se le envía un objeto de promesa, y
cuando recibe el objeto de promesa, con el objeto de promesa, o bien haría
el entonces y el catch, por lo que se supone que debe implementar tanto el entonces como
las métricas de captura cambiaron a ese objeto de promesa.
Y luego, de esa promesa a un lado, si la promesa resulta correctamente,
entonces la resolución será llamada y por lo tanto, el resultado será entregado
en el método entonces de su promesa.
Si la promesa es rechazada,
la llamada de rechazo entregará el error en su captura.
Entonces, así es como implementarías el código usando promesas.
Trataremos con el ejemplo en el ejercicio que sigue a esta conferencia.
Ahora, obviamente, la pregunta que hago es por qué promesas?
Más adelante, cuando tratamos con Node JS,
nos ocuparemos de cómo podemos construir devoluciones de llamada.
Y voy a explicar los detalles de las devoluciones de llamada y la forma de lidiar con las devoluciones de llamada
cuando cubrimos el Node JS en el último curso de esta especialización.
Las devoluciones de llamada tienen un problema de crear lo que se conoce como el infierno de devolución de llamada.
Así que tiene un código de devolución de llamada fuertemente anidado
que es muy complicado para poder averiguar qué está tratando de hacer.
Las promesas proporcionan una forma de abordar este problema del infierno de devolución de llamada.
Pero por el momento nos estamos concentrando en Angular, solo mencionaré este punto.
Y luego volveremos para tratar esta cuestión en el último curso.
La otra ventaja de usar promesas es que las promesas se pueden cambiar.
Una promesa cuando entrega el resultado en la bin,
puedes generar otra promesa y devolver, y
esa promesa se puede tratar encadenando otro método a eso y así sucesivamente.
Así que puedes encadenar un conjunto de métodos entonces juntos para hacer frente a las promesas
una detrás de la otra.
Si el resultado está inmediatamente disponible o si vas a rechazarlo inmediatamente,
entonces promise proporciona un método para regresar inmediatamente sin esperar a
la promesa para resolver o rechazar.
En ese caso, simplemente dirá promesa con un p.Resolve mayúscula y
Promise.Rechazar y luego devolver el resultado o el error inmediatamente.
En el primer ejercicio, trataremos con este método de devolver el valor
de nuestro servicio a nuestros componentes.
En la segunda parte del ejercicio, vamos a tratar con
la situación en la que la promesa se resolverá después de un tiempo de duración.
Y también dentro de nuestro componente, deberíamos ser capaces de lidiar con el hecho de que
los resultados vuelven un poco más tarde que cuando se pide el resultado.
Con esta rápida comprensión de las promesas,
pasemos al próximo ejercicio donde trataremos con las promesas.
[MÚSICA]