1
00:00:01,210 --> 00:00:02,880
‫Instructor: Empecemos ahora a aprender cómo

2
00:00:02,880 --> 00:00:05,783
‫resolver el infierno de las devoluciones de llamada mediante el uso de promesas.

3
00:00:07,430 --> 00:00:09,750
‫Y comenzaremos usando una promesa para la solicitud

4
00:00:09,750 --> 00:00:11,260
‫de aparición del agente en

5
00:00:11,260 --> 00:00:13,010
‫lugar de la devolución de llamada.

6
00:00:13,010 --> 00:00:16,410
‫Y esto funcionará porque la biblioteca de súper agentes

7
00:00:16,410 --> 00:00:19,770
‫tiene soporte para promesas listas para usar, por lo

8
00:00:19,770 --> 00:00:21,980
‫que simplemente podemos usarlas aquí.

9
00:00:21,980 --> 00:00:25,410
‫Para las funciones de nodo, que provienen de paquetes de nodos internos

10
00:00:25,410 --> 00:00:28,395
‫como Read File, en realidad tendremos que construir la promesa

11
00:00:28,395 --> 00:00:31,690
‫nosotros mismos, y lo haremos más adelante en la próxima lección, más

12
00:00:31,690 --> 00:00:32,523
‫o menos.

13
00:00:32,523 --> 00:00:33,356
‫Pero por

14
00:00:33,356 --> 00:00:36,120
‫ahora, quiero que aprendas cómo consumir promesas

15
00:00:36,120 --> 00:00:38,500
‫y solo más tarde cómo construirlas.

16
00:00:38,500 --> 00:00:40,433
‫Bien, de nuevo vamos a empezar

17
00:00:40,433 --> 00:00:42,350
‫con la biblioteca de

18
00:00:42,350 --> 00:00:45,930
‫súper agentes y más específicamente con el método get aquí.

19
00:00:45,930 --> 00:00:50,220
‫Porque este método aquí realmente devuelve una promesa.

20
00:00:50,220 --> 00:00:53,690
‫Entonces, sin entrar en demasiados detalles, por ahora, una

21
00:00:53,690 --> 00:00:55,410
‫promesa básicamente implementa el

22
00:00:55,410 --> 00:00:57,550
‫concepto de un valor futuro.

23
00:00:57,550 --> 00:01:00,470
‫Básicamente, es un valor que esperamos recibir en algún momento

24
00:01:00,470 --> 00:01:02,270
‫en el futuro, por lo que

25
00:01:02,270 --> 00:01:04,900
‫es un poco como si dijéramos "Oye, servidor" o

26
00:01:04,900 --> 00:01:08,157
‫"Oye, API, por favor, consígueme una imagen de perro aleatoria" en segundo

27
00:01:08,157 --> 00:01:10,617
‫plano y deja sé cuándo estás listo "y

28
00:01:10,617 --> 00:01:14,243
‫luego devuélveme esos datos. " ¿Okey?

29
00:01:14,243 --> 00:01:16,906
‫Entonces, esa imagen aleatoria es el valor

30
00:01:16,906 --> 00:01:19,140
‫que esperamos en el futuro.

31
00:01:19,140 --> 00:01:21,340
‫Y ese es exactamente el tipo de solicitud

32
00:01:21,340 --> 00:01:23,650
‫que estamos haciendo usando una biblioteca de súper agentes

33
00:01:23,650 --> 00:01:24,740
‫en este ejemplo.

34
00:01:24,740 --> 00:01:25,573
‫Derecha.

35
00:01:25,573 --> 00:01:28,840
‫Y el método de obtención que usamos nuevamente

36
00:01:28,840 --> 00:01:32,660
‫devolverá una promesa automática e inmediatamente tan pronto como iniciemos

37
00:01:32,660 --> 00:01:33,493
‫la solicitud.

38
00:01:33,493 --> 00:01:35,870
‫Entonces, la promesa aún no tiene valor,

39
00:01:35,870 --> 00:01:38,610
‫porque el servidor en realidad todavía está obteniendo

40
00:01:38,610 --> 00:01:41,470
‫los datos del servidor de forma asincrónica en segundo

41
00:01:41,470 --> 00:01:43,790
‫plano, pero la promesa está disponible de

42
00:01:43,790 --> 00:01:47,070
‫inmediato y básicamente nos promete que obtendrá algunos datos en

43
00:01:47,070 --> 00:01:48,070
‫el futuro.

44
00:01:48,070 --> 00:01:50,150
‫Vale, ¿eso tiene sentido?

45
00:01:50,150 --> 00:01:52,960
‫Y ese estado de la promesa en ese caso,

46
00:01:52,960 --> 00:01:55,660
‫tan justo al principio, es una promesa pendiente.

47
00:01:55,660 --> 00:01:58,331
‫Así que todavía está pendiente, todavía

48
00:01:58,331 --> 00:02:01,050
‫no ha vuelto con ningún dato, ¿de acuerdo?

49
00:02:01,050 --> 00:02:03,480
‫Así que aquí, en este punto, ya tenemos una promesa

50
00:02:03,480 --> 00:02:04,750
‫con la que podemos trabajar.

51
00:02:04,750 --> 00:02:07,470
‫Ahora todo lo que tenemos que hacer es consumirlo,

52
00:02:07,470 --> 00:02:10,350
‫lo que básicamente significa que esperamos a que regrese

53
00:02:10,350 --> 00:02:11,470
‫con los datos.

54
00:02:11,470 --> 00:02:14,513
‫Y para hacer eso, usamos el método then.

55
00:02:15,710 --> 00:02:19,650
‫Entonces, todo lo que hacemos es usar entonces y luego

56
00:02:19,650 --> 00:02:22,950
‫aquí, pasamos una función de devolución de llamada.

57
00:02:22,950 --> 00:02:25,730
‫Esta función de devolución de llamada se llamará tan

58
00:02:25,730 --> 00:02:29,740
‫pronto como la promesa haya terminado de hacer su trabajo y haya regresado

59
00:02:29,740 --> 00:02:30,980
‫con los datos.

60
00:02:30,980 --> 00:02:33,520
‫Y esos datos están disponibles como argumento para esa

61
00:02:33,520 --> 00:02:34,630
‫devolución de llamada.

62
00:02:34,630 --> 00:02:36,380
‫Ahora me gusta llamar a eso el resultado.

63
00:02:39,270 --> 00:02:42,140
‫Y así, nuevamente en esa función de devolución de llamada

64
00:02:42,140 --> 00:02:44,690
‫que tenemos aquí, tenemos esos datos disponibles.

65
00:02:44,690 --> 00:02:47,962
‫Así que tomemos todo esto aquí y pongámoslo en

66
00:02:47,962 --> 00:02:50,830
‫esta función de devolución de llamada y, de

67
00:02:50,830 --> 00:02:52,423
‫hecho, eliminemos esto.

68
00:02:53,530 --> 00:02:55,350
‫Así que ya no necesitamos

69
00:02:55,350 --> 00:02:57,110
‫eso, y salvamos.

70
00:02:57,110 --> 00:03:00,380
‫Ahora podría estar pensando, bueno, todavía estamos

71
00:03:00,380 --> 00:03:04,510
‫usando devoluciones de llamada aquí, y sí, eso es realmente cierto.

72
00:03:04,510 --> 00:03:07,650
‫Por lo tanto, esto no parece un gran cambio por

73
00:03:07,650 --> 00:03:10,530
‫ahora, pero después de que transformemos todo el

74
00:03:10,530 --> 00:03:11,770
‫ejemplo aquí en

75
00:03:11,770 --> 00:03:15,657
‫promesas, verá el gran impacto que las promesas tendrán en nuestro código.

76
00:03:15,657 --> 00:03:19,320
‫Básicamente, si tenemos varias promesas, podremos encadenar estas

77
00:03:19,320 --> 00:03:22,700
‫devoluciones de llamada entre sí en lugar

78
00:03:22,700 --> 00:03:24,150
‫de anidarlas.

79
00:03:24,150 --> 00:03:26,343
‫Lo que ya es una gran mejora.

80
00:03:27,370 --> 00:03:29,520
‫Ahora bien, una cosa que olvidé mencionar

81
00:03:29,520 --> 00:03:32,850
‫antes es que una promesa tan pronto como regrese con los

82
00:03:32,850 --> 00:03:34,980
‫datos se llama promesa resuelta.

83
00:03:34,980 --> 00:03:37,180
‫Entonces, al principio es una promesa pendiente

84
00:03:37,180 --> 00:03:39,160
‫y cuando obtiene los datos

85
00:03:39,160 --> 00:03:41,180
‫con éxito, entonces es una promesa resuelta.

86
00:03:41,180 --> 00:03:44,600
‫Sin embargo, es posible que una promesa resuelta no siempre

87
00:03:44,600 --> 00:03:47,670
‫tenga éxito porque podría haber habido un error.

88
00:03:47,670 --> 00:03:50,895
‫Entonces decimos que una promesa resuelta puede

89
00:03:50,895 --> 00:03:52,510
‫cumplirse o rechazarse.

90
00:03:52,510 --> 00:03:55,680
‫La promesa cumplida en realidad tiene un resultado que

91
00:03:55,680 --> 00:03:56,513
‫queremos utilizar.

92
00:03:56,513 --> 00:04:00,860
‫Mientras que una promesa rechazada es cuando hubo un error.

93
00:04:00,860 --> 00:04:03,050
‫Así que recuerde la situación que tuvimos

94
00:04:03,050 --> 00:04:05,950
‫antes en la que teníamos una raza de perro equivocada.

95
00:04:05,950 --> 00:04:07,750
‫Entonces, en ese caso,

96
00:04:07,750 --> 00:04:11,840
‫tuvimos un error y manejamos ese error usando este código aquí.

97
00:04:11,840 --> 00:04:12,673
‫Bueno.

98
00:04:12,673 --> 00:04:14,980
‫Ahora bien, el problema con este método

99
00:04:14,980 --> 00:04:18,160
‫entonces aquí es que en realidad solo maneja las promesas

100
00:04:18,160 --> 00:04:20,770
‫cumplidas, pero no hace nada si hubo un

101
00:04:20,770 --> 00:04:23,640
‫error, porque para eso, en realidad tenemos otro método.

102
00:04:23,640 --> 00:04:25,790
‫Entonces, otro mecanismo para manejar eso.

103
00:04:25,790 --> 00:04:27,840
‫Y ese es el método de captura.

104
00:04:27,840 --> 00:04:29,960
‫Entonces, justo después del método then,

105
00:04:29,960 --> 00:04:32,753
‫podemos encadenar otro método que se llama catch.

106
00:04:34,390 --> 00:04:35,223
‫Bueno.

107
00:04:35,223 --> 00:04:38,350
‫Y este será llamado si hubo un error.

108
00:04:38,350 --> 00:04:42,243
‫Entonces aquí, de hecho, tenemos acceso a ese objeto de error.

109
00:04:44,480 --> 00:04:46,640
‫Y ahora sigamos adelante, tomemos

110
00:04:46,640 --> 00:04:48,590
‫este fragmento de código y

111
00:04:48,590 --> 00:04:49,423
‫colóquelo

112
00:04:49,423 --> 00:04:52,290
‫aquí, y ahora podemos deshacernos de esto.

113
00:04:52,290 --> 00:04:54,310
‫Porque en realidad en este método,

114
00:04:54,310 --> 00:04:56,330
‫no tenemos información si hubo

115
00:04:56,330 --> 00:04:59,000
‫un error o no porque solo se llama

116
00:04:59,000 --> 00:05:01,620
‫en caso de que la promesa sea exitosa.

117
00:05:01,620 --> 00:05:03,440
‫Entonces, si es una promesa cumplida.

118
00:05:03,440 --> 00:05:07,120
‫Bien, es bueno separar estos dos

119
00:05:07,120 --> 00:05:09,870
‫casos automáticamente para nosotros.

120
00:05:09,870 --> 00:05:12,400
‫Entonces, en lugar de tener ese manejo

121
00:05:12,400 --> 00:05:13,470
‫extraño que

122
00:05:13,470 --> 00:05:17,400
‫teníamos antes, simplemente podemos escribir toda la lógica para el caso

123
00:05:17,400 --> 00:05:19,080
‫exitoso, que es el

124
00:05:19,080 --> 00:05:21,900
‫más habitual porque generalmente esperamos que todo funcione

125
00:05:21,900 --> 00:05:24,550
‫bien, pero en caso de que haya un

126
00:05:24,550 --> 00:05:29,336
‫error, podemos ingresar alguna otra lógica aquí abajo en este controlador de errores aquí.

127
00:05:29,336 --> 00:05:32,370
‫Así que lo mantenemos bien separado.

128
00:05:32,370 --> 00:05:33,853
‫Cambiémoslo aquí de nuevo.

129
00:05:36,030 --> 00:05:38,493
‫Dale a este otro guardado para ejecutarlo nuevamente.

130
00:05:39,450 --> 00:05:41,710
‫Y aquí tenemos No encontrado, y

131
00:05:41,710 --> 00:05:45,720
‫entonces puede ver que en realidad ingresó este método de captura aquí

132
00:05:45,720 --> 00:05:47,860
‫y no hizo ninguna de

133
00:05:47,860 --> 00:05:50,270
‫las cosas que están en este método.

134
00:05:50,270 --> 00:05:52,980
‫Ahora adelante, arregle esto aquí, ciérrelo,

135
00:05:52,980 --> 00:05:53,813
‫guarde

136
00:05:53,813 --> 00:05:54,900
‫este y

137
00:05:54,900 --> 00:05:55,910
‫aquí vamos.

138
00:05:55,910 --> 00:05:58,620
‫Así es como consumimos las promesas.

139
00:05:58,620 --> 00:06:01,870
‫Así que comenzamos con este método aquí que

140
00:06:01,870 --> 00:06:04,280
‫devolvió una promesa y así sucesivamente,

141
00:06:04,280 --> 00:06:06,160
‫podemos encadenar el método

142
00:06:06,160 --> 00:06:08,810
‫then que maneja básicamente el caso exitoso,

143
00:06:08,810 --> 00:06:12,060
‫y luego, al final, también encadenamos el método

144
00:06:12,060 --> 00:06:16,090
‫catch que maneja lo fallido, por lo que el rechazado, promesa.

145
00:06:16,090 --> 00:06:19,860
‫Pero como dije antes, esto todavía se ve

146
00:06:19,860 --> 00:06:20,930
‫como antes.

147
00:06:20,930 --> 00:06:21,763
‫¿Derecha?

148
00:06:21,763 --> 00:06:25,000
‫Así que todavía tenemos esta función de devolución de llamada aquí,

149
00:06:26,180 --> 00:06:28,440
‫así que toda esta función de devolución

150
00:06:28,440 --> 00:06:32,520
‫de llamada y también aquí dentro de nuestro método then, tenemos esta función

151
00:06:32,520 --> 00:06:34,600
‫de devolución de llamada del writeFile.

152
00:06:34,600 --> 00:06:37,663
‫Así que sigamos adelante y arreglemos eso en el siguiente video.