1
00:00:01,190 --> 00:00:02,840
‫Jonas: Escribamos ahora algo

2
00:00:02,840 --> 00:00:05,520
‫de código para comprender mejor lo que

3
00:00:05,520 --> 00:00:07,893
‫sucede en el bucle de eventos.

4
00:00:09,200 --> 00:00:11,370
‫Así que, al igual que antes,

5
00:00:11,370 --> 00:00:13,670
‫para comenzar con la parte de codificación

6
00:00:13,670 --> 00:00:15,970
‫de esta sección, siga adelante y obtenga

7
00:00:15,970 --> 00:00:18,550
‫los archivos de inicio para esta sección, cópielos en

8
00:00:18,550 --> 00:00:22,050
‫algún lugar y luego abra el proyecto en su editor de código.

9
00:00:22,050 --> 00:00:24,310
‫Así que lo tengo aquí en el escritorio

10
00:00:24,310 --> 00:00:27,550
‫y en mi VSCode, y todo lo que tenemos aquí para

11
00:00:27,550 --> 00:00:31,420
‫comenzar es este archivo de prueba. txt, por lo que crearé un nuevo archivo

12
00:00:31,420 --> 00:00:35,033
‫aquí, y lo llamaré bucle de eventos. js.

13
00:00:38,040 --> 00:00:41,530
‫Muy bien, ahora es extremadamente difícil simular el bucle de eventos

14
00:00:41,530 --> 00:00:44,000
‫correctamente, porque realmente no podemos poner muchas

15
00:00:44,000 --> 00:00:46,400
‫devoluciones de llamada en todas las colas

16
00:00:46,400 --> 00:00:48,080
‫de devolución de llamada

17
00:00:48,080 --> 00:00:51,260
‫de las que hablamos antes, todas al mismo tiempo, ¿verdad?

18
00:00:51,260 --> 00:00:53,710
‫Esa situación ocurre cuando, por ejemplo,

19
00:00:53,710 --> 00:00:56,360
‫ingresan muchas solicitudes a su aplicación, pero

20
00:00:56,360 --> 00:01:00,240
‫aquí de manera local, eso es muy difícil de replicar.

21
00:01:00,240 --> 00:01:03,150
‫Pero de todos modos, todavía haremos algunos experimentos muy

22
00:01:03,150 --> 00:01:05,390
‫interesantes usando algunas de las cosas que

23
00:01:05,390 --> 00:01:07,540
‫aprendimos en el último video.

24
00:01:07,540 --> 00:01:09,830
‫Y lo que vamos a hacer

25
00:01:09,830 --> 00:01:12,190
‫es escribir un montón de líneas de

26
00:01:12,190 --> 00:01:15,130
‫código y luego tratar de averiguar en qué orden

27
00:01:15,130 --> 00:01:17,950
‫deben ejecutarse en el ciclo de eventos y analizar

28
00:01:17,950 --> 00:01:20,360
‫si los resultados que obtenemos realmente tienen sentido.

29
00:01:20,360 --> 00:01:22,710
‫Así que comencemos escribiendo un setTimeout, básicamente

30
00:01:24,290 --> 00:01:26,513
‫para configurar un temporizador, y estoy usando

31
00:01:27,980 --> 00:01:29,890
‫una función de flecha aquí,

32
00:01:29,890 --> 00:01:31,270
‫y lo único

33
00:01:31,270 --> 00:01:33,773
‫que voy a hacer es iniciar sesión en

34
00:01:34,930 --> 00:01:39,930
‫la consola con una cadena, así que consola. log, el temporizador uno terminó

35
00:01:41,800 --> 00:01:45,390
‫y quiero que expire justo después de cero segundos.

36
00:01:45,390 --> 00:01:47,740
‫Bien, guarde, y luego verá que realmente

37
00:01:47,740 --> 00:01:50,030
‫corrigió esta cadena aquí, por lo que

38
00:01:50,030 --> 00:01:53,120
‫cambió estas comillas y agregó el punto y coma, y

39
00:01:53,120 --> 00:01:54,810
‫eso se debe a

40
00:01:54,810 --> 00:01:56,940
‫la extensión Prettier que instalamos antes.

41
00:01:56,940 --> 00:01:58,510
‫Ahora no lo voy a configurar

42
00:01:58,510 --> 00:01:59,850
‫aquí, porque para este

43
00:01:59,850 --> 00:02:02,050
‫pequeño ejemplo, eso no es realmente necesario, está bien.

44
00:02:02,050 --> 00:02:05,150
‫Eso es configurar un temporizador, entonces

45
00:02:05,150 --> 00:02:09,320
‫también usemos setImmediate, así que recuerde eso del último video.

46
00:02:09,320 --> 00:02:11,620
‫Bien, ahora no voy a explicar mucho aquí,

47
00:02:11,620 --> 00:02:13,350
‫por ahora escribamos este código

48
00:02:13,350 --> 00:02:15,510
‫y luego analicemos lo que sucede, está bien.

49
00:02:15,510 --> 00:02:20,320
‫Entonces, setImmediate, y al igual que el otro temporizador, recibe una función

50
00:02:20,320 --> 00:02:22,500
‫de devolución de llamada.

51
00:02:22,500 --> 00:02:25,130
‫Y lo único que vamos a hacer

52
00:02:27,720 --> 00:02:31,440
‫es escribir uno inmediato terminado, y este no tiene

53
00:02:31,440 --> 00:02:33,520
‫tiempo, porque no es

54
00:02:33,520 --> 00:02:36,930
‫necesario porque como dice el nombre, es inmediato.

55
00:02:36,930 --> 00:02:38,540
‫Luego, otra cosa que queremos

56
00:02:38,540 --> 00:02:41,620
‫hacer es leer este archivo aquí, y luego pasar

57
00:02:41,620 --> 00:02:44,930
‫una función de devolución de llamada, está bien, entonces lo

58
00:02:44,930 --> 00:02:48,963
‫primero es que tenemos que requerir el módulo correcto, entonces FS, y

59
00:02:52,600 --> 00:02:54,987
‫ahora fs. readFile, y queremos archivo de texto. txt,

60
00:03:05,586 --> 00:03:08,003
‫y luego algo que suceda.

61
00:03:09,270 --> 00:03:12,153
‫Y al igual que antes, digamos aquí,

62
00:03:13,740 --> 00:03:17,263
‫en este caso, la E / S terminó, está bien.

63
00:03:18,830 --> 00:03:21,170
‫Entonces E / S porque esta devolución

64
00:03:21,170 --> 00:03:24,830
‫de llamada aquí está realmente relacionada con una tarea de E / S,

65
00:03:24,830 --> 00:03:28,440
‫que en realidad obtiene su propia fase en el bucle de eventos, ¿verdad?

66
00:03:28,440 --> 00:03:31,930
‫Y finalmente, agreguemos una consola. inicie sesión aquí,

67
00:03:31,930 --> 00:03:35,473
‫diciendo bueno, hola desde el código de nivel superior.

68
00:03:37,517 --> 00:03:40,440
‫De acuerdo, y el código de nivel superior, porque en realidad es

69
00:03:40,440 --> 00:03:43,130
‫el único que no está dentro de ninguna devolución de llamada.

70
00:03:43,130 --> 00:03:46,000
‫Entonces, en este pequeño ejemplo que tenemos por ahora,

71
00:03:46,000 --> 00:03:48,400
‫intentemos averiguar qué debería suceder primero.

72
00:03:48,400 --> 00:03:50,510
‫Bueno, recuerde que el primer paso

73
00:03:50,510 --> 00:03:53,310
‫cuando cargamos un módulo es que su código de

74
00:03:53,310 --> 00:03:56,000
‫nivel superior se ejecuta, así que de inmediato

75
00:03:56,000 --> 00:03:59,360
‫deberíamos ver esta consola. log here, correcto, solo entonces

76
00:03:59,360 --> 00:04:02,110
‫más tarde deberíamos ver los otros registros provenientes de estas

77
00:04:02,110 --> 00:04:04,280
‫otras devoluciones de llamada, porque estas devoluciones de

78
00:04:04,280 --> 00:04:06,820
‫llamada realmente se ejecutarán en el bucle de eventos.

79
00:04:06,820 --> 00:04:09,190
‫Así que intentemos ver si ese es

80
00:04:09,190 --> 00:04:12,000
‫realmente el caso, y luego analicémoslo un poco mejor incluso.

81
00:04:12,000 --> 00:04:15,150
‫Entonces, abro la consola aquí, y nuevamente, lo

82
00:04:15,150 --> 00:04:17,250
‫hago usando la terminal, o

83
00:04:17,250 --> 00:04:22,023
‫en realidad en la vista, así que esta terminal aquí, está bien.

84
00:04:23,100 --> 00:04:27,020
‫Así que tenga en cuenta, event-loop. js, o en realidad antes

85
00:04:27,020 --> 00:04:30,960
‫de hacerlo, necesito corregir este error tipográfico aquí, por lo que es un

86
00:04:30,960 --> 00:04:33,580
‫archivo de prueba, no un archivo de texto.

87
00:04:33,580 --> 00:04:36,093
‫Bien, pero ahora estamos listos para ejecutar este

88
00:04:36,960 --> 00:04:40,320
‫comando, y los resultados están, por lo que el primer registro

89
00:04:40,320 --> 00:04:43,810
‫que tenemos aquí es un saludo desde el código de nivel

90
00:04:43,810 --> 00:04:46,100
‫superior, y eso era lo esperado,

91
00:04:46,100 --> 00:04:49,390
‫correcto, porque este es un código que se ejecuta. inmediatamente.

92
00:04:49,390 --> 00:04:52,940
‫Luego, después de eso, tenemos estas tres salidas, pero en realidad no están

93
00:04:52,940 --> 00:04:55,460
‫en un orden en particular, y eso se debe

94
00:04:55,460 --> 00:04:57,640
‫a que este código aquí, entonces este

95
00:04:57,640 --> 00:05:00,970
‫código, en realidad no está en un ciclo de E / S,

96
00:05:00,970 --> 00:05:03,780
‫por lo que no se está ejecutando dentro del ciclo de

97
00:05:03,780 --> 00:05:07,170
‫eventos, porque no se ejecuta dentro de ninguna función de devolución de llamada.

98
00:05:07,170 --> 00:05:10,370
‫De acuerdo, en su computadora, es posible que vea este

99
00:05:11,470 --> 00:05:13,160
‫registro aquí antes que

100
00:05:13,160 --> 00:05:15,360
‫este, y luego este aquí es solo

101
00:05:15,360 --> 00:05:18,550
‫el último porque este tipo de archivo grande aquí toma

102
00:05:18,550 --> 00:05:20,840
‫algo de tiempo para leerse, por lo

103
00:05:20,840 --> 00:05:23,060
‫que probablemente siempre será el último uno.

104
00:05:23,060 --> 00:05:27,140
‫Entonces, nuevamente, en este punto, el orden de estos tres aquí no tiene nada

105
00:05:27,140 --> 00:05:29,640
‫que ver con el ciclo de eventos, porque

106
00:05:29,640 --> 00:05:31,320
‫en realidad todavía no se

107
00:05:31,320 --> 00:05:33,420
‫están ejecutando dentro del ciclo de eventos.

108
00:05:33,420 --> 00:05:36,490
‫Para eso, tendremos que moverlos, o al menos

109
00:05:36,490 --> 00:05:40,490
‫mover estos dos aquí, dentro de una función de devolución de llamada.

110
00:05:40,490 --> 00:05:43,713
‫Y entonces, para eso vamos a usar este de aquí.

111
00:05:45,270 --> 00:05:50,190
‫Así que déjame ponerlo aquí, y decir temporizador dos y temporizador dos aquí,

112
00:05:50,190 --> 00:05:55,190
‫o dos inmediatos, y también agregaré otro temporizador aquí, así que el temporizador

113
00:05:55,270 --> 00:05:57,740
‫tres, y este se ejecutará durante

114
00:05:57,740 --> 00:06:01,140
‫tres segundos, por lo que son 3000 milisegundos. .

115
00:06:01,140 --> 00:06:03,840
‫Probemos ahora el resultado de este.

116
00:06:03,840 --> 00:06:06,230
‫Pero antes de hacer eso, pensemos

117
00:06:06,230 --> 00:06:09,660
‫realmente por qué, justo después de que se ejecutó

118
00:06:09,660 --> 00:06:13,730
‫todo el código anterior, el programa salió y volvió al indicador aquí.

119
00:06:13,730 --> 00:06:16,500
‫Así que recuerda cómo Node. js decide si

120
00:06:16,500 --> 00:06:19,000
‫debe continuar ejecutando el bucle de eventos, bueno,

121
00:06:19,000 --> 00:06:21,620
‫lo hace preguntando si todavía hay tiempo ejecutándose en

122
00:06:21,620 --> 00:06:24,580
‫segundo plano, y si es así, no terminará, y si

123
00:06:24,580 --> 00:06:26,800
‫todavía hay un temporizador pendiente, bueno, entonces

124
00:06:26,800 --> 00:06:29,140
‫no lo es. va a salir del programa.

125
00:06:29,140 --> 00:06:30,920
‫Pero si no lo hay,

126
00:06:30,920 --> 00:06:33,920
‫que fue el caso en el primer ejemplo aquí,

127
00:06:33,920 --> 00:06:36,660
‫inmediatamente sale del programa, está bien, pero ahora

128
00:06:36,660 --> 00:06:38,980
‫tenemos un temporizador aquí, por lo que

129
00:06:38,980 --> 00:06:41,620
‫este funcionará durante tres segundos, así que intentemos

130
00:06:41,620 --> 00:06:43,220
‫averiguar qué sucede aquí.

131
00:06:45,260 --> 00:06:47,450
‫Bien, entonces ve que no está

132
00:06:47,450 --> 00:06:50,640
‫saliendo, y solo ahora, después de que el temporizador

133
00:06:50,640 --> 00:06:53,170
‫tres haya terminado, salió de la aplicación.

134
00:06:53,170 --> 00:06:56,100
‫Bien, veamos eso de nuevo, para que todos

135
00:06:56,100 --> 00:06:59,480
‫estos cronómetros de registros se estén ejecutando, el cronómetro

136
00:06:59,480 --> 00:07:02,070
‫finalizó y salió de la aplicación.

137
00:07:02,070 --> 00:07:04,490
‫Ahora, sobre estos resultados aquí, hagamos que

138
00:07:04,490 --> 00:07:06,820
‫esto sea un poco más

139
00:07:06,820 --> 00:07:10,113
‫fácil de ver y agreguemos solo un pequeño separador aquí.

140
00:07:11,360 --> 00:07:14,683
‫Está bien, limpia esto, está bien.

141
00:07:16,510 --> 00:07:19,600
‫Entonces, estos cuatro aquí son las salidas que realmente no

142
00:07:19,600 --> 00:07:22,110
‫se estaban ejecutando en el bucle de

143
00:07:22,110 --> 00:07:24,380
‫eventos, pero estos tres aquí realmente

144
00:07:24,380 --> 00:07:28,150
‫estaban saliendo del bucle de eventos, así que ahora analicemos estos resultados.

145
00:07:28,150 --> 00:07:29,980
‫Ahora, si recuerdas el

146
00:07:29,980 --> 00:07:32,690
‫diagrama de la lección anterior, probablemente habrás

147
00:07:32,690 --> 00:07:36,960
‫pensado que el temporizador, por lo que el temporizador dos aquí, debería

148
00:07:36,960 --> 00:07:39,640
‫terminar antes del setImmediate, porque en el

149
00:07:39,640 --> 00:07:42,640
‫diagrama, en realidad apareció primero justo en la

150
00:07:42,640 --> 00:07:45,100
‫parte superior de la bucle de eventos.

151
00:07:45,100 --> 00:07:48,090
‫Así que tenemos que establecer el tiempo de

152
00:07:48,090 --> 00:07:52,500
‫espera aquí con cero, que debería ser lo mismo que setImmediate, correcto.

153
00:07:52,500 --> 00:07:54,610
‫Entonces, ¿por qué

154
00:07:54,610 --> 00:07:57,630
‫setImmediate aparece antes de setTimeout?

155
00:07:57,630 --> 00:08:00,020
‫Bueno, hay algo que realmente no

156
00:08:00,020 --> 00:08:02,470
‫expliqué en el último video, porque no quería

157
00:08:02,470 --> 00:08:05,750
‫hacerlo aún más confuso, y es que el bucle de eventos

158
00:08:05,750 --> 00:08:09,320
‫en realidad espera que sucedan cosas en la fase de encuesta.

159
00:08:09,320 --> 00:08:12,270
‫Entonces, en esa fase donde se manejan las devoluciones de llamada de E / S.

160
00:08:12,270 --> 00:08:15,400
‫Entonces, cuando esta cola de devoluciones de llamada está vacía, que

161
00:08:15,400 --> 00:08:17,940
‫es el caso en nuestro ejemplo ficticio aquí,

162
00:08:17,940 --> 00:08:20,270
‫entonces no tenemos devoluciones de llamada de

163
00:08:20,270 --> 00:08:23,500
‫E / S, todo lo que tenemos son estos temporizadores, bueno,

164
00:08:23,500 --> 00:08:27,490
‫entonces el bucle de eventos esperará en esta fase hasta que haya expirado Temporizador.

165
00:08:27,490 --> 00:08:31,430
‫Pero, si programamos una devolución de llamada usando setImmediate, entonces esa

166
00:08:31,430 --> 00:08:34,320
‫devolución de llamada se ejecutará inmediatamente después de

167
00:08:34,320 --> 00:08:36,920
‫la fase de sondeo, e incluso

168
00:08:36,920 --> 00:08:40,240
‫antes de que expiren los temporizadores, si hay uno.

169
00:08:40,240 --> 00:08:43,270
‫Y en este caso, el temporizador expira de inmediato, por lo

170
00:08:43,270 --> 00:08:46,080
‫que después de cero segundos, pero nuevamente, el bucle

171
00:08:46,080 --> 00:08:49,710
‫de eventos realmente espera, por lo que se detiene en la fase de sondeo.

172
00:08:49,710 --> 00:08:52,100
‫Y entonces esa devolución de llamada

173
00:08:52,100 --> 00:08:55,580
‫setImmediate se ejecuta primero, por lo que esa es la razón

174
00:08:55,580 --> 00:08:59,730
‫por la que tenemos este inmediato aquí después de que tenemos los temporizadores.

175
00:08:59,730 --> 00:09:02,770
‫Está bien, y sé que esto suena muy confuso, y estoy

176
00:09:02,770 --> 00:09:04,810
‫completamente de acuerdo, pero en realidad esa es

177
00:09:04,810 --> 00:09:08,090
‫la forma en que Node. js funciona.

178
00:09:08,090 --> 00:09:11,380
‫Y ahora hagamos esto un poco más confuso y

179
00:09:11,380 --> 00:09:14,250
‫agreguemos el proceso. nextTick de la

180
00:09:14,250 --> 00:09:16,950
‫que hablamos también en la última conferencia.

181
00:09:16,950 --> 00:09:21,950
‫Entonces decimos proceso. nextTick, y luego, como antes, simplemente le pasamos

182
00:09:22,170 --> 00:09:24,323
‫una función de devolución de llamada.

183
00:09:25,540 --> 00:09:27,640
‫Y de nuevo, solo quiero iniciar sesión en

184
00:09:27,640 --> 00:09:31,663
‫la consola, y voy a decir proceso. nextTick.

185
00:09:32,550 --> 00:09:36,150
‫Entonces, ¿qué crees que pasará en este caso?

186
00:09:36,150 --> 00:09:40,170
‫Continúe y adivine, y una vez que esté listo,

187
00:09:40,170 --> 00:09:42,883
‫puede ejecutar esto, así que hagámoslo.

188
00:09:44,120 --> 00:09:48,280
‫Guárdelo aquí primero, ejecútelo, y aquí vamos.

189
00:09:48,280 --> 00:09:51,760
‫Entonces, los resultados están nuevamente, y ahora la primera

190
00:09:51,760 --> 00:09:55,640
‫devolución de llamada que se ejecutó fue en realidad esta función aquí.

191
00:09:55,640 --> 00:09:58,220
‫Por eso tenemos el proceso. siguiente Marque a

192
00:09:58,220 --> 00:09:59,710
‫la derecha en el primero.

193
00:09:59,710 --> 00:10:03,500
‫Entonces, ¿por qué esta función de devolución de llamada del proceso. siguiente ¿Marque el

194
00:10:03,500 --> 00:10:06,570
‫primero de todos ellos en ejecutarse?

195
00:10:06,570 --> 00:10:09,070
‫Bueno, recuerde que nextTick es parte

196
00:10:09,070 --> 00:10:12,410
‫de la cola de microtareas, que se ejecutan después de

197
00:10:12,410 --> 00:10:16,530
‫cada fase, por lo que no solo después de un tick completo.

198
00:10:16,530 --> 00:10:19,120
‫Entonces, lo que sucedió aquí es que esta función

199
00:10:19,120 --> 00:10:23,660
‫de devolución de llamada realmente se ejecutó antes de la fase en la que se ejecutó esta

200
00:10:23,660 --> 00:10:26,970
‫función de devolución de llamada aquí, y la fase anterior, está bien.

201
00:10:26,970 --> 00:10:30,850
‫Ahora nextTick es en realidad un nombre engañoso, porque un tick es

202
00:10:30,850 --> 00:10:33,990
‫en realidad un ciclo completo, pero nextTick en

203
00:10:33,990 --> 00:10:37,860
‫realidad ocurre antes de la siguiente fase de ciclo, y no

204
00:10:37,860 --> 00:10:41,990
‫todo el tick, así que eso es lo que estaba diciendo antes.

205
00:10:41,990 --> 00:10:45,830
‫Luego, por otro lado, setImmediate te haría pensar que

206
00:10:45,830 --> 00:10:49,690
‫su devolución de llamada se ejecutaría de inmediato, pero

207
00:10:49,690 --> 00:10:52,780
‫en realidad no es así, ¿verdad? SetImmediate

208
00:10:52,780 --> 00:10:55,570
‫en realidad se ejecuta una vez

209
00:10:55,570 --> 00:10:58,800
‫por tick, mientras que nextTick se ejecuta inmediatamente.

210
00:10:58,800 --> 00:11:01,820
‫Entonces, sus dos nombres deberían cambiarse.

211
00:11:01,820 --> 00:11:03,700
‫Deberían ser al revés, y esto

212
00:11:03,700 --> 00:11:05,390
‫puede causar mucha confusión, por

213
00:11:05,390 --> 00:11:08,440
‫lo que es mejor ceñirse siempre a uno de ellos,

214
00:11:08,440 --> 00:11:12,470
‫que generalmente es setImmediate y no process. nextTick.

215
00:11:12,470 --> 00:11:15,070
‫De todos modos, como mencioné en un último

216
00:11:15,070 --> 00:11:18,530
‫video, estos mecanismos son en realidad más para casos de uso

217
00:11:18,530 --> 00:11:20,320
‫bastante avanzados, por lo que

218
00:11:20,320 --> 00:11:22,760
‫probablemente no los usaremos en nuestro proyecto.

219
00:11:22,760 --> 00:11:24,970
‫Pero si desea obtener más información

220
00:11:24,970 --> 00:11:28,060
‫sobre ellos, siempre puede leer la documentación oficial de Node.

221
00:11:28,060 --> 00:11:30,660
‫Bien, con esto hemos simulado algunos aspectos del

222
00:11:30,660 --> 00:11:33,250
‫bucle de eventos, pero para terminar, quiero presentar

223
00:11:33,250 --> 00:11:35,500
‫rápidamente algo sobre el grupo de

224
00:11:35,500 --> 00:11:38,290
‫subprocesos también, y para eso vamos a hacer

225
00:11:38,290 --> 00:11:40,950
‫una operación más compleja que en realidad se

226
00:11:40,950 --> 00:11:43,490
‫descargará en el grupo de subprocesos y

227
00:11:43,490 --> 00:11:47,040
‫observe cuánto tardan en ejecutarse estas operaciones y cómo podemos cambiar

228
00:11:47,040 --> 00:11:48,510
‫el tamaño del

229
00:11:48,510 --> 00:11:50,870
‫grupo de subprocesos del que hablamos antes.

230
00:11:50,870 --> 00:11:52,840
‫Así que usaremos algo de

231
00:11:52,840 --> 00:11:55,203
‫criptografía aquí para encriptar básicamente una contraseña.

232
00:11:58,620 --> 00:12:00,820
‫Ese es un nuevo paquete que no

233
00:12:00,820 --> 00:12:04,130
‫habíamos usado antes, y se llama Crypto, pero mencioné anteriormente que

234
00:12:04,130 --> 00:12:07,063
‫en realidad, todas las funciones de este paquete, serán

235
00:12:07,960 --> 00:12:11,260
‫descargadas automáticamente por el bucle de eventos al grupo de subprocesos,

236
00:12:11,260 --> 00:12:13,280
‫y eso es lo que nosotros

237
00:12:13,280 --> 00:12:14,780
‫voy a probar ahora.

238
00:12:18,380 --> 00:12:22,070
‫Y usemos esto ahora, así que cripto. pb, entonces usaremos una función

239
00:12:22,070 --> 00:12:25,303
‫de cifrado llamada pbkdf2, un nombre un poco extraño,

240
00:12:27,610 --> 00:12:31,050
‫y ahora pasamos la cadena secreta, que digamos contraseña, luego

241
00:12:31,050 --> 00:12:34,640
‫necesitamos una cadena para resolver las contraseñas y las implementaciones

242
00:12:34,640 --> 00:12:37,520
‫aquí realmente no importa, así que por ahora

243
00:12:37,520 --> 00:12:40,820
‫no voy a entrar en detalles de cómo funciona

244
00:12:40,820 --> 00:12:42,970
‫esto, lo haremos más tarde, está

245
00:12:42,970 --> 00:12:46,150
‫bien, aquí solo necesitamos la longitud de la clave,

246
00:12:46,150 --> 00:12:48,320
‫así que este número aquí es

247
00:12:48,320 --> 00:12:50,070
‫solo para el

248
00:12:50,070 --> 00:12:53,870
‫número de iteraciones, entonces esta es la longitud de la clave,

249
00:12:53,870 --> 00:12:56,020
‫y finalmente el algoritmo, que

250
00:12:56,020 --> 00:12:58,430
‫se utilizará para cifrar la contraseña.

251
00:12:58,430 --> 00:13:00,380
‫Por lo tanto, estos números simplemente

252
00:13:00,380 --> 00:13:02,483
‫aumentarán el tiempo necesario para el cifrado.

253
00:13:04,970 --> 00:13:08,610
‫De acuerdo, y finalmente, también se necesita una función de devolución de llamada, y todo lo que voy

254
00:13:08,610 --> 00:13:11,483
‫a hacer aquí es hacer otra consola. log

255
00:13:12,730 --> 00:13:16,453
‫y solo diga contraseña cifrada.

256
00:13:17,950 --> 00:13:20,740
‫Ahora, para el propósito de esta

257
00:13:20,740 --> 00:13:24,220
‫demostración, en realidad quiero mostrarles cuánto tiempo toma

258
00:13:24,220 --> 00:13:27,400
‫cada una de estas operaciones, así que

259
00:13:27,400 --> 00:13:32,010
‫lo que vamos a hacer es básicamente definir una variable al

260
00:13:32,010 --> 00:13:37,010
‫principio, configurarla a la fecha. ahora, esa es la fecha actual en

261
00:13:37,120 --> 00:13:41,310
‫milisegundos, y luego aquí, todo lo que tenemos que hacer es registrar no

262
00:13:41,310 --> 00:13:46,310
‫solo la cadena, sino también la fecha. ahora, que será la fecha en

263
00:13:46,310 --> 00:13:49,700
‫este punto en milisegundos, menos el inicio, y

264
00:13:49,700 --> 00:13:53,010
‫entonces eso nos dará la cantidad de

265
00:13:53,010 --> 00:13:55,380
‫milisegundos que han pasado para

266
00:13:55,380 --> 00:13:57,380
‫hacer este cálculo.

267
00:13:57,380 --> 00:13:59,693
‫Bien, probémoslo, guarde

268
00:14:00,890 --> 00:14:05,360
‫y ejecútelo de nuevo, y aquí puede ver

269
00:14:05,360 --> 00:14:08,530
‫que tomó 1855 milisegundos, casi

270
00:14:08,530 --> 00:14:12,250
‫dos segundos para encriptar esta contraseña.

271
00:14:12,250 --> 00:14:15,110
‫Bien, pero ahora vamos a duplicar este código,

272
00:14:15,110 --> 00:14:17,360
‫o en realidad quiero cuatro

273
00:14:17,360 --> 00:14:19,660
‫instancias de esto para mostrarte algo.

274
00:14:19,660 --> 00:14:23,400
‫Entonces, si ejecutamos esto ahora, probablemente debería tomar aproximadamente la misma

275
00:14:23,400 --> 00:14:25,710
‫cantidad de tiempo, y sí, así que

276
00:14:25,710 --> 00:14:27,980
‫fue 1. 8

277
00:14:27,980 --> 00:14:31,620
‫segundos, ahora son 2. 2 segundos, que es bastante similar.

278
00:14:31,620 --> 00:14:34,530
‫De acuerdo, y recuerde que le dije en una

279
00:14:34,530 --> 00:14:36,630
‫de las conferencias anteriores, que por

280
00:14:36,630 --> 00:14:39,360
‫defecto el tamaño del grupo de subprocesos es

281
00:14:39,360 --> 00:14:41,720
‫cuatro, por lo que hay cuatro subprocesos

282
00:14:41,720 --> 00:14:44,010
‫haciendo el trabajo al mismo tiempo, y

283
00:14:44,010 --> 00:14:46,160
‫por eso estos cuatro cifrados de contraseña

284
00:14:46,160 --> 00:14:48,000
‫toman aproximadamente al mismo

285
00:14:48,000 --> 00:14:50,740
‫tiempo y suceden básicamente todos al mismo tiempo.

286
00:14:50,740 --> 00:14:53,990
‫Pero en realidad podemos cambiar el tamaño de ese grupo de subprocesos.

287
00:14:53,990 --> 00:14:57,100
‫Entonces, permítanme mostrarles cómo hacemos eso, y lo

288
00:14:57,100 --> 00:14:59,867
‫hacemos diciendo proceso. env, y esa

289
00:15:01,290 --> 00:15:03,230
‫es una variable ambiental, y nuevamente

290
00:15:03,230 --> 00:15:05,680
‫hablaremos más sobre eso más adelante, y

291
00:15:06,684 --> 00:15:08,613
‫UV, que significa LibUV, tamaño

292
00:15:11,232 --> 00:15:15,500
‫de grupo de subprocesos, por lo que si configuramos esto en uno,

293
00:15:15,500 --> 00:15:18,783
‫solo tendremos un subproceso en nuestro grupo de subprocesos.

294
00:15:21,110 --> 00:15:26,110
‫Intentémoslo de nuevo y veamos qué sucede ahora.

295
00:15:28,650 --> 00:15:32,840
‫Entonces ves que todos tardan mucho más en calcularse.

296
00:15:32,840 --> 00:15:35,490
‫Básicamente, se calculan uno tras otro.

297
00:15:35,490 --> 00:15:38,470
‫Entonces este es el primero, luego este aquí toma el

298
00:15:38,470 --> 00:15:40,610
‫doble de tiempo, y nuevamente eso es

299
00:15:40,610 --> 00:15:42,980
‫porque este solo puede comenzar tan pronto como

300
00:15:42,980 --> 00:15:45,160
‫se complete el primero, y lo mismo con

301
00:15:45,160 --> 00:15:46,893
‫el tercero y el cuarto.

302
00:15:47,920 --> 00:15:49,620
‫Ahora digamos que lo

303
00:15:52,170 --> 00:15:54,300
‫cambiamos a dos, entonces deberíamos ver los

304
00:15:54,300 --> 00:15:56,990
‫dos primeros con el mismo tiempo, y exactamente,

305
00:15:56,990 --> 00:15:59,710
‫los dos segundos también con un tiempo similar.

306
00:15:59,710 --> 00:16:01,363
‫Entonces eso tiene sentido, ¿verdad?

307
00:16:02,650 --> 00:16:04,500
‫Solo para completar aquí, ahora

308
00:16:05,610 --> 00:16:08,950
‫lo mismo con tres, por lo que estos tres tienen

309
00:16:08,950 --> 00:16:11,340
‫un tiempo similar, y luego el último.

310
00:16:11,340 --> 00:16:15,440
‫Muy bien, así es como funciona básicamente el grupo de subprocesos, así que

311
00:16:15,440 --> 00:16:18,660
‫decidí no solo centrarme en el bucle de eventos, sino

312
00:16:18,660 --> 00:16:22,630
‫también darles una descripción general, muy rápida, del grupo de subprocesos y cómo

313
00:16:22,630 --> 00:16:25,010
‫podemos cambiar el tamaño del grupo de

314
00:16:25,010 --> 00:16:27,620
‫subprocesos. , está bien, tenga en cuenta que

315
00:16:27,620 --> 00:16:29,560
‫este código aquí en realidad

316
00:16:29,560 --> 00:16:33,230
‫todavía es asincrónico, porque pasamos una función de devolución de llamada.

317
00:16:33,230 --> 00:16:36,490
‫De acuerdo, y podríamos usar la versión síncrona, pero

318
00:16:36,490 --> 00:16:38,920
‫eso bloquearía el ciclo de eventos.

319
00:16:38,920 --> 00:16:40,650
‫¿Quieres ver eso?

320
00:16:40,650 --> 00:16:43,183
‫Así que permítanme mostrarles eso muy rápidamente también, de

321
00:16:44,120 --> 00:16:46,130
‫modo que uno no estaba realmente planeado,

322
00:16:46,130 --> 00:16:48,240
‫pero hagámoslo de todos modos, porque es

323
00:16:48,240 --> 00:16:50,090
‫muy interesante ver eso, creo.

324
00:16:51,580 --> 00:16:53,830
‫Bien, entonces eso funcionará así.

325
00:16:53,830 --> 00:16:57,570
‫Usamos nuevamente la versión sincronizada de la misma función, que

326
00:16:57,570 --> 00:16:59,950
‫una nota, está muchas veces disponible.

327
00:16:59,950 --> 00:17:02,760
‫Recuerde que tenemos lo mismo para el archivo de lectura, por

328
00:17:02,760 --> 00:17:05,190
‫lo que hemos leído el archivo, que acepta una

329
00:17:05,190 --> 00:17:08,290
‫devolución de llamada, y hemos leído la sincronización de archivos, que es

330
00:17:08,290 --> 00:17:11,440
‫la versión sincrónica que no acepta ninguna devolución de llamada, así que así.

331
00:17:11,440 --> 00:17:13,520
‫Entonces, este cifrará la contraseña,

332
00:17:13,520 --> 00:17:16,890
‫bloqueará la ejecución del código y luego pasará a la siguiente

333
00:17:16,890 --> 00:17:19,700
‫línea, que luego registrará esto aquí en la consola.

334
00:17:19,700 --> 00:17:21,823
‫Ahora dupliquemos esto aquí.

335
00:17:23,570 --> 00:17:26,553
‫Eso fue demasiado, deshágase de este aquí, por lo

336
00:17:27,500 --> 00:17:31,310
‫que ahora estos cuatro cifrados de contraseña ya no se ejecutarán

337
00:17:31,310 --> 00:17:33,350
‫en el bucle de eventos.

338
00:17:33,350 --> 00:17:37,070
‫Y, por lo tanto, ya no se descargarán al grupo de subprocesos.

339
00:17:37,070 --> 00:17:39,980
‫Bien, y ahora, incluso si tenemos un tamaño de

340
00:17:39,980 --> 00:17:42,583
‫grupo de subprocesos de cuatro, veamos qué sucede.

341
00:17:46,010 --> 00:17:50,080
‫Como puede ver, suceden de forma completamente sincrónica.

342
00:17:50,080 --> 00:17:53,290
‫Entonces, uno tras otro, y lo que es aún

343
00:17:53,290 --> 00:17:55,350
‫peor, es que todos

344
00:17:55,350 --> 00:17:57,960
‫estos temporizadores aquí, incluso nextTick y el

345
00:17:57,960 --> 00:18:01,850
‫inmediato, solo aparecieron después de que ocurrieron las encriptaciones de contraseñas.

346
00:18:01,850 --> 00:18:04,990
‫Así que esto realmente estaba bloqueando toda la ejecución, incluso

347
00:18:04,990 --> 00:18:07,460
‫si este temporizador aquí, por ejemplo, este aquí,

348
00:18:07,460 --> 00:18:09,580
‫se terminó después de cero segundos,

349
00:18:09,580 --> 00:18:11,440
‫y este después de tres

350
00:18:11,440 --> 00:18:13,830
‫segundos, pero todos tienen que esperar siete

351
00:18:13,830 --> 00:18:16,010
‫segundos hasta que todas estas encriptaciones de

352
00:18:16,010 --> 00:18:19,670
‫contraseñas aquí estén disponibles. finalmente listo, de nuevo porque no se estaban

353
00:18:19,670 --> 00:18:22,120
‫ejecutando dentro del bucle de eventos, pero sí.

354
00:18:22,120 --> 00:18:24,960
‫Básicamente, estaban trabajando en segundo plano y solo podían

355
00:18:24,960 --> 00:18:26,890
‫ser recogidos por el bucle

356
00:18:26,890 --> 00:18:29,470
‫de eventos cuando estaban listos, justo después

357
00:18:29,470 --> 00:18:32,110
‫de estas cuatro encriptaciones de contraseña, por lo

358
00:18:32,110 --> 00:18:34,760
‫que este fue otro gran ejemplo de ver

359
00:18:34,760 --> 00:18:38,240
‫el bloqueo de código y el bucle de eventos en acción.

360
00:18:38,240 --> 00:18:41,600
‫Bien, eso fue suficiente para una conferencia, espero que les

361
00:18:41,600 --> 00:18:43,270
‫haya resultado interesante y

362
00:18:43,270 --> 00:18:45,220
‫nos vemos en la próxima.