1
00:00:01,500 --> 00:00:03,600
‫Instructor: En este video, prometeremos

2
00:00:03,600 --> 00:00:06,680
‫las funciones de archivo de lectura y escritura.

3
00:00:06,680 --> 00:00:09,440
‫Lo que significa que los haremos para

4
00:00:09,440 --> 00:00:11,230
‫que devuelvan promesas en

5
00:00:11,230 --> 00:00:14,383
‫lugar de pasarles funciones de devolución de llamada.

6
00:00:16,180 --> 00:00:19,156
‫Entonces, si lo desea, es básicamente una función de archivo de

7
00:00:19,156 --> 00:00:20,890
‫lectura que devuelve una promesa

8
00:00:20,890 --> 00:00:24,300
‫y que solo recibe un nombre de archivo, sin devolución de llamada.

9
00:00:24,300 --> 00:00:26,023
‫Así que hagamos exactamente eso.

10
00:00:28,530 --> 00:00:33,530
‫Entonces, vamos a crear una función pro de lectura de archivos.

11
00:00:34,110 --> 00:00:36,380
‫Así que a favor de la promesa porque

12
00:00:36,380 --> 00:00:37,970
‫nuevamente devuelve una promesa.

13
00:00:37,970 --> 00:00:40,270
‫Y luego todo lo que hacemos es

14
00:00:41,590 --> 00:00:44,713
‫pasar el nombre del archivo y, como decíamos, devolver una promesa.

15
00:00:46,060 --> 00:00:49,570
‫Entonces, devuelva una nueva promesa.

16
00:00:49,570 --> 00:00:52,150
‫Entonces usamos el constructor de promesas

17
00:00:52,150 --> 00:00:55,540
‫aquí que se introdujo en el lenguaje con ES6.

18
00:00:55,540 --> 00:00:58,600
‫Entonces, antes de ES6 como ES5, ES4

19
00:00:58,600 --> 00:01:00,030
‫y todas las

20
00:01:00,030 --> 00:01:03,820
‫versiones anteriores, no había soporte para promesas en JavaScript.

21
00:01:03,820 --> 00:01:05,670
‫Pero cambiaron eso en

22
00:01:05,670 --> 00:01:08,660
‫ES6 y mejoraron mucho el lenguaje en ese sentido.

23
00:01:08,660 --> 00:01:12,010
‫Por lo que respecta a JavaScript asincrónico.

24
00:01:12,010 --> 00:01:14,350
‫Ahora, este constructor de promesas

25
00:01:14,350 --> 00:01:17,400
‫aquí toma una llamada función ejecutora, que

26
00:01:17,400 --> 00:01:20,980
‫se llamará inmediatamente cuando se cree la promesa.

27
00:01:20,980 --> 00:01:24,450
‫Y esta función tomará dos argumentos, así que

28
00:01:24,450 --> 00:01:26,363
‫resuelva y rechace.

29
00:01:28,330 --> 00:01:30,370
‫Así que resuelvan y rechacen,

30
00:01:30,370 --> 00:01:32,770
‫pero por ahora no se preocupen por

31
00:01:32,770 --> 00:01:35,020
‫ellos, hablaremos de ellos en un minuto.

32
00:01:35,020 --> 00:01:38,550
‫Por ahora, centrémonos en esta función ejecutora en sí

33
00:01:38,550 --> 00:01:41,470
‫misma porque aquí es donde realmente hacemos

34
00:01:41,470 --> 00:01:43,450
‫todo este trabajo asincrónico.

35
00:01:43,450 --> 00:01:46,430
‫En este caso, el archivo de lectura funciona.

36
00:01:46,430 --> 00:01:48,890
‫Así que aquí es donde llamaremos fs. readfile con el

37
00:01:51,040 --> 00:01:53,287
‫nombre del archivo que se pasó

38
00:01:53,287 --> 00:01:57,270
‫y luego la función de devolución de llamada habitual, está bien.

39
00:01:57,270 --> 00:02:00,660
‫Entonces, el error y los datos,

40
00:02:00,660 --> 00:02:02,000
‫como antes.

41
00:02:02,000 --> 00:02:03,550
‫Así que tenga en cuenta

42
00:02:03,550 --> 00:02:06,200
‫que en realidad no estamos cambiando la función de

43
00:02:06,200 --> 00:02:07,997
‫archivo de lectura, simplemente estamos creando

44
00:02:07,997 --> 00:02:11,140
‫una nueva función que, detrás de escena, por supuesto, todavía ejecuta

45
00:02:11,140 --> 00:02:13,850
‫la función de archivo de lectura incorporada, pero luego devuelve

46
00:02:13,850 --> 00:02:15,570
‫una promesa para que podamos usar

47
00:02:15,570 --> 00:02:17,040
‫la promesa en su

48
00:02:17,040 --> 00:02:19,170
‫lugar. de la función de devolución de llamada.

49
00:02:19,170 --> 00:02:20,320
‫Bueno.

50
00:02:20,320 --> 00:02:22,630
‫Así que aquí tenemos esa función de lectura

51
00:02:22,630 --> 00:02:24,270
‫de archivo que hará

52
00:02:24,270 --> 00:02:27,250
‫su trabajo y cuando esté lista volverá con los datos.

53
00:02:27,250 --> 00:02:29,070
‫Y ahora aquí es donde

54
00:02:29,070 --> 00:02:31,510
‫entran en juego las funciones de resolución y rechazo.

55
00:02:31,510 --> 00:02:34,610
‫Porque ambos argumentos que están

56
00:02:34,610 --> 00:02:38,390
‫disponibles en la función ejecutora son funciones.

57
00:02:38,390 --> 00:02:40,410
‫Ahora, llamar a la

58
00:02:40,410 --> 00:02:44,250
‫función de resolución marcará básicamente la promesa como exitosa

59
00:02:44,250 --> 00:02:45,320
‫y cumplida,

60
00:02:45,320 --> 00:02:49,010
‫y devolverá el valor exitoso de la promesa.

61
00:02:49,010 --> 00:02:50,310
‫Así que hagámoslo de verdad.

62
00:02:51,520 --> 00:02:55,270
‫Por eso lo llamamos resolver con datos.

63
00:02:55,270 --> 00:02:58,690
‫Entonces, cualquier variable que pasemos a la función de resolución

64
00:02:58,690 --> 00:03:00,860
‫es lo que estará disponible

65
00:03:00,860 --> 00:03:04,370
‫más adelante como argumento en el método then, ¿de acuerdo?

66
00:03:04,370 --> 00:03:07,310
‫Entonces, estos datos aquí serán el

67
00:03:07,310 --> 00:03:10,550
‫valor que nos devuelva esta promesa, está bien.

68
00:03:10,550 --> 00:03:12,930
‫Eso probablemente suena un poco confuso, ¿verdad?

69
00:03:12,930 --> 00:03:17,080
‫Entonces, nuevamente, lo que sea que pasemos a esta función aquí, a

70
00:03:17,080 --> 00:03:18,840
‫la función de resolución,

71
00:03:18,840 --> 00:03:20,690
‫es el resultado de la

72
00:03:20,690 --> 00:03:23,590
‫promesa que estará disponible en el controlador then.

73
00:03:23,590 --> 00:03:24,700
‫Ahora, por otro

74
00:03:24,700 --> 00:03:27,800
‫lado, también podemos marcar la promesa como rechazada en caso

75
00:03:27,800 --> 00:03:29,960
‫de que haya un error, está bien.

76
00:03:29,960 --> 00:03:31,230
‫Y lo hacemos llamando,

77
00:03:31,230 --> 00:03:32,450
‫como probablemente

78
00:03:32,450 --> 00:03:34,710
‫pueda adivinar, a la función de rechazo.

79
00:03:34,710 --> 00:03:36,390
‫Entonces, si hubo un error y

80
00:03:38,300 --> 00:03:40,530
‫esto es similar a lo que hicimos antes.

81
00:03:40,530 --> 00:03:42,520
‫Entonces, si hubo un error

82
00:03:42,520 --> 00:03:45,170
‫aquí, llame a la función de rechazo.

83
00:03:45,170 --> 00:03:47,770
‫Y todo lo que pasemos a este

84
00:03:47,770 --> 00:03:50,310
‫será el error que luego

85
00:03:50,310 --> 00:03:52,930
‫estará disponible en el método de captura.

86
00:03:52,930 --> 00:03:54,810
‫Entonces, en este de aquí.

87
00:03:54,810 --> 00:03:56,110
‫¿Okey?

88
00:03:56,110 --> 00:03:58,673
‫Así que pasemos una cadena

89
00:04:00,200 --> 00:04:05,060
‫aquí, no pude encontrar ese archivo, algunos emoji aquí tal vez

90
00:04:05,060 --> 00:04:08,480
‫para que aparezca un poco más en

91
00:04:08,480 --> 00:04:11,030
‫nuestra consola. registros, ¿de acuerdo?

92
00:04:11,030 --> 00:04:11,993
‫Y esta bien.

93
00:04:11,993 --> 00:04:14,070
‫Eso ya es todo.

94
00:04:14,070 --> 00:04:15,940
‫Entonces, repasemos esto aquí nuevamente.

95
00:04:15,940 --> 00:04:17,850
‫Entonces creamos un nuevo

96
00:04:17,850 --> 00:04:21,080
‫archivo, allí pasaremos un nombre de archivo.

97
00:04:21,080 --> 00:04:22,200
‫Entonces este argumento.

98
00:04:22,200 --> 00:04:25,580
‫Y todo lo que hacemos aquí es devolver esta promesa.

99
00:04:25,580 --> 00:04:29,160
‫Esta promesa incluye una función ejecutora, así que

100
00:04:29,160 --> 00:04:30,560
‫esta aquí,

101
00:04:30,560 --> 00:04:34,040
‫que es donde hacemos nuestro trabajo asincrónico.

102
00:04:34,040 --> 00:04:36,110
‫En ese caso aquí, por supuesto, es nuestro

103
00:04:36,110 --> 00:04:36,943
‫fs. readfile.

104
00:04:38,500 --> 00:04:41,250
‫Luego, si obtenemos nuestros datos correctamente, llamamos a

105
00:04:41,250 --> 00:04:42,810
‫la función de

106
00:04:42,810 --> 00:04:44,950
‫resolución con el valor de resolución.

107
00:04:44,950 --> 00:04:46,290
‫Y si hay un

108
00:04:46,290 --> 00:04:49,040
‫error, llamamos a la función de rechazo, ¿de acuerdo?

109
00:04:49,040 --> 00:04:52,560
‫Y ahora vamos a usar esto en la práctica.

110
00:04:52,560 --> 00:04:55,030
‫Read file pro, pasamos nuestro

111
00:04:55,030 --> 00:04:57,490
‫nombre de archivo.

112
00:04:57,490 --> 00:04:58,890
‫Así que ese es este, por

113
00:05:00,020 --> 00:05:01,300
‫supuesto, y eso es todo.

114
00:05:01,300 --> 00:05:03,460
‫Entonces esto ahora devolverá una promesa.

115
00:05:03,460 --> 00:05:04,980
‫Y así, al igual

116
00:05:04,980 --> 00:05:08,203
‫que antes, podemos usar nuestro método then en eso.

117
00:05:11,670 --> 00:05:14,930
‫De acuerdo, este argumento de datos aquí será exactamente

118
00:05:14,930 --> 00:05:17,890
‫lo que devolvimos de la promesa en caso

119
00:05:17,890 --> 00:05:19,510
‫de que tuviera éxito.

120
00:05:19,510 --> 00:05:21,540
‫Entonces, con esta determinación.

121
00:05:21,540 --> 00:05:23,740
‫Entonces, en este momento, nuestro archivo

122
00:05:23,740 --> 00:05:25,540
‫de perro aquí contiene

123
00:05:25,540 --> 00:05:29,440
‫labrador y, por lo tanto, estos datos aquí serán labrador.

124
00:05:29,440 --> 00:05:31,280
‫Y eso está disponible más adelante en

125
00:05:31,280 --> 00:05:32,737
‫nuestro controlador de entonces aquí.

126
00:05:32,737 --> 00:05:36,230
‫Pero, por supuesto, no necesita tener el mismo nombre,

127
00:05:36,230 --> 00:05:38,670
‫también podría llamarlo como resultado

128
00:05:38,670 --> 00:05:41,300
‫o algo que no importe, ¿de acuerdo?

129
00:05:41,300 --> 00:05:44,080
‫Bien, ahora tomemos todo esto y

130
00:05:44,920 --> 00:05:46,463
‫pongámoslo aquí.

131
00:05:48,270 --> 00:05:49,103
‫Bueno.

132
00:05:49,103 --> 00:05:52,000
‫Deshazte de todo esto, guárdalo y

133
00:05:52,000 --> 00:05:53,720
‫eso lo ejecutará.

134
00:05:53,720 --> 00:05:55,520
‫Ahora tenemos ese error aquí, por lo

135
00:05:55,520 --> 00:05:57,100
‫que los datos no están definidos.

136
00:05:57,100 --> 00:05:59,480
‫Eso es porque lo cambié aquí a un resultado.

137
00:05:59,480 --> 00:06:02,210
‫Así que regresemos y cambiemos a datos porque aquí

138
00:06:02,210 --> 00:06:03,270
‫tenemos datos y aquí

139
00:06:03,270 --> 00:06:04,300
‫tenemos datos

140
00:06:04,300 --> 00:06:06,610
‫y de esta manera no tengo que

141
00:06:06,610 --> 00:06:09,210
‫seguir adelante y cambiar todos estos nombres de variables.

142
00:06:09,210 --> 00:06:10,690
‫Dale otra salvada y

143
00:06:10,690 --> 00:06:12,080
‫aquí vamos.

144
00:06:12,080 --> 00:06:13,460
‫Así que funcionó, ¿ves?

145
00:06:13,460 --> 00:06:15,150
‫De hecho, obtuvimos la raza,

146
00:06:15,150 --> 00:06:16,720
‫que todavía es

147
00:06:16,720 --> 00:06:19,870
‫labrador y esta vez de nuestra promesa, está bien.

148
00:06:19,870 --> 00:06:21,150
‫Entonces, esto realmente funcionó.

149
00:06:21,150 --> 00:06:23,290
‫Entonces, nuestra función read file

150
00:06:23,290 --> 00:06:24,890
‫pro ahora devuelve

151
00:06:24,890 --> 00:06:29,890
‫una promesa y esos datos aquí están disponibles en nuestro controlador de entonces.

152
00:06:29,910 --> 00:06:31,660
‫Genial, ya está funcionando y

153
00:06:31,660 --> 00:06:33,110
‫podemos mejorarlo mucho y

154
00:06:33,110 --> 00:06:33,943
‫lo

155
00:06:33,943 --> 00:06:36,487
‫haremos, pero por ahora también quiero prometer

156
00:06:36,487 --> 00:06:39,170
‫esta función de escritura de archivo aquí.

157
00:06:39,170 --> 00:06:40,580
‫Básicamente, hagamos lo mismo que

158
00:06:40,580 --> 00:06:42,520
‫hicimos con la función de lectura de archivos.

159
00:06:42,520 --> 00:06:45,110
‫Ahora, si ya sabe un poco acerca

160
00:06:45,110 --> 00:06:49,000
‫de no js, tal vez esté pensando que en realidad hay

161
00:06:49,000 --> 00:06:52,090
‫un nodo de función que nos promete funciones automáticamente.

162
00:06:52,090 --> 00:06:54,300
‫Pero, por supuesto, quería mostrarles aquí

163
00:06:54,300 --> 00:06:56,130
‫cómo funcionan realmente las promesas

164
00:06:56,130 --> 00:06:57,320
‫y cómo las

165
00:06:57,320 --> 00:07:01,270
‫construimos, por eso es que estoy haciendo todo esto aquí, está bien.

166
00:07:01,270 --> 00:07:03,860
‫Así que realmente quiero que aprendas sobre las promesas,

167
00:07:03,860 --> 00:07:05,410
‫no solo cómo las consumimos,

168
00:07:05,410 --> 00:07:06,710
‫sino también cómo construirlas.

169
00:07:06,710 --> 00:07:08,733
‫Y por eso lo hago de esta manera.

170
00:07:11,170 --> 00:07:14,913
‫Entonces, escriba el archivo y como una promesa.

171
00:07:16,720 --> 00:07:19,460
‫Y este en realidad no solo necesita el nombre

172
00:07:19,460 --> 00:07:22,993
‫del archivo, sino también los datos que deben escribirse en ese archivo.

173
00:07:25,350 --> 00:07:27,460
‫Pero entonces la lógica aquí es bastante similar.

174
00:07:27,460 --> 00:07:30,253
‫Entonces, nuevamente, devolvemos una nueva promesa,

175
00:07:31,760 --> 00:07:34,230
‫allí tenemos nuestra función

176
00:07:34,230 --> 00:07:37,823
‫ejecutora que toma resolver y rechazar como argumento.

177
00:07:39,090 --> 00:07:40,470
‫Y estos son

178
00:07:40,470 --> 00:07:41,860
‫nombres estándar. Resuélvalos y

179
00:07:41,860 --> 00:07:44,000
‫rechácelos. Podrías llamarlos como realmente quisieras,

180
00:07:44,000 --> 00:07:46,463
‫pero este es el estándar, está bien.

181
00:07:47,780 --> 00:07:48,613
‫Entonces fs,

182
00:07:50,211 --> 00:07:51,044
‫escribe el

183
00:07:52,870 --> 00:07:54,390
‫archivo, pasamos el archivo, los

184
00:07:54,390 --> 00:07:57,523
‫datos y luego la función de devolución de llamada.

185
00:07:58,580 --> 00:08:01,260
‫Y ahora algo muy similar a antes, así

186
00:08:01,260 --> 00:08:02,800
‫que si hubo un

187
00:08:02,800 --> 00:08:05,570
‫error, entonces llame a la función de rechazo

188
00:08:05,570 --> 00:08:07,473
‫y pase algún mensaje allí.

189
00:08:10,550 --> 00:08:12,340
‫No se pudo escribir

190
00:08:12,340 --> 00:08:16,060
‫el archivo, nuevamente con este emoji aquí para que se destaque

191
00:08:16,060 --> 00:08:18,870
‫un poco más y en caso de que

192
00:08:18,870 --> 00:08:20,830
‫todo funcione bien, entonces resuélvalo.

193
00:08:20,830 --> 00:08:24,960
‫Ahora no tenemos ningún dato para pasar aquí, ¿verdad?

194
00:08:24,960 --> 00:08:27,940
‫Así que vamos a pasar una cadena

195
00:08:27,940 --> 00:08:30,920
‫aleatoria, algo como decir éxito, está bien.

196
00:08:30,920 --> 00:08:32,770
‫Por lo tanto, una

197
00:08:32,770 --> 00:08:36,000
‫promesa no siempre tiene que devolver un valor significativo.

198
00:08:36,000 --> 00:08:38,060
‫En este caso, todo lo que realmente

199
00:08:38,060 --> 00:08:39,030
‫estamos tratando de

200
00:08:39,030 --> 00:08:42,340
‫hacer aquí es escribir un archivo que realmente no devuelva un valor significativo.

201
00:08:42,340 --> 00:08:46,290
‫Así que ahora estamos listos para usar esta función prometida,

202
00:08:46,290 --> 00:08:47,280
‫pero

203
00:08:47,280 --> 00:08:49,640
‫antes de hacerlo, implementemos el encadenamiento

204
00:08:49,640 --> 00:08:51,750
‫del que les hablé antes.

205
00:08:51,750 --> 00:08:52,780
‫Entonces, en

206
00:08:52,780 --> 00:08:56,170
‫este momento, todavía tenemos devoluciones de llamada dentro de devoluciones de

207
00:08:56,170 --> 00:08:58,290
‫llamada dentro de devoluciones de llamada, ¿verdad?

208
00:08:58,290 --> 00:08:59,550
‫Entonces tenemos esto, que

209
00:08:59,550 --> 00:09:00,930
‫tiene esta devolución de llamada.

210
00:09:00,930 --> 00:09:03,800
‫Y luego hay otro controlador que

211
00:09:03,800 --> 00:09:06,470
‫tiene otra devolución de llamada.

212
00:09:06,470 --> 00:09:09,230
‫Entonces eso realmente no cambia nada, ¿verdad?

213
00:09:09,230 --> 00:09:12,697
‫En su lugar, queremos encadenar estos controladores aquí.

214
00:09:12,697 --> 00:09:14,090
‫Y el secreto para

215
00:09:14,090 --> 00:09:17,670
‫hacer eso es hacer que cada controlador devuelva una nueva promesa.

216
00:09:17,670 --> 00:09:19,280
‫Entonces, ¿cómo vamos a hacer eso?

217
00:09:19,280 --> 00:09:24,280
‫Bueno, recuerde que esta función aquí devuelve una promesa.

218
00:09:24,760 --> 00:09:26,230
‫Entonces, todo lo que tenemos

219
00:09:26,230 --> 00:09:29,290
‫que hacer es devolver esa promesa de este primero y luego manejador.

220
00:09:29,290 --> 00:09:30,490
‫Déjame mostrarte eso.

221
00:09:32,370 --> 00:09:35,260
‫Entonces decimos volver superagente. get y luego

222
00:09:35,260 --> 00:09:38,630
‫la cadena y eso ahora es una promesa, está bien.

223
00:09:38,630 --> 00:09:41,920
‫Y luego cerramos esta función de devolución

224
00:09:41,920 --> 00:09:46,520
‫de llamada aquí y encadenamos este método directamente a ella.

225
00:09:46,520 --> 00:09:49,400
‫Salvarlo, ahora tenemos algún error aquí y eso

226
00:09:49,400 --> 00:09:51,830
‫está en la línea 40.

227
00:09:51,830 --> 00:09:53,780
‫Deshagámonos de esto aquí y

228
00:09:53,780 --> 00:09:54,913
‫está bien.

229
00:09:55,760 --> 00:09:57,730
‫Cambió el formato aquí para

230
00:09:57,730 --> 00:09:59,200
‫nosotros nuevamente, que

231
00:09:59,200 --> 00:10:02,700
‫era más bonito y luego ya lo tenemos funcionando aquí.

232
00:10:02,700 --> 00:10:04,420
‫Entonces, ¿por qué funciona esto de nuevo?

233
00:10:04,420 --> 00:10:06,800
‫Bueno, por supuesto, esta función que creamos

234
00:10:06,800 --> 00:10:09,130
‫al principio devuelve una promesa.

235
00:10:09,130 --> 00:10:11,840
‫Entonces, podemos usar el método then.

236
00:10:11,840 --> 00:10:14,440
‫Luego hacemos que esta función de devolución de llamada que

237
00:10:14,440 --> 00:10:16,690
‫está en ella nuevamente devuelva una promesa.

238
00:10:16,690 --> 00:10:18,530
‫Y así podemos

239
00:10:18,530 --> 00:10:21,150
‫encadenar al siguiente controlador en eso.

240
00:10:21,150 --> 00:10:22,860
‫Entonces, esta variable de

241
00:10:22,860 --> 00:10:25,760
‫resultado aquí será el valor resuelto de

242
00:10:25,760 --> 00:10:29,170
‫esta promesa que regresó del controlador anterior, ¿de acuerdo?

243
00:10:29,170 --> 00:10:30,750
‫¿Tiene sentido?

244
00:10:30,750 --> 00:10:33,020
‫Ahora, para dar un paso más,

245
00:10:33,020 --> 00:10:33,990
‫seguiremos adelante

246
00:10:33,990 --> 00:10:38,423
‫y usaremos nuestra función de escritura de archivos pro aquí ahora también.

247
00:10:39,350 --> 00:10:41,980
‫Y como queremos seguir encadenando los métodos

248
00:10:41,980 --> 00:10:44,190
‫then, lo devolveremos de nuevo.

249
00:10:44,190 --> 00:10:48,163
‫Así que regrese, escriba file pro pass en el

250
00:10:50,420 --> 00:10:53,513
‫nombre del archivo, que es este, los

251
00:10:55,840 --> 00:10:57,070
‫datos ...

252
00:11:00,210 --> 00:11:01,360
‫Y eso es todo.

253
00:11:03,460 --> 00:11:06,600
‫Bien, ya no necesitamos nada de esto aquí,

254
00:11:06,600 --> 00:11:08,250
‫solo comentémoslo por ahora.

255
00:11:09,880 --> 00:11:11,650
‫Deshazte de este espacio

256
00:11:11,650 --> 00:11:14,973
‫aquí y luego allá podemos encadenar el siguiente controlador.

257
00:11:16,010 --> 00:11:18,230
‫Entonces, y recuerde que

258
00:11:18,230 --> 00:11:21,950
‫aquí en realidad no teníamos ningún valor resuelto significativo.

259
00:11:21,950 --> 00:11:24,240
‫Entonces, no queremos ningún argumento

260
00:11:24,240 --> 00:11:26,580
‫para esta función de devolución de

261
00:11:26,580 --> 00:11:31,433
‫llamada aquí, todo lo que queremos hacer es registrar esta cadena, ¿verdad?

262
00:11:32,640 --> 00:11:34,970
‫Así que ahora realmente podemos deshacernos de

263
00:11:36,450 --> 00:11:37,920
‫esto y está bien.

264
00:11:37,920 --> 00:11:39,490
‫Entonces, aquí abajo vemos ahora

265
00:11:39,490 --> 00:11:41,090
‫que en realidad ya está funcionando.

266
00:11:41,090 --> 00:11:43,080
‫Y nuevamente, el truco para

267
00:11:43,080 --> 00:11:46,050
‫poder encadenar todos estos métodos aquí es devolver

268
00:11:46,050 --> 00:11:49,360
‫una promesa antes de llamar a cada uno de ellos.

269
00:11:49,360 --> 00:11:52,360
‫Así que este aquí obviamente devuelve una promesa aquí para

270
00:11:52,360 --> 00:11:55,320
‫que podamos encadenar el método then en él.

271
00:11:55,320 --> 00:11:56,860
‫Entonces este fragmento de

272
00:11:56,860 --> 00:11:58,110
‫código aquí

273
00:11:58,110 --> 00:12:00,630
‫devolverá una promesa y entonces podemos usarlo.

274
00:12:00,630 --> 00:12:02,920
‫Entonces este fragmento de código

275
00:12:02,920 --> 00:12:07,320
‫devolverá una promesa y entonces podremos usarlo de nuevo, ¿de acuerdo?

276
00:12:07,320 --> 00:12:09,010
‫Así que ese es el secreto.

277
00:12:09,010 --> 00:12:10,380
‫Vuelve a salvarlo

278
00:12:10,380 --> 00:12:13,500
‫y aquí abajo vemos que la raza sigue siendo labrador.

279
00:12:13,500 --> 00:12:16,640
‫Vemos que esto aquí es el enlace, vayamos

280
00:12:16,640 --> 00:12:19,180
‫aquí y confirmemos que esto es

281
00:12:19,180 --> 00:12:21,300
‫realmente lo mismo que esto.

282
00:12:21,300 --> 00:12:26,050
‫Y así escribió con éxito la cadena en el archivo de texto

283
00:12:26,050 --> 00:12:30,717
‫usando nuestra función de archivo de escritura promisificada, de acuerdo.

284
00:12:30,717 --> 00:12:34,240
‫Y luego, al final, tenemos este controlador de errores.

285
00:12:34,240 --> 00:12:38,060
‫Y la belleza aquí es que para todas estas cadenas

286
00:12:38,060 --> 00:12:39,430
‫y luego manipuladores

287
00:12:39,430 --> 00:12:43,020
‫al final, simplemente necesitamos un solo manipulador de capturas.

288
00:12:43,020 --> 00:12:44,980
‫Entonces, una función que maneja

289
00:12:44,980 --> 00:12:48,910
‫los errores provenientes de cualquiera de las tres promesas, está bien.

290
00:12:48,910 --> 00:12:52,090
‫De hecho, solo registremos el error en la

291
00:12:52,090 --> 00:12:53,900
‫consola e intentemos, por

292
00:12:53,900 --> 00:12:56,160
‫ejemplo, cambiar este archivo aquí.

293
00:12:56,160 --> 00:12:57,980
‫En realidad no es

294
00:12:57,980 --> 00:13:01,940
‫el archivo, pero voy a cambiar el nombre del archivo

295
00:13:01,940 --> 00:13:06,150
‫aquí, guardarlo y ahora vemos que no pude encontrar ese archivo.

296
00:13:06,150 --> 00:13:07,970
‫Entonces, ¿de dónde viene eso?

297
00:13:07,970 --> 00:13:09,720
‫Viene aquí desde

298
00:13:09,720 --> 00:13:13,410
‫llamar a la función de rechazo, ¿de acuerdo?

299
00:13:13,410 --> 00:13:16,320
‫Tenemos un error aquí porque no pudimos encontrar el archivo

300
00:13:16,320 --> 00:13:18,890
‫y llamamos a la función de rechazo.

301
00:13:18,890 --> 00:13:22,600
‫Y esa función de rechazo marcará esta promesa aquí, así que recuerde

302
00:13:23,850 --> 00:13:25,720
‫que esta es una promesa.

303
00:13:25,720 --> 00:13:27,780
‫Lo marcará como rechazado.

304
00:13:27,780 --> 00:13:30,870
‫Y por lo tanto, se llama a la función de captura.

305
00:13:30,870 --> 00:13:33,260
‫Y entonces registramos ese error en la consola.

306
00:13:33,260 --> 00:13:36,313
‫Y el resultado de eso es lo que puedes ver aquí abajo.

307
00:13:37,360 --> 00:13:40,830
‫Bien, volvamos a ponerlo ahora que

308
00:13:40,830 --> 00:13:41,900
‫funciona.

309
00:13:41,900 --> 00:13:43,920
‫Ahora vayamos al archivo, creemos un

310
00:13:43,920 --> 00:13:45,880
‫perro que no existe y

311
00:13:50,010 --> 00:13:54,320
‫ahora, oh, aquí tenemos este gran error extraño y eso es porque simplemente

312
00:13:54,320 --> 00:13:57,583
‫estamos registrando el error completo y no el mensaje

313
00:13:57,583 --> 00:14:00,700
‫de error como lo estábamos haciendo antes, pero no

314
00:14:00,700 --> 00:14:01,723
‫no importa.

315
00:14:03,500 --> 00:14:05,203
‫Ahora dale un guardado aquí

316
00:14:06,170 --> 00:14:07,220
‫ahora, devuélvelo

317
00:14:07,220 --> 00:14:08,500
‫y está bien.

318
00:14:08,500 --> 00:14:10,210
‫Así que ahora todo está

319
00:14:10,210 --> 00:14:12,510
‫funcionando y nos deshicimos de esa forma

320
00:14:12,510 --> 00:14:14,040
‫triangular que teníamos

321
00:14:14,040 --> 00:14:18,420
‫en nuestro código y ahora tenemos una estructura plana de promesas en cadena.

322
00:14:18,420 --> 00:14:20,600
‫Nuevamente, esto es mucho más

323
00:14:20,600 --> 00:14:23,150
‫fácil de administrar y espero que puedas comenzar

324
00:14:23,150 --> 00:14:25,430
‫a apreciarlo y también es más lógico

325
00:14:25,430 --> 00:14:28,120
‫pensar y razonar sobre el código de esta manera.

326
00:14:28,120 --> 00:14:29,270
‫Ahora, en

327
00:14:29,270 --> 00:14:31,660
‫la próxima lección, daremos un paso más

328
00:14:31,660 --> 00:14:33,570
‫y lo haremos aún más legible

329
00:14:33,570 --> 00:14:35,210
‫y más fácil de usar.

330
00:14:35,210 --> 00:14:36,783
‫Así que estad atentos a eso.