1
00:00:01,830 --> 00:00:03,030
‫Instructor: ¡Bienvenido de nuevo!

2
00:00:03,030 --> 00:00:06,790
‫En este video, vamos a leer archivos y

3
00:00:06,790 --> 00:00:11,063
‫escribir dos archivos como antes, pero en cambio de forma asincrónica.

4
00:00:13,160 --> 00:00:14,960
‫Agreguemos algunos comentarios aquí antes.

5
00:00:19,630 --> 00:00:21,183
‫Entonces, esta

6
00:00:26,160 --> 00:00:31,160
‫es la forma bloqueante, sincrónica, y luego, haremos un

7
00:00:32,870 --> 00:00:36,480
‫ejercicio de forma no bloqueante, asincrónica.

8
00:00:36,480 --> 00:00:38,230
‫Entonces, no vamos a

9
00:00:38,230 --> 00:00:40,300
‫hacer lo mismo, solo vamos

10
00:00:40,300 --> 00:00:43,150
‫a inventar otro tipo de ejercicio loco aquí.

11
00:00:43,150 --> 00:00:46,350
‫Entonces, para leer un archivo de forma

12
00:00:46,350 --> 00:00:48,410
‫asincrónica, funciona así.

13
00:00:48,410 --> 00:00:53,380
‫Nuevamente, necesitamos el módulo FS, y luego leer el archivo, pero esta vez, no

14
00:00:54,890 --> 00:00:57,920
‫leer la sincronización del archivo, por supuesto.

15
00:00:57,920 --> 00:01:01,930
‫Y, nuevamente, pasamos el nombre del archivo, o la ruta

16
00:01:01,930 --> 00:01:04,060
‫al archivo en realidad, y

17
00:01:04,060 --> 00:01:07,360
‫nuevamente, es txt, y el archivo que quiero

18
00:01:07,360 --> 00:01:11,583
‫ahora se llama inicio. txt,

19
00:01:12,460 --> 00:01:14,603
‫entonces este.

20
00:01:16,040 --> 00:01:17,860
‫Ups, perdón por eso.

21
00:01:17,860 --> 00:01:21,790
‫Entonces, este es el archivo que quiero, en la tarea lee esto, y

22
00:01:21,790 --> 00:01:24,660
‫te explicaré por qué un poco más tarde.

23
00:01:24,660 --> 00:01:26,860
‫Por ahora, no se preocupe por el contenido aquí.

24
00:01:28,220 --> 00:01:29,360
‫Entonces, en el

25
00:01:29,360 --> 00:01:34,360
‫archivo leído, en realidad no tenemos que especificar la codificación del archivo, está bien.

26
00:01:34,580 --> 00:01:36,090
‫Y así, el siguiente

27
00:01:36,090 --> 00:01:39,500
‫parámetro, el segundo será una función de devolución de llamada, y

28
00:01:39,500 --> 00:01:42,270
‫eso es lo que aprendimos en la última lección.

29
00:01:42,270 --> 00:01:45,380
‫Entonces, Node JS se basa en devoluciones

30
00:01:45,380 --> 00:01:48,750
‫de llamada para implementar un comportamiento asincrónico, y así

31
00:01:48,750 --> 00:01:50,200
‫es como funciona.

32
00:01:50,200 --> 00:01:53,080
‫Entonces, Node comenzará a leer este archivo

33
00:01:53,080 --> 00:01:56,470
‫aquí en segundo plano, y tan pronto como esté

34
00:01:56,470 --> 00:02:00,543
‫listo, iniciará la función de devolución de llamada que especificamos aquí.

35
00:02:03,880 --> 00:02:06,730
‫De acuerdo, y llama a esta función de devolución

36
00:02:06,730 --> 00:02:08,450
‫de llamada con dos argumentos.

37
00:02:08,450 --> 00:02:11,440
‫El primero es el error

38
00:02:11,440 --> 00:02:15,560
‫y el segundo son los datos reales, ¿de acuerdo?

39
00:02:15,560 --> 00:02:19,130
‫Entonces, este primer estilo de devolución de llamada de error

40
00:02:19,130 --> 00:02:22,090
‫es muy típico en Node JS, está bien.

41
00:02:22,090 --> 00:02:24,910
‫Entonces, muchas, muchas veces, el primer parámetro

42
00:02:24,910 --> 00:02:28,730
‫en una devolución de llamada será el error, en caso

43
00:02:28,730 --> 00:02:33,060
‫de que haya alguno, y el segundo serán los datos en sí.

44
00:02:33,060 --> 00:02:34,403
‫Lo que importa

45
00:02:34,403 --> 00:02:38,610
‫aquí es que el error suele ser siempre el primero, ¿de acuerdo?

46
00:02:38,610 --> 00:02:41,740
‫Entonces, solo para probarlo por ahora,

47
00:02:41,740 --> 00:02:46,740
‫simplemente iniciemos sesión a través de la consola, los datos.

48
00:02:47,100 --> 00:02:50,050
‫Entonces, ahora probemos eso.

49
00:02:50,050 --> 00:02:51,520
‫Pero, antes de

50
00:02:51,520 --> 00:02:55,793
‫hacer esto, sigamos especificando la codificación de archivo aquí, ¿de acuerdo?

51
00:02:57,820 --> 00:03:00,160
‫Entonces, no estoy cien por ciento

52
00:03:00,160 --> 00:03:01,933
‫seguro de que funcione

53
00:03:04,190 --> 00:03:09,190
‫sin esto, así que limpie esto ahora, ejecútelo nuevamente, y aquí vemos leer esto.

54
00:03:10,400 --> 00:03:13,790
‫Entonces, analicemos, nuevamente, lo que sucedió aquí.

55
00:03:13,790 --> 00:03:17,260
‫Tan pronto como se ejecute esta función, comenzará

56
00:03:17,260 --> 00:03:20,980
‫a leer este archivo en segundo plano sin bloquear

57
00:03:20,980 --> 00:03:24,083
‫el resto de la ejecución del código.

58
00:03:24,970 --> 00:03:27,663
‫Entonces, permítanme demostrar esto aquí.

59
00:03:29,290 --> 00:03:30,690
‫Entonces, una consola. log

60
00:03:33,370 --> 00:03:38,370
‫leerá el archivo, y para tener un poco menos de

61
00:03:38,530 --> 00:03:43,170
‫confusión, permítanme comentar esta parte aquí, está bien.

62
00:03:43,170 --> 00:03:45,970
‫Entonces, ¿qué crees que pasará ahora?

63
00:03:45,970 --> 00:03:48,533
‫¿Qué registro vamos a ver primero?

64
00:03:51,830 --> 00:03:55,060
‫Y, de hecho, primero vemos will

65
00:03:55,060 --> 00:03:58,470
‫read file y, solo entonces, vemos leer esto.

66
00:03:58,470 --> 00:04:00,960
‫Entonces, nuevamente, ¿por qué sucedió eso?

67
00:04:00,960 --> 00:04:04,400
‫Entonces, como mencioné, Node JS comenzará a leer el

68
00:04:04,400 --> 00:04:07,570
‫archivo en segundo plano aquí, y no bloqueará

69
00:04:07,570 --> 00:04:11,760
‫el código, y luego pasará inmediatamente a la siguiente línea de código.

70
00:04:11,760 --> 00:04:15,240
‫Y, la siguiente línea de código, bueno, es este registro aquí,

71
00:04:15,240 --> 00:04:17,030
‫y eso es lo primero

72
00:04:17,030 --> 00:04:19,520
‫que se registrará aquí en la terminal.

73
00:04:19,520 --> 00:04:22,760
‫Solo entonces, cuando un archivo se lea por

74
00:04:22,760 --> 00:04:26,580
‫completo, esta función de devolución de llamada se ejecutará, ¿de acuerdo?

75
00:04:26,580 --> 00:04:30,810
‫Y nuevamente, esta función de devolución de llamada tiene acceso al error y

76
00:04:30,810 --> 00:04:33,070
‫a los datos que se leyeron,

77
00:04:33,070 --> 00:04:36,260
‫y realmente podríamos llamar a esto aquí como queramos.

78
00:04:36,260 --> 00:04:39,250
‫También podríamos llamarlo texto, realmente no importa, todo lo que

79
00:04:39,250 --> 00:04:42,240
‫importa es que es el segundo argumento en esta función

80
00:04:42,240 --> 00:04:43,713
‫de devolución de llamada.

81
00:04:44,670 --> 00:04:47,070
‫De hecho, volvamos a los

82
00:04:47,070 --> 00:04:49,740
‫datos porque me gusta más esa forma.

83
00:04:49,740 --> 00:04:54,740
‫Y así, solo entonces, esta consola. log se ejecutará con los datos, es

84
00:04:54,900 --> 00:04:57,510
‫decir, con el texto que estaba en el archivo.

85
00:04:57,510 --> 00:05:01,480
‫Entonces, es por eso que vemos esto aquí como el segundo registro.

86
00:05:01,480 --> 00:05:04,430
‫Muy bien, ahora para ir más

87
00:05:04,430 --> 00:05:08,860
‫allá, hagamos otro archivo de lectura, pero en lugar de esto,

88
00:05:08,860 --> 00:05:11,990
‫para que pueda mostrarles que básicamente podemos

89
00:05:11,990 --> 00:05:16,130
‫hacer varios pasos, uno tras otro, con devoluciones de llamada.

90
00:05:16,130 --> 00:05:20,810
‫Entonces, pasos que dependen del resultado del paso anterior.

91
00:05:20,810 --> 00:05:25,310
‫Bien, es por eso que en realidad en el archivo de inicio,

92
00:05:25,310 --> 00:05:26,610
‫he leído

93
00:05:26,610 --> 00:05:29,930
‫esto porque luego hay un archivo llamado leer esto,

94
00:05:29,930 --> 00:05:33,103
‫que tiene el contenido que realmente nos interesa.

95
00:05:34,090 --> 00:05:34,923
‫¿Okey?

96
00:05:37,060 --> 00:05:39,963
‫Entonces, lo que voy a hacer aquí es copiar

97
00:05:40,890 --> 00:05:42,793
‫este código y ponerlo aquí.

98
00:05:44,740 --> 00:05:48,210
‫Llamaré a este dato uno, y luego dato dos,

99
00:05:48,210 --> 00:05:52,900
‫y el resultado del segundo paso, por lo que la lectura del

100
00:05:52,900 --> 00:05:55,140
‫segundo archivo dependerá del primero.

101
00:05:55,140 --> 00:06:00,140
‫Eso es porque usaremos los datos para el nombre del archivo, ¿recuerdas?

102
00:06:02,030 --> 00:06:05,340
‫Entonces, aquí estamos haciendo un (murmullos) ahora

103
00:06:06,290 --> 00:06:10,730
‫porque necesitamos poner esa variable, y se llama datos

104
00:06:14,490 --> 00:06:15,323
‫uno.

105
00:06:16,330 --> 00:06:18,290
‫Vale, ¿tiene sentido?

106
00:06:18,290 --> 00:06:22,900
‫Entonces, el dato uno se leerá esto, está bien, y luego, en el

107
00:06:22,900 --> 00:06:27,900
‫siguiente paso, leemos txt / readthis. txt, que es

108
00:06:30,090 --> 00:06:31,910
‫entonces este.

109
00:06:31,910 --> 00:06:35,110
‫De acuerdo, y es por eso que este nombre de archivo aquí

110
00:06:35,110 --> 00:06:37,053
‫es el mismo que este contenido.

111
00:06:39,340 --> 00:06:42,283
‫Y así, eso se registra a través de los datos de la consola.

112
00:06:43,310 --> 00:06:45,833
‫Y, probemos rápidamente si esto funciona, y de hecho,

113
00:06:48,370 --> 00:06:53,370
‫ese es el contenido de leer esto. TXT.

114
00:06:53,860 --> 00:06:57,030
‫Y ahora voy a ir un paso más allá,

115
00:06:57,030 --> 00:07:00,740
‫incluso porque hay otro texto en este archivo adjunto que quiero

116
00:07:00,740 --> 00:07:04,080
‫agregar a esta primera cadena, por lo que hay texto

117
00:07:04,080 --> 00:07:06,420
‫que proviene del otro archivo.

118
00:07:06,420 --> 00:07:08,590
‫Entonces, tenemos otro paso que

119
00:07:08,590 --> 00:07:10,840
‫depende del paso anterior, así que lo

120
00:07:10,840 --> 00:07:14,563
‫que voy a hacer es agregar otro archivo de lectura aquí.

121
00:07:15,560 --> 00:07:17,660
‫Así que, así.

122
00:07:17,660 --> 00:07:19,313
‫Entonces, este se

123
00:07:21,610 --> 00:07:26,610
‫llama adjuntar, y voy a llamar a este datos tres, datos tres aquí,

124
00:07:27,720 --> 00:07:30,133
‫y eso es, nuevamente, ejecutar eso.

125
00:07:32,760 --> 00:07:37,570
‫Y, está bien, ahora tenemos estos dos resultados aquí.

126
00:07:37,570 --> 00:07:40,830
‫Muy bien, y ahora finalmente, como último paso,

127
00:07:40,830 --> 00:07:44,030
‫quiero escribir estas dos cadenas juntas en

128
00:07:44,030 --> 00:07:46,360
‫un archivo, ¿de acuerdo?

129
00:07:46,360 --> 00:07:48,500
‫Hasta ahora, solo hemos

130
00:07:48,500 --> 00:07:51,160
‫leído archivos, pero yo también quiero escribir

131
00:07:51,160 --> 00:07:53,730
‫un archivo, así que hagámoslo aquí también.

132
00:07:53,730 --> 00:07:54,623
‫Entonces, fs.

133
00:07:57,480 --> 00:08:01,100
‫writeFile, y por supuesto, no estamos usando el sincrónico

134
00:08:01,100 --> 00:08:02,140
‫como lo hicimos

135
00:08:02,140 --> 00:08:06,320
‫antes, pero nuevamente usamos, al igual que aquí y aquí

136
00:08:06,320 --> 00:08:10,113
‫y aquí, usamos la versión asincrónica, no la sincrónica.

137
00:08:11,600 --> 00:08:16,600
‫Entonces, txt slash, falta este aquí,

138
00:08:19,240 --> 00:08:20,143
‫final.

139
00:08:22,314 --> 00:08:25,933
‫Luego, deberíamos agregar la codificación de mensajes de texto aquí también, y

140
00:08:29,650 --> 00:08:33,040
‫luego esta también acepta una función de devolución de llamada, pero

141
00:08:33,040 --> 00:08:36,220
‫en este caso no hay datos que leemos, por

142
00:08:36,220 --> 00:08:38,370
‫lo que no necesitamos dos argumentos.

143
00:08:38,370 --> 00:08:41,933
‫Entonces, el único argumento que tenemos es el error, en realidad.

144
00:08:44,100 --> 00:08:48,980
‫Bien, aquí tenemos el error y los datos que se leyeron,

145
00:08:48,980 --> 00:08:52,270
‫pero aquí en writeFile, no hay datos.

146
00:08:52,270 --> 00:08:56,690
‫Todo lo que hay, o puede haber, es un error, ¿de acuerdo?

147
00:08:56,690 --> 00:08:58,530
‫Y de hecho, nos

148
00:08:58,530 --> 00:09:03,063
‫falta algo aquí, que es lo que realmente queremos escribir en el archivo.

149
00:09:03,910 --> 00:09:06,430
‫Bien, y ese es el segundo

150
00:09:06,430 --> 00:09:11,100
‫argumento, y lo que es, son los datos dos y los datos tres.

151
00:09:11,100 --> 00:09:12,823
‫Entonces, nuevamente una cadena

152
00:09:14,340 --> 00:09:16,063
‫(murmura) aquí, datos dos,

153
00:09:17,620 --> 00:09:21,323
‫luego un carácter de nueva línea, que nuevamente, es barra

154
00:09:23,010 --> 00:09:25,523
‫invertida n, y luego datos 3.

155
00:09:27,360 --> 00:09:32,010
‫Muy bien, y así, al igual que con las funciones de lectura de archivos, esta devolución de

156
00:09:32,010 --> 00:09:35,800
‫llamada es lo que se ejecuta al final, así que lo que voy a

157
00:09:35,800 --> 00:09:38,660
‫hacer aquí es simplemente registrar a través de la consola que

158
00:09:38,660 --> 00:09:40,613
‫los archivos se han escrito o que

159
00:09:41,490 --> 00:09:43,190
‫el archivo tiene sido escrito.

160
00:09:44,430 --> 00:09:49,360
‫Su archivo ha sido escrito, y usemos algunos emoji

161
00:09:49,360 --> 00:09:53,220
‫divertidos aquí, solo para hacer que la

162
00:09:53,220 --> 00:09:56,883
‫consola sea un poco más

163
00:09:58,300 --> 00:10:03,080
‫brillante para nosotros, y creo que deberíamos hacerlo así.

164
00:10:03,080 --> 00:10:06,023
‫Entonces, limpiemos la consola una vez más, ejecútela

165
00:10:07,370 --> 00:10:10,560
‫y, de hecho, vemos que su archivo ha sido escrito.

166
00:10:10,560 --> 00:10:11,833
‫Entonces, ¿realmente lo ha hecho?

167
00:10:13,460 --> 00:10:14,990
‫Final.

168
00:10:14,990 --> 00:10:16,433
‫Oh, sí, aquí está.

169
00:10:18,140 --> 00:10:22,040
‫Entonces, esa es la lectura de este texto

170
00:10:22,040 --> 00:10:27,040
‫y el texto adjunto, ambos juntos, ambos en el mismo archivo.

171
00:10:27,490 --> 00:10:32,490
‫Bien, así es como realizamos varios pasos en los pedidos, utilizando

172
00:10:33,160 --> 00:10:36,270
‫funciones de devolución de llamada, ¿verdad?

173
00:10:36,270 --> 00:10:40,180
‫Porque imagina que simplemente hiciste la misma lectura de archivo, y luego la

174
00:10:40,180 --> 00:10:42,490
‫lectura del segundo archivo, así que este,

175
00:10:42,490 --> 00:10:44,060
‫justo después de eso.

176
00:10:44,060 --> 00:10:46,770
‫Bueno, entonces, ¿cómo obtendrías acceso a

177
00:10:46,770 --> 00:10:49,200
‫los datos del primero, verdad?

178
00:10:49,200 --> 00:10:52,420
‫Y así es como surge este patrón.

179
00:10:52,420 --> 00:10:53,720
‫De hecho, tiene su

180
00:10:53,720 --> 00:10:55,930
‫propio nombre, y creo que mencioné que en

181
00:10:55,930 --> 00:10:58,240
‫el último video, es el llamado infierno de

182
00:10:58,240 --> 00:11:01,490
‫devolución de llamada, y hay algunas soluciones para hacer que este código

183
00:11:01,490 --> 00:11:04,080
‫aquí sea más legible y mejor de entender, pero

184
00:11:04,080 --> 00:11:07,130
‫por ahora, eso no es así. importa en absoluto para ti.

185
00:11:07,130 --> 00:11:10,650
‫Lo que importa es que Node JS se basa en

186
00:11:10,650 --> 00:11:13,480
‫esta filosofía de devoluciones de llamada, de modo

187
00:11:13,480 --> 00:11:17,530
‫que así es como Node JS implementa las operaciones asincrónicas, llamando

188
00:11:17,530 --> 00:11:20,330
‫a las devoluciones de llamada tan

189
00:11:20,330 --> 00:11:23,260
‫pronto como finaliza la operación que está haciendo.

190
00:11:23,260 --> 00:11:26,280
‫Y, por cierto, esta forma de escribir la función que

191
00:11:26,280 --> 00:11:28,110
‫ves aquí, nuevamente, en caso de

192
00:11:28,110 --> 00:11:29,870
‫que no estés familiarizado

193
00:11:29,870 --> 00:11:33,420
‫con ella, también es la nueva sintaxis de ES6, ¿de acuerdo?

194
00:11:33,420 --> 00:11:36,320
‫Entonces, nuevamente, espero que esté familiarizado con

195
00:11:36,320 --> 00:11:38,550
‫ES6 en este punto, y

196
00:11:38,550 --> 00:11:41,950
‫para que todo esto tenga mucho sentido para usted.

197
00:11:41,950 --> 00:11:44,580
‫Si escribiera esta función aquí

198
00:11:45,700 --> 00:11:49,461
‫sin la sintaxis de la función de

199
00:11:49,461 --> 00:11:54,461
‫error, lo haríamos simplemente así, función, err, dato uno, y

200
00:11:55,950 --> 00:11:57,600
‫luego así.

201
00:11:57,600 --> 00:11:59,470
‫Entonces, esa es una

202
00:11:59,470 --> 00:12:02,210
‫función normal, digamos una función pasada

203
00:12:02,210 --> 00:12:05,470
‫de moda, y la nueva versión funciona así.

204
00:12:05,470 --> 00:12:09,490
‫La diferencia entre ellos es principalmente la sintaxis, pero también el hecho de

205
00:12:09,490 --> 00:12:12,690
‫que una función de error, por lo que este tipo

206
00:12:12,690 --> 00:12:14,360
‫de función, no obtiene

207
00:12:14,360 --> 00:12:17,070
‫su propia palabra clave de disco, por lo

208
00:12:17,070 --> 00:12:20,860
‫que usa la palabra clave de disco de la función principal.

209
00:12:20,860 --> 00:12:24,540
‫Y eso se llama la palabra clave léxica de disco,

210
00:12:24,540 --> 00:12:27,500
‫mientras que una función normal como esta

211
00:12:27,500 --> 00:12:30,920
‫siempre obtiene su propia palabra clave de disco, ¿verdad?

212
00:12:30,920 --> 00:12:33,610
‫Estoy seguro de que está familiarizado con ese tipo de

213
00:12:33,610 --> 00:12:37,640
‫cosas, pero solo haga una pequeña revisión aquí en caso de que no lo esté.

214
00:12:37,640 --> 00:12:39,673
‫Está bien, espero que se haya hecho desde entonces.

215
00:12:40,600 --> 00:12:44,150
‫En realidad, nunca usamos este error, no manejamos

216
00:12:44,150 --> 00:12:46,160
‫ningún error, así que,

217
00:12:46,160 --> 00:12:50,060
‫por ejemplo, imagine que este archivo aquí no existe.

218
00:12:50,060 --> 00:12:52,490
‫Bueno, podríamos haber usado este error,

219
00:12:52,490 --> 00:12:56,300
‫y de hecho hagámoslo, pero solo para este aquí, así que

220
00:12:56,300 --> 00:13:00,820
‫no quiero crear todos estos controladores de errores aquí, pero solo en esta

221
00:13:00,820 --> 00:13:04,100
‫situación, digamos que hubo un error, y así digamos

222
00:13:04,100 --> 00:13:06,463
‫si hay un error, el retorno

223
00:13:07,340 --> 00:13:10,373
‫de esta función, así que no haga nada

224
00:13:12,290 --> 00:13:13,743
‫más, e inicie

225
00:13:18,050 --> 00:13:22,260
‫sesión en la consola, error, y luego podemos agregar algún otro emoji

226
00:13:22,260 --> 00:13:25,653
‫aquí, como esta explosión, así que algo explotó aquí.

227
00:13:28,010 --> 00:13:32,933
‫Entonces, cambiemos esto aquí, como comenzar. txt, ejecute esto nuevamente, y entonces,

228
00:13:33,900 --> 00:13:34,973
‫tenemos este

229
00:13:36,090 --> 00:13:39,980
‫error ahora, por lo que nos da este registro a

230
00:13:39,980 --> 00:13:42,570
‫la consola, y como regresamos, no hará

231
00:13:42,570 --> 00:13:46,200
‫nada después de eso, por lo que todo esto

232
00:13:46,200 --> 00:13:49,990
‫básicamente se ignora y no se ejecutará , que es

233
00:13:49,990 --> 00:13:51,823
‫exactamente lo que queremos.

234
00:13:52,680 --> 00:13:55,863
‫Bien, pero si lo ponemos de nuevo a la

235
00:13:57,720 --> 00:13:59,090
‫normalidad y luego

236
00:13:59,090 --> 00:14:02,010
‫lo ejecutamos de nuevo, entonces todo funciona como antes.

237
00:14:02,010 --> 00:14:05,270
‫Entonces, acostúmbrese a este patrón de devoluciones de llamada porque

238
00:14:05,270 --> 00:14:08,270
‫lo verá por todas partes en Node JS

239
00:14:08,270 --> 00:14:10,163
‫y en toda esta sección.