1
00:00:01,410 --> 00:00:04,220
Ahora vamos a crear dos situaciones más

2
00:00:04,220 --> 00:00:06,920
en el que van a aparecer los cierres.

3
00:00:06,920 --> 00:00:10,030
Para que puedas empezar a identificar cierres

4
00:00:10,030 --> 00:00:12,063
en su propio código en el futuro.

5
00:00:13,810 --> 00:00:16,960
Y ambos ejemplos van a demostrar

6
00:00:16,960 --> 00:00:19,300
que no necesitamos devolver si la función

7
00:00:19,300 --> 00:00:23,120
de otra función para crear un cierre.

8
00:00:23,120 --> 00:00:28,120
Muy bien, entonces comencemos con nuestro primer ejemplo aquí.

9
00:00:28,190 --> 00:00:32,540
Voy a empezar definiendo una variable vacía llamada f

10
00:00:34,510 --> 00:00:36,913
y luego una expresión de función g.

11
00:00:42,350 --> 00:00:44,410
Estos son solo algunos nombres genéricos

12
00:00:45,760 --> 00:00:48,573
porque lo que hacen las funciones aquí realmente no importa.

13
00:00:50,060 --> 00:00:53,620
Luego aquí, definí esto como una variable

14
00:00:53,620 --> 00:00:57,543
y luego voy a reasignar la variable F

15
00:00:57,543 --> 00:00:59,980
que creamos aquí.

16
00:00:59,980 --> 00:01:02,533
Y voy a asignarle un valor de función.

17
00:01:04,660 --> 00:01:07,870
Y esta función simplemente registrará

18
00:01:07,870 --> 00:01:10,490
la variable a la consola

19
00:01:10,490 --> 00:01:11,923
digamos dos veces.

20
00:01:12,830 --> 00:01:15,833
Bien, y eso es todo por ahora al menos.

21
00:01:17,300 --> 00:01:20,740
Así que tratemos de llamar a g

22
00:01:22,430 --> 00:01:24,710
así que va a ser una función dispersa.

23
00:01:24,710 --> 00:01:29,280
Y entonces el resultado de esta función es que a será 23

24
00:01:29,280 --> 00:01:32,870
y esa variable F que tenemos aquí

25
00:01:32,870 --> 00:01:34,970
se convertirá en esta función.

26
00:01:34,970 --> 00:01:39,970
Y así, después de g podemos llamar a F.

27
00:01:39,970 --> 00:01:40,903
Así que intentemos eso.

28
00:01:41,770 --> 00:01:46,770
Y obtenemos 46 que es de hecho 23 por dos, muy bien.

29
00:01:48,850 --> 00:01:53,030
Y lo que esto prueba es que este valor F aquí

30
00:01:53,030 --> 00:01:57,730
entonces esta función F realmente se cierra sobre cualquier variable

31
00:01:57,730 --> 00:02:01,950
del contexto de ejecución en el que se definió.

32
00:02:01,950 --> 00:02:06,290
Y eso es cierto incluso cuando la variable en sí.

33
00:02:06,290 --> 00:02:11,080
Así que F aquí técnicamente ni siquiera estaba definido en el interior

34
00:02:11,080 --> 00:02:14,710
de este entorno variable aquí, a la derecha.

35
00:02:14,710 --> 00:02:17,440
Así que esta variable F se definió fuera de aquí

36
00:02:17,440 --> 00:02:20,410
en el ámbito global, se creó aquí

37
00:02:20,410 --> 00:02:23,530
pero luego como le asignamos una función aquí

38
00:02:23,530 --> 00:02:25,960
en esto la función g,

39
00:02:25,960 --> 00:02:27,840
así que aquí mismo en instilar cerrado

40
00:02:27,840 --> 00:02:31,390
sobre el entorno variable de la función g.

41
00:02:31,390 --> 00:02:34,330
Y eso incluye esta una variable.

42
00:02:34,330 --> 00:02:38,230
Y por lo tanto es capaz de acceder a esta una variable aquí

43
00:02:38,230 --> 00:02:41,730
incluso después de la función g aquí en este punto

44
00:02:41,730 --> 00:02:46,170
por supuesto ya ha terminado su ejecución, verdad.

45
00:02:46,170 --> 00:02:49,500
Así que eso es justo lo que aprendimos en la última lección.

46
00:02:49,500 --> 00:02:51,490
Así que en este punto de la ejecución,

47
00:02:51,490 --> 00:02:56,490
el entorno variable de g ya no está, verdad.

48
00:02:56,760 --> 00:02:59,960
Pero f, entonces esta función aquí cerrada

49
00:02:59,960 --> 00:03:03,620
ese entorno variable y por lo tanto es capaz

50
00:03:03,620 --> 00:03:06,283
para acceder a la variable.

51
00:03:08,030 --> 00:03:11,670
Básicamente, usando la analogía de o menos video,

52
00:03:11,670 --> 00:03:16,670
la variable a está dentro de la mochila de la función f.

53
00:03:17,480 --> 00:03:20,670
Pero ahora vamos a llevarlo al siguiente nivel

54
00:03:20,670 --> 00:03:22,503
y crear una nueva función aquí.

55
00:03:25,320 --> 00:03:29,540
Así que eso es h y va a ser muy similar.

56
00:03:29,540 --> 00:03:34,540
Todo lo que va a hacer es definir b como algún otro valor,

57
00:03:35,060 --> 00:03:39,340
digamos esto y luego lo haremos de nuevo,

58
00:03:39,340 --> 00:03:42,193
reasignar f, aquí mismo.

59
00:03:43,250 --> 00:03:46,500
Así que llamemos a este ab ahora, por supuesto.

60
00:03:46,500 --> 00:03:49,950
Así que este de aquí intentará acceder a b

61
00:03:49,950 --> 00:03:51,423
y multiplicar por dos.

62
00:03:52,800 --> 00:03:56,110
Bien, entonces lo que quiero ver con esto

63
00:03:56,110 --> 00:03:59,300
es lo que sucede cuando asignamos el valor f

64
00:03:59,300 --> 00:04:00,573
una segunda función.

65
00:04:01,580 --> 00:04:06,580
Bien, aquí llamamos g y entonces g se asignará a

66
00:04:06,680 --> 00:04:09,810
o variable vacía esta función f.

67
00:04:09,810 --> 00:04:14,810
Bien, y luego si llamamos h después

68
00:04:14,910 --> 00:04:18,640
o en realidad hagámoslo después de llamar a f por primera vez.

69
00:04:18,640 --> 00:04:21,500
Entonces, cuando llamamos h, entonces la variable f

70
00:04:21,500 --> 00:04:23,680
será asignado nuevamente.

71
00:04:23,680 --> 00:04:26,713
Entonces, una segunda función que es esta aquí.

72
00:04:27,780 --> 00:04:31,890
Entonces, lo que quiero ver es lo que f hace entonces.

73
00:04:31,890 --> 00:04:33,270
Entonces, veamos.

74
00:04:33,270 --> 00:04:36,860
Y de nuevo, teniendo en cuenta que F en este punto

75
00:04:36,860 --> 00:04:39,510
es una función diferente a esta de aquí

76
00:04:39,510 --> 00:04:42,203
porque fue reasignado por h.

77
00:04:43,210 --> 00:04:44,493
Solo escribimos eso aquí.

78
00:04:51,520 --> 00:04:56,520
Bien, ahora obtenemos 1554, que es probablemente 777 veces dos.

79
00:05:00,530 --> 00:05:02,140
y de hecho lo es.

80
00:05:02,140 --> 00:05:05,520
Y entonces esto prueba que la función f

81
00:05:05,520 --> 00:05:07,240
fue reasignado aquí

82
00:05:07,240 --> 00:05:11,560
también cerrado sobre el entorno variable de h.

83
00:05:11,560 --> 00:05:15,180
Y así es como puede acceder a la variable b aquí

84
00:05:15,180 --> 00:05:17,163
que se ha fijado en 777.

85
00:05:18,120 --> 00:05:22,390
Así que vamos a inspeccionar el entorno variable como

86
00:05:22,390 --> 00:05:24,643
lo hicimos al final del último video.

87
00:05:25,930 --> 00:05:30,930
Entonces de f y luego podremos ver que en el cierre,

88
00:05:34,000 --> 00:05:37,490
de hecho tiene el valor de b

89
00:05:37,490 --> 00:05:40,930
y ahora ya no tiene el valor de a.

90
00:05:40,930 --> 00:05:44,950
Así que después del cierre que tenía antes.

91
00:05:44,950 --> 00:05:47,530
Así que en este punto aquí en el cierre contenido

92
00:05:47,530 --> 00:05:52,530
el valor a y, por supuesto, también podemos ver eso.

93
00:05:53,400 --> 00:05:58,400
Entonces, en este momento, el cierre es de hecho un 23, correcto.

94
00:06:04,350 --> 00:06:09,350
Y entonces, cuando reasignamos la función a un nuevo valor,

95
00:06:09,350 --> 00:06:12,820
entonces ese viejo cierre básicamente desaparece

96
00:06:12,820 --> 00:06:16,363
y ahora el cierre es b.

97
00:06:17,260 --> 00:06:20,150
Así que esta variable aquí del lugar de nacimiento

98
00:06:20,150 --> 00:06:22,630
donde fue reasignado.

99
00:06:22,630 --> 00:06:25,770
Y esto es realmente fascinante en mi opinión.

100
00:06:25,770 --> 00:06:28,160
que el cierre puede cambiar asi

101
00:06:28,160 --> 00:06:30,670
a medida que se reasigna la variable.

102
00:06:30,670 --> 00:06:34,640
Así que es cierto que un cierre siempre asegura

103
00:06:34,640 --> 00:06:37,720
que una función no pierda la conexión

104
00:06:37,720 --> 00:06:41,760
a las variables que estaban presentes en su lugar de nacimiento.

105
00:06:41,760 --> 00:06:44,000
Así que siempre los recordará.

106
00:06:44,000 --> 00:06:45,940
En nuestro caso aquí, la función

107
00:06:45,940 --> 00:06:49,510
nació dentro de g primero

108
00:06:49,510 --> 00:06:54,050
y luego renació esencialmente de nuevo en h.

109
00:06:54,050 --> 00:06:57,490
Y entonces, primero el cierre contenía la variable a

110
00:06:57,490 --> 00:06:59,450
de su primer lugar de nacimiento.

111
00:06:59,450 --> 00:07:03,920
Y luego, cuando renació para seguir nuestra analogía

112
00:07:03,920 --> 00:07:08,500
luego recordó esta variable B de su lugar de nacimiento.

113
00:07:08,500 --> 00:07:13,253
Bien, entonces este fue el ejemplo uno.

114
00:07:14,250 --> 00:07:17,513
Ahora vamos a crear otro ejemplo.

115
00:07:21,540 --> 00:07:24,690
Bien, entonces espero que la primera haya sido clara aquí.

116
00:07:24,690 --> 00:07:26,670
Entonces, cada vez que sucede algo como esto

117
00:07:26,670 --> 00:07:30,690
donde tus funciones reasignadas aún sin devolverlas,

118
00:07:30,690 --> 00:07:33,940
tenga en cuenta que también esto creará un cierre

119
00:07:35,760 --> 00:07:39,130
pero ahora pasando a nuestro segundo ejemplo aquí

120
00:07:39,130 --> 00:07:41,410
y eso va a ser un temporizador.

121
00:07:41,410 --> 00:07:43,950
Así que un temporizador es otro gran ejemplo.

122
00:07:43,950 --> 00:07:46,460
que no necesitamos devolver una función

123
00:07:46,460 --> 00:07:48,423
para ver un cierre en acción.

124
00:07:49,960 --> 00:07:54,373
Así que aquí estoy volviendo al ejemplo de la aerolínea.

125
00:07:57,300 --> 00:08:01,320
Así que creando una función llamada pasajeros a bordo

126
00:08:03,940 --> 00:08:08,940
y luego obtenemos el número de pasajeros y el tiempo de espera.

127
00:08:10,710 --> 00:08:13,320
Entonces vamos a crear una nueva variable aquí

128
00:08:13,320 --> 00:08:14,723
que estoy llamando perGroup.

129
00:08:16,520 --> 00:08:20,240
Y eso es porque el abordaje suele ocurrir en grupos.

130
00:08:20,240 --> 00:08:22,040
y solemos tener tres grupos.

131
00:08:22,040 --> 00:08:24,700
Así que voy a dividir a todos los pasajeros.

132
00:08:24,700 --> 00:08:28,940
Así que el número de pasajeros que está abordando por tres

133
00:08:30,460 --> 00:08:31,850
y al final de esta función,

134
00:08:31,850 --> 00:08:33,523
Quiero bloquear a la consola.

135
00:08:35,340 --> 00:08:40,340
Empezaremos a abordar y luego esperaremos unos segundos, ¿de acuerdo?

136
00:08:46,110 --> 00:08:48,840
Y ahora usemos un temporizador

137
00:08:48,840 --> 00:08:52,157
y aún no hemos usado un temporizador en este curso.

138
00:08:52,157 --> 00:08:54,750
Y aprenderemos más sobre ellos más adelante.

139
00:08:54,750 --> 00:08:56,670
pero este es un buen caso de uso

140
00:08:56,670 --> 00:09:00,010
que quería usar un temporizador ahora.

141
00:09:00,010 --> 00:09:01,830
Y en realidad es muy simple.

142
00:09:01,830 --> 00:09:05,830
Entonces solo usamos la función de tiempo de espera establecido

143
00:09:06,720 --> 00:09:09,650
y una función de tiempo de espera establecido necesita dos parámetros.

144
00:09:09,650 --> 00:09:13,223
La primera es una función que se ejecutará, está bien.

145
00:09:15,290 --> 00:09:19,610
Y esta función se ejecutará después de un cierto tiempo.

146
00:09:19,610 --> 00:09:23,010
Por ejemplo, podemos especificar 1.000 milisegundos

147
00:09:23,010 --> 00:09:26,180
porque el segundo argumento aquí es milisegundos.

148
00:09:26,180 --> 00:09:28,530
Y eso significará que cualquier código

149
00:09:28,530 --> 00:09:31,260
está dentro de esta función se ejecutará

150
00:09:31,260 --> 00:09:32,823
después de un segundo.

151
00:09:34,070 --> 00:09:36,340
Déjame hacer eso aquí

152
00:09:36,340 --> 00:09:38,653
solo para que veas esto como un ejemplo.

153
00:09:42,950 --> 00:09:45,730
Así que si nos salvé ahora espera un segundo

154
00:09:45,730 --> 00:09:47,800
y luego aquí ves que aparece el temporizador.

155
00:09:47,800 --> 00:09:49,150
Así que voy a hacer eso de nuevo.

156
00:09:50,470 --> 00:09:53,920
Bien, verás que después de este segundo,

157
00:09:53,920 --> 00:09:56,060
esta función fue ejecutada.

158
00:09:56,060 --> 00:09:59,540
Bien, y entonces esto, como ya aprendimos antes

159
00:09:59,540 --> 00:10:01,810
es esencialmente una función de devolución de llamada.

160
00:10:01,810 --> 00:10:05,210
Y en este caso se llama literalmente más tarde.

161
00:10:05,210 --> 00:10:07,313
Entonces, en este caso, después de un segundo.

162
00:10:08,720 --> 00:10:11,663
Así que vamos a crear una función de devolución de llamada aquí.

163
00:10:13,170 --> 00:10:15,560
Y primero quiero iniciar sesión en la consola.

164
00:10:15,560 --> 00:10:20,560
Ahora estamos abordando todos y luego los n pasajeros.

165
00:10:25,330 --> 00:10:30,220
Y entonces este n aquí es este parámetro de la función.

166
00:10:30,220 --> 00:10:35,190
Así que de esta función madre que esencialmente es la función

167
00:10:35,190 --> 00:10:38,480
o el alcance en el que esta función de devolución de llamada aquí

168
00:10:38,480 --> 00:10:40,040
se está creando.

169
00:10:40,040 --> 00:10:42,080
Y eso, por supuesto, será importante.

170
00:10:42,080 --> 00:10:43,943
para nuestro ejemplo de cierre.

171
00:10:46,066 --> 00:10:49,610
Y luego usemos también la variable perGroup ahora.

172
00:10:49,610 --> 00:10:54,597
Hay tres grupos cada uno con

173
00:11:00,640 --> 00:11:03,480
pasajeros, está bien,

174
00:11:03,480 --> 00:11:06,870
esa es nuestra función y ahora llamémosla.

175
00:11:06,870 --> 00:11:11,870
Y aquí queremos especificar espera y luego veces 1,000

176
00:11:12,690 --> 00:11:16,290
porque vamos a pasar a esperar en segundos.

177
00:11:16,290 --> 00:11:19,240
Y este argumento aquí debe estar en milisegundos.

178
00:11:19,240 --> 00:11:21,863
y entonces solo multiplicamos por 1,000.

179
00:11:23,730 --> 00:11:28,450
Aborde pasajeros, digamos que tenemos 180 pasajeros

180
00:11:29,300 --> 00:11:32,700
y tarda dos, digamos tres segundos.

181
00:11:32,700 --> 00:11:36,170
Así que inmediatamente cuando llamamos a esta función,

182
00:11:36,170 --> 00:11:38,210
esta variable será creada

183
00:11:38,210 --> 00:11:40,580
luego se llamará al tiempo de espera establecido

184
00:11:40,580 --> 00:11:44,390
y básicamente registrará esta función de devolución de llamada aquí.

185
00:11:44,390 --> 00:11:47,330
Y luego eso se llamará después de tres segundos.

186
00:11:47,330 --> 00:11:50,510
Pero inmediatamente también este console.log aquí

187
00:11:50,510 --> 00:11:53,060
será llamado, de acuerdo.

188
00:11:53,060 --> 00:11:57,750
Así que este console.log aquí no esperará estos tres segundos

189
00:11:57,750 --> 00:12:00,910
para que estos establezcan el tiempo de espera para finalizar la devolución de llamada.

190
00:12:00,910 --> 00:12:05,730
Bien, inmediatamente se crea esta variable,

191
00:12:05,730 --> 00:12:09,180
se ejecuta esta función de tiempo de espera establecido y se ejecuta console.log.

192
00:12:09,180 --> 00:12:12,480
Y luego, después de tres segundos, esta función aquí

193
00:12:12,480 --> 00:12:13,870
será ejecutado.

194
00:12:13,870 --> 00:12:17,430
Y entonces, veamos qué sucede con la variable n

195
00:12:17,430 --> 00:12:20,673
ya la variable perGroup que está en esta función.

196
00:12:23,040 --> 00:12:27,340
Inmediatamente obtuvimos este registro y luego de tres segundos,

197
00:12:27,340 --> 00:12:30,840
estamos abordando los 180 y hay tres grupos

198
00:12:30,840 --> 00:12:33,870
con 60 pasajeros cada uno.

199
00:12:33,870 --> 00:12:36,330
Está bien, funcionó.

200
00:12:36,330 --> 00:12:39,860
Y nuevamente, tenga en cuenta que esta función de devolución de llamada aquí

201
00:12:39,860 --> 00:12:42,940
se ejecutó de forma completamente independiente

202
00:12:42,940 --> 00:12:45,570
desde la función de pasajeros a bordo.

203
00:12:45,570 --> 00:12:48,470
Muy bien, pero aún así la función de devolución de llamada

204
00:12:48,470 --> 00:12:51,220
fue capaz de utilizar todas las variables que fueron

205
00:12:51,220 --> 00:12:55,030
en el entorno variable en el que fue creado.

206
00:12:55,030 --> 00:12:57,503
Eso es n y perGroup.

207
00:12:59,000 --> 00:13:01,680
Y una vez más, esta es una señal clara

208
00:13:01,680 --> 00:13:05,250
de un cierre que se está creando, a la derecha.

209
00:13:05,250 --> 00:13:08,660
Entonces, la única forma en que esta función de devolución de llamada aquí

210
00:13:08,660 --> 00:13:11,720
puede tener acceso a las variables que se definen

211
00:13:11,720 --> 00:13:13,473
en la función de pasajeros a bordo

212
00:13:13,473 --> 00:13:18,200
que hace tiempo que terminó la ejecución es si creó un cierre.

213
00:13:18,200 --> 00:13:20,310
Y eso es exactamente lo que sucedió.

214
00:13:20,310 --> 00:13:24,130
Y sí, así es como obtuvimos acceso a perGroup

215
00:13:24,130 --> 00:13:26,730
y también este argumento de la función

216
00:13:26,730 --> 00:13:29,110
así que esto espera aquí, a la derecha.

217
00:13:29,110 --> 00:13:31,280
Entonces, como mencioné en la última lección,

218
00:13:31,280 --> 00:13:34,170
el cierre por supuesto también incluye los argumentos

219
00:13:34,170 --> 00:13:36,320
y eso es porque son realmente solo

220
00:13:36,320 --> 00:13:39,050
una variable local en la función.

221
00:13:39,050 --> 00:13:41,820
Y para terminar, demostremos ahora también

222
00:13:41,820 --> 00:13:45,470
que el cierre sí tiene prioridad

223
00:13:45,470 --> 00:13:47,290
sobre la cadena de escultura.

224
00:13:47,290 --> 00:13:49,590
Así que aquí en el ámbito global,

225
00:13:49,590 --> 00:13:54,323
También voy a crear una variable llamada perGroup equals

226
00:13:56,280 --> 00:13:59,254
y luego solo algo de valor aquí.

227
00:13:59,254 --> 00:14:03,820
Entonces, si la cadena de alcance tuviera prioridad sobre el cierre,

228
00:14:03,820 --> 00:14:05,630
entonces esta función de devolución de llamada aquí

229
00:14:05,630 --> 00:14:08,670
de hecho usaría esta variable aquí

230
00:14:08,670 --> 00:14:10,120
esta variable global

231
00:14:10,120 --> 00:14:12,620
porque podemos imaginar esta función aquí

232
00:14:12,620 --> 00:14:16,740
básicamente siendo ejecutado en el ámbito global, está bien.

233
00:14:16,740 --> 00:14:20,120
Entonces, si no fuera por el cierre, usaría esto.

234
00:14:20,120 --> 00:14:22,210
Así que déjame demostrarte eso.

235
00:14:22,210 --> 00:14:24,880
Entonces, si elimino esta variable,

236
00:14:24,880 --> 00:14:27,090
entonces podrá usar el perGroup

237
00:14:29,570 --> 00:14:31,510
y los datos están aquí afuera.

238
00:14:31,510 --> 00:14:33,880
Así que de hecho ahora tenemos 1,000

239
00:14:33,880 --> 00:14:36,230
pero luego como lo volvemos a poner aquí

240
00:14:36,230 --> 00:14:40,490
entonces la función de devolución de llamada se cerrará sobre esta variable.

241
00:14:40,490 --> 00:14:41,750
Entonces se cerrará

242
00:14:41,750 --> 00:14:45,290
todo el entorno variable de hecho.

243
00:14:45,290 --> 00:14:50,290
Y entonces entonces usará este año primero, correcto.

244
00:14:50,570 --> 00:14:52,100
Y lo hizo.

245
00:14:52,100 --> 00:14:56,530
Entonces, de hecho, una divulgación incluso tiene prioridad

246
00:14:56,530 --> 00:14:57,633
sobre la cadena de escultura.

247
00:14:58,690 --> 00:15:00,370
Bien, y con esto,

248
00:15:00,370 --> 00:15:04,180
terminamos estas dos conferencias sobre los cierres

249
00:15:04,180 --> 00:15:06,080
y esperan que después de este,

250
00:15:06,080 --> 00:15:10,320
ahora puede identificar un poco mejor los cierres

251
00:15:10,320 --> 00:15:14,520
como suceden en su código o incluso aquí en mi código

252
00:15:14,520 --> 00:15:15,730
a lo largo de los códigos

253
00:15:15,730 --> 00:15:18,790
porque veremos algunos cierres ocurriendo

254
00:15:18,790 --> 00:15:21,130
algunas veces más en el futuro.

255
00:15:21,130 --> 00:15:23,990
Ahora todo lo que queda por hacer es el desafío de la codificación.

256
00:15:23,990 --> 00:15:26,320
en el proximo video donde estaras pensando

257
00:15:26,320 --> 00:15:28,323
sobre los cierres una vez más.