1
00:00:00,000 --> 00:00:04,722
[MUSIC]

2
00:00:04,722 --> 00:00:10,212
Cuando estábamos hablando de servicios en el módulo anterior, había mencionado

3
00:00:10,212 --> 00:00:16,070
sobre promesas y luego prometí que volvería a las promesas en este módulo.

4
00:00:17,360 --> 00:00:20,360
Así que, aquí estamos voy a cumplir mi promesa que te hice.

5
00:00:22,090 --> 00:00:28,310
Un cálculo sincrónico está por todas partes en la World Wide Web.

6
00:00:28,310 --> 00:00:31,410
Y cómo funciona la web.

7
00:00:32,880 --> 00:00:35,810
Si vienes del mundo de la programación secuencial,

8
00:00:37,040 --> 00:00:41,640
envolver tu cabeza alrededor de un cálculo sincrónico requiere un poco de esfuerzo.

9
00:00:42,680 --> 00:00:48,570
Ha habido muchos intentos de hacer que el cálculo asíncrono sea tan indoloro como

10
00:00:48,570 --> 00:00:54,680
posible para las personas que están en transición a él desde el libro de cálculo secuencial.

11
00:00:56,850 --> 00:01:01,470
Uno de esos intentos son hacer que la computación asíncrona

12
00:01:01,470 --> 00:01:04,790
sea más fácil de lograr son las promesas.

13
00:01:06,040 --> 00:01:10,304
Como nos damos cuenta, cuando hacemos cualquier solicitud a cualquier servicio

14
00:01:10,304 --> 00:01:15,220
o a un servidor back-end,

15
00:01:16,530 --> 00:01:21,180
va a tomar algún tiempo para que los resultados estén disponibles para nosotros.

16
00:01:22,550 --> 00:01:30,840
Si hacemos tal solicitud mientras estamos procediendo con nuestro trabajo,

17
00:01:30,840 --> 00:01:35,680
entonces hay una alta probabilidad de que nuestro cálculo se quede atascado en el punto,

18
00:01:35,680 --> 00:01:37,890
esperando los resultados.

19
00:01:37,890 --> 00:01:44,070
Esto es un no-no en términos de hacer una buena experiencia de usuario.

20
00:01:46,090 --> 00:01:52,420
Así que es importante que cada vez que sus resultados vayan a tomar tiempo

21
00:01:52,420 --> 00:01:57,660
usted pueda seguir adelante sin esperar las reglas.

22
00:01:57,660 --> 00:02:01,492
Y ahí es donde la computación asincrónica viene a su ventaja.

23
00:02:01,492 --> 00:02:04,640
En el cálculo asíncrono cuando envía una solicitud

24
00:02:04,640 --> 00:02:07,800
está esperando que los resultados vuelvan en un momento posterior, y

25
00:02:07,800 --> 00:02:12,720
debería ser capaz de lidiar con el hecho, los resultados base vuelven en un momento

26
00:02:14,490 --> 00:02:20,410
mucho más tarde que donde estaba en el momento en que hizo la solicitud.

27
00:02:21,830 --> 00:02:25,710
Las promesas nos proporcionan una manera de lidiar con esto.

28
00:02:26,790 --> 00:02:32,540
Echemos un vistazo a las promesas con un poco más de detalle en esta conferencia.

29
00:02:32,540 --> 00:02:35,910
Y luego también veremos el uso de promesas

30
00:02:35,910 --> 00:02:39,490
en nuestra aplicación Angular un poco más tarde.

31
00:02:39,490 --> 00:02:44,750
Promesas, el concepto general es un área muy vasta por sí mismo.

32
00:02:44,750 --> 00:02:49,030
Y en este curso, no tengo tiempo para revisar los detalles de las promesas.

33
00:02:49,030 --> 00:02:51,780
Eso se convertirá en un curso completo en sí mismo.

34
00:02:51,780 --> 00:02:56,950
Te daré sólo lo esencial de las promesas que son necesarias para que

35
00:02:56,950 --> 00:03:02,490
nosotros entienda cómo hacer uso de las promesas dentro de nuestra aplicación angular.

36
00:03:02,490 --> 00:03:07,230
Te proporciono muchas pistas a recursos

37
00:03:07,230 --> 00:03:11,380
adicionales donde puedes ir y examinar las promesas con más detalle.

38
00:03:13,110 --> 00:03:17,230
Así que volviendo a esa pregunta, ¿qué es exactamente una promesa?

39
00:03:17,230 --> 00:03:21,690
Una promesa es un mecanismo que admite la computación asíncrona.

40
00:03:21,690 --> 00:03:26,580
Acabo de dar una explicación larga de por qué la computación asíncrona

41
00:03:26,580 --> 00:03:31,340
es esencial para que la web funcione.

42
00:03:31,340 --> 00:03:36,720
Ahora, al usar una promesa, la promesa proporciona un mecanismo o

43
00:03:36,720 --> 00:03:42,760
un proxy para un valor que no está disponible en el momento en que usted lo pide.

44
00:03:42,760 --> 00:03:46,050
Así que una promesa te devolverá una promesa, diciendo que

45
00:03:46,050 --> 00:03:51,430
cuando el resultado esté disponible, volverá y te entregará los resultados.

46
00:03:51,430 --> 00:03:56,850
Entonces, una promesa le devuelve un objeto proxy y se aferra al objeto proxy.

47
00:03:56,850 --> 00:04:02,030
Y ese objeto proxy le dará acceso a los resultados cuando estén disponibles.

48
00:04:02,030 --> 00:04:07,290
Y hay un método en cómo esperas los resultados.

49
00:04:07,290 --> 00:04:11,560
En realidad no suspende su cálculo en ese momento, en su lugar

50
00:04:13,110 --> 00:04:19,948
configura una forma de aceptar los resultados cuando vuelva de esa promesa.

51
00:04:19,948 --> 00:04:23,780
Para decirlo en pocas palabras,

52
00:04:23,780 --> 00:04:27,960
promise representa un valor que estará disponible en un futuro.

53
00:04:27,960 --> 00:04:29,680
También puede estar disponible inmediatamente,

54
00:04:29,680 --> 00:04:32,960
en cuyo caso la promesa devolverá el valor inmediatamente.

55
00:04:32,960 --> 00:04:37,940
Pero en caso de que necesite devolver un valor en una fecha futura, entonces le da

56
00:04:37,940 --> 00:04:42,040
la promesa de que ese valor cuando esté disponible será devuelto a usted.

57
00:04:43,400 --> 00:04:47,820
Siempre existe la posibilidad de que la promesa no se pueda cumplir,

58
00:04:47,820 --> 00:04:50,730
porque los resultados no están disponibles por cualquier razón.

59
00:04:51,950 --> 00:04:57,150
En ese caso, se te entregará un error, o se te entregará un rechazo

60
00:04:57,150 --> 00:05:02,430
, y depende de ti lidiar con el hecho de que la promesa fue rechazada.

61
00:05:03,930 --> 00:05:06,890
Nos fijamos en cómo nos ocupamos de eso en la siguiente diapositiva.

62
00:05:07,950 --> 00:05:11,180
Como aprendimos antes, una promesa es un proxy para

63
00:05:11,180 --> 00:05:15,080
algo que iba a suceder en el futuro o que nunca ocurriría en el futuro.

64
00:05:15,080 --> 00:05:19,745
Así que una promesa cuando se te dé, estará en el estado pendiente.

65
00:05:20,860 --> 00:05:25,130
Ahora, cuando la promesa se resuelva, eso es que los resultados estén disponibles y

66
00:05:25,130 --> 00:05:30,080
la promesa es capaz de entregar los resultados a usted, entonces la promesa se resolverá o

67
00:05:30,080 --> 00:05:31,490
cumplirá.

68
00:05:31,490 --> 00:05:37,130
Y en ese caso la promesa pasará del estado pendiente al estado de resolución o

69
00:05:37,130 --> 00:05:38,490
al estado de cumplimiento.

70
00:05:38,490 --> 00:05:41,220
Así que en ese momento sus resultados están disponibles para usted.

71
00:05:42,540 --> 00:05:48,760
Hay una ligera posibilidad de que la promesa pueda ser rechazada debido a un error,

72
00:05:48,760 --> 00:05:50,590
o cualquiera que sea la razón.

73
00:05:50,590 --> 00:05:53,280
En esa circunstancia remota,

74
00:05:53,280 --> 00:05:57,980
se le entregará un rechazo y en ese caso, la promesa será

75
00:05:57,980 --> 00:06:02,209
considerada como rechazada cuando se entregue el rechazo.

76
00:06:03,380 --> 00:06:06,710
Entonces, cuando generas una promesa, como dije,

77
00:06:06,710 --> 00:06:10,560
una promesa es un objeto proxy que se te entrega.

78
00:06:10,560 --> 00:06:14,580
Entonces, cuando usted entrega una promesa a alguien, la promesa internamente tendrá

79
00:06:14,580 --> 00:06:17,500
una función que tratará tanto con la resolución como

80
00:06:17,500 --> 00:06:20,310
las opciones de rechazo dentro de allí.

81
00:06:21,480 --> 00:06:22,540
Al escribir código,

82
00:06:22,540 --> 00:06:28,190
verá que va a escribir código como nueva promesa (función (resolver, rechazar).

83
00:06:28,190 --> 00:06:33,350
Así que ya sea que se resuelva o sea rechazado, necesitamos poder enviar

84
00:06:33,350 --> 00:06:38,290
de vuelta la información a quien le hayamos entregado la promesa.

85
00:06:39,570 --> 00:06:41,600
¿Cómo hacemos esto en código?

86
00:06:41,600 --> 00:06:44,040
Echemos un vistazo a eso en la siguiente diapositiva.

87
00:06:45,280 --> 00:06:50,430
Aquí hay un ejemplo de cómo se configura promesa en el código.

88
00:06:50,430 --> 00:06:53,870
De hecho, este ejemplo se deriva del ejercicio que harás

89
00:06:53,870 --> 00:06:55,850
un poco más tarde.

90
00:06:55,850 --> 00:07:01,100
Así que aquí, cuando configuramos nuestro servicio, podemos hacer que nuestro servicio

91
00:07:01,100 --> 00:07:06,830
devuelva una promesa a un componente que solicita datos del servicio.

92
00:07:06,830 --> 00:07:08,368
Así que cuando se devuelve la promesa,

93
00:07:08,368 --> 00:07:13,810
entonces la promesa de retorno está disponible para usted como un objeto.

94
00:07:13,810 --> 00:07:18,190
Y esta promesa proporciona dos métodos, el método entonces y el método catch.

95
00:07:19,420 --> 00:07:23,416
Ahora, entonces, la promesa se resuelve con éxito.

96
00:07:23,416 --> 00:07:28,300
Entonces la promesa resultará

97
00:07:28,300 --> 00:07:32,810
en llamar a una resolución.

98
00:07:32,810 --> 00:07:36,960
Como viste, la promesa está construida, y dentro de la promesa,

99
00:07:36,960 --> 00:07:42,170
tienes la función, la resolución y el rechazo, como los dos parámetros.

100
00:07:42,170 --> 00:07:46,820
Entonces, si la promesa es capaz de entregar el resultado,

101
00:07:46,820 --> 00:07:51,680
entonces llamará al método de resolución y luego le devolverá el resultado.

102
00:07:51,680 --> 00:07:53,520
¿De dónde llega el resultado la realidad?

103
00:07:54,820 --> 00:07:58,820
Cuando escribe código esperando

104
00:07:58,820 --> 00:08:04,400
la promesa, entonces especificaría qué hacer cuando la promesa devuelve el resultado

105
00:08:04,400 --> 00:08:09,370
en la opción then para esa promesa.

106
00:08:09,370 --> 00:08:14,590
Así que digamos, por ejemplo, dirías getdishes.Entonces y dentro de entonces

107
00:08:14,590 --> 00:08:18,810
proporcionarías la función que tratará con el resultado cuando llegue.

108
00:08:20,370 --> 00:08:25,700
Si la promesa no puede resolverse correctamente, rechazará

109
00:08:25,700 --> 00:08:28,570
con el error que se le enviará de nuevo.

110
00:08:28,570 --> 00:08:31,600
El error es un objeto de error que se le enviará de vuelta.

111
00:08:31,600 --> 00:08:36,560
Así que cuando su promesa sea rechazada, entonces usted lidia con

112
00:08:36,560 --> 00:08:41,020
el rechazo usando una captura dentro de su código.

113
00:08:41,020 --> 00:08:47,460
Así que dentro de la captura, proporcionará una función que se ocupará del error.

114
00:08:47,460 --> 00:08:51,470
Por ejemplo, puede simplemente enviar el mensaje de error,

115
00:08:51,470 --> 00:08:56,770
el registro de la consola y tratar con el error de esa manera.

116
00:08:56,770 --> 00:09:01,080
O puede que tenga una forma más elaborada de manejar el error.

117
00:09:01,080 --> 00:09:06,670
Eso se proporcionaría en la opción de captura que das para ese código de promesa

118
00:09:06,670 --> 00:09:12,130
de tu lado cuando la promesa te entrega un rechazo.

119
00:09:12,130 --> 00:09:17,690
Así que así es como las dos caras de la moneda tratan con las promesas.

120
00:09:17,690 --> 00:09:21,160
Desde un lado, se le envía un objeto de promesa, y

121
00:09:21,160 --> 00:09:24,730
cuando recibe el objeto de promesa, con el objeto de promesa, o bien haría

122
00:09:24,730 --> 00:09:28,300
el entonces y el catch, por lo que se supone que debe implementar tanto el entonces como

123
00:09:28,300 --> 00:09:33,510
las métricas de captura cambiaron a ese objeto de promesa.

124
00:09:34,780 --> 00:09:39,910
Y luego, de esa promesa a un lado, si la promesa resulta correctamente,

125
00:09:39,910 --> 00:09:44,757
entonces la resolución será llamada y por lo tanto, el resultado será entregado

126
00:09:44,757 --> 00:09:48,770
en el método entonces de su promesa.

127
00:09:48,770 --> 00:09:51,175
Si la promesa es rechazada,

128
00:09:51,175 --> 00:09:55,530
la llamada de rechazo entregará el error en su captura.

129
00:09:56,760 --> 00:10:01,725
Entonces, así es como implementarías el código usando promesas.

130
00:10:01,725 --> 00:10:07,375
Trataremos con el ejemplo en el ejercicio que sigue a esta conferencia.

131
00:10:07,375 --> 00:10:09,786
Ahora, obviamente, la pregunta que hago es por qué promesas?

132
00:10:11,347 --> 00:10:13,927
Más adelante, cuando tratamos con Node JS,

133
00:10:13,927 --> 00:10:18,237
nos ocuparemos de cómo podemos construir devoluciones de llamada.

134
00:10:18,237 --> 00:10:21,677
Y voy a explicar los detalles de las devoluciones de llamada y la forma de lidiar con las devoluciones de llamada

135
00:10:21,677 --> 00:10:29,920
cuando cubrimos el Node JS en el último curso de esta especialización.

136
00:10:29,920 --> 00:10:37,400
Las devoluciones de llamada tienen un problema de crear lo que se conoce como el infierno de devolución de llamada.

137
00:10:37,400 --> 00:10:40,000
Así que tiene un código de devolución de llamada fuertemente anidado

138
00:10:40,000 --> 00:10:44,650
que es muy complicado para poder averiguar qué está tratando de hacer.

139
00:10:44,650 --> 00:10:50,970
Las promesas proporcionan una forma de abordar este problema del infierno de devolución de llamada.

140
00:10:50,970 --> 00:10:55,270
Pero por el momento nos estamos concentrando en Angular, solo mencionaré este punto.

141
00:10:55,270 --> 00:10:59,050
Y luego volveremos para tratar esta cuestión en el último curso.

142
00:11:00,760 --> 00:11:05,600
La otra ventaja de usar promesas es que las promesas se pueden cambiar.

143
00:11:05,600 --> 00:11:08,780
Una promesa cuando entrega el resultado en la bin,

144
00:11:08,780 --> 00:11:11,130
puedes generar otra promesa y devolver, y

145
00:11:11,130 --> 00:11:16,280
esa promesa se puede tratar encadenando otro método a eso y así sucesivamente.

146
00:11:16,280 --> 00:11:21,720
Así que puedes encadenar un conjunto de métodos entonces juntos para hacer frente a las promesas

147
00:11:21,720 --> 00:11:23,470
una detrás de la otra.

148
00:11:25,610 --> 00:11:31,850
Si el resultado está inmediatamente disponible o si vas a rechazarlo inmediatamente,

149
00:11:31,850 --> 00:11:37,190
entonces promise proporciona un método para regresar inmediatamente sin esperar a

150
00:11:37,190 --> 00:11:39,900
la promesa para resolver o rechazar.

151
00:11:39,900 --> 00:11:45,766
En ese caso, simplemente dirá promesa con un p.Resolve mayúscula y

152
00:11:45,766 --> 00:11:52,243
Promise.Rechazar y luego devolver el resultado o el error inmediatamente.

153
00:11:52,243 --> 00:11:57,079
En el primer ejercicio, trataremos con este método de devolver el valor

154
00:11:57,079 --> 00:11:59,480
de nuestro servicio a nuestros componentes.

155
00:12:00,920 --> 00:12:04,010
En la segunda parte del ejercicio, vamos a tratar con

156
00:12:04,010 --> 00:12:09,820
la situación en la que la promesa se resolverá después de un tiempo de duración.

157
00:12:09,820 --> 00:12:13,400
Y también dentro de nuestro componente, deberíamos ser capaces de lidiar con el hecho de que

158
00:12:13,400 --> 00:12:20,280
los resultados vuelven un poco más tarde que cuando se pide el resultado.

159
00:12:22,485 --> 00:12:25,679
Con esta rápida comprensión de las promesas,

160
00:12:25,679 --> 00:12:30,393
pasemos al próximo ejercicio donde trataremos con las promesas.

161
00:12:30,393 --> 00:12:33,769
[MÚSICA]