1
00:00:01,250 --> 00:00:04,570
Ahora es el momento de ver el alcance en acción

2
00:00:04,570 --> 00:00:07,450
en un ejemplo semicomplejo,

3
00:00:07,450 --> 00:00:09,260
para asegurarte de que realmente obtienes

4
00:00:09,260 --> 00:00:11,473
el concepto súper importante.

5
00:00:13,060 --> 00:00:14,350
Y como siempre,

6
00:00:14,350 --> 00:00:18,500
comencemos abriendo una nueva ventana de VS Code

7
00:00:18,500 --> 00:00:20,203
con (murmura) archivos de inicio.

8
00:00:23,010 --> 00:00:25,343
Eso ya está aquí en mi escritorio.

9
00:00:28,170 --> 00:00:29,003
Y otra vez,

10
00:00:29,003 --> 00:00:30,963
Tengo la configuración más bonita aquí.

11
00:00:32,000 --> 00:00:34,533
El índice no es realmente importante aquí.

12
00:00:36,120 --> 00:00:37,890
Y entonces empecemos a escribir

13
00:00:37,890 --> 00:00:39,910
algo de código JavaScript aquí.

14
00:00:39,910 --> 00:00:41,910
Y voy a empezar escribiendo un

15
00:00:41,910 --> 00:00:44,000
función de cálculo simple.

16
00:00:44,000 --> 00:00:47,270
Y esta vez usemos una declaración de función.

17
00:00:47,270 --> 00:00:49,100
No es que importe.

18
00:00:49,100 --> 00:00:51,160
Pero solo para tener algo de diversidad,

19
00:00:51,160 --> 00:00:54,033
y no siempre crean el mismo tipo de función.

20
00:00:55,477 --> 00:00:56,750
Yo sé calcAge,

21
00:00:56,750 --> 00:00:59,063
que va a recibir un año de nacimiento.

22
00:01:03,780 --> 00:01:05,680
Y luego toda esta función hace

23
00:01:05,680 --> 00:01:07,393
es calcular una edad.

24
00:01:08,400 --> 00:01:11,310
Y entonces esto no es nada nuevo en este punto.

25
00:01:11,310 --> 00:01:12,863
Así que el año en curso,

26
00:01:13,800 --> 00:01:17,063
menos el año de nacimiento.

27
00:01:17,910 --> 00:01:19,280
Entonces vamos también

28
00:01:21,070 --> 00:01:23,133
devuelve esa edad aquí.

29
00:01:24,220 --> 00:01:26,780
Y entonces esta función calcAge aquí es,

30
00:01:26,780 --> 00:01:28,730
como aprendimos en la última lección,

31
00:01:28,730 --> 00:01:30,870
definida en un ámbito global.

32
00:01:30,870 --> 00:01:32,240
Y eso es porque es

33
00:01:32,240 --> 00:01:35,200
aquí en el código de nivel superior, ¿verdad?

34
00:01:35,200 --> 00:01:39,010
Además, esta función aquí crea su propio alcance.

35
00:01:39,010 --> 00:01:41,470
Y ese alcance va a ser equivalente

36
00:01:41,470 --> 00:01:43,300
al entorno variable

37
00:01:43,300 --> 00:01:45,720
de su contexto de ejecución.

38
00:01:45,720 --> 00:01:47,430
Así que eso es todo lo que aprendimos

39
00:01:47,430 --> 00:01:50,480
en el último par de conferencias.

40
00:01:50,480 --> 00:01:53,993
Y ahora vamos a crear una variable global aquí.

41
00:01:55,630 --> 00:01:57,580
Así que voy a llamar a ese

42
00:01:57,580 --> 00:01:59,403
nombre de pila.

43
00:02:02,060 --> 00:02:04,770
Y ahora llamemos a la función

44
00:02:06,290 --> 00:02:07,483
Yo sé calcAge,

45
00:02:09,240 --> 00:02:11,410
con 1991.

46
00:02:11,410 --> 00:02:14,550
Y luego aquí dentro de esta función calcAge,

47
00:02:14,550 --> 00:02:17,063
Registraré el nombre en la consola.

48
00:02:20,660 --> 00:02:23,180
Así que primer nombre.

49
00:02:23,180 --> 00:02:24,140
Ahora como ves,

50
00:02:24,140 --> 00:02:27,760
esta variable de nombre no está realmente en este ámbito

51
00:02:27,760 --> 00:02:29,770
de la función calcAge.

52
00:02:29,770 --> 00:02:32,230
Sin embargo, es una variable global.

53
00:02:32,230 --> 00:02:34,100
que definimos aquí.

54
00:02:34,100 --> 00:02:35,110
Y por lo tanto,

55
00:02:35,110 --> 00:02:36,290
a través de la cadena de alcance,

56
00:02:36,290 --> 00:02:38,110
va a estar disponible

57
00:02:38,110 --> 00:02:40,430
también dentro de este ámbito.

58
00:02:40,430 --> 00:02:42,533
Así que dentro de esta función, ¿verdad?

59
00:02:43,430 --> 00:02:46,293
Así que ejecutemos este código aquí,

60
00:02:47,270 --> 00:02:49,630
solo para ver que realmente funciona.

61
00:02:49,630 --> 00:02:52,510
Y luego vamos a explicar un poco más.

62
00:02:52,510 --> 00:02:54,853
Entonces servidor en vivo.

63
00:02:58,400 --> 00:03:00,510
Y aquí vamos.

64
00:03:00,510 --> 00:03:02,423
Abramos la consola.

65
00:03:07,880 --> 00:03:10,053
Vamos a recargar para deshacernos de este error.

66
00:03:10,949 --> 00:03:11,782
Y bien

67
00:03:13,210 --> 00:03:14,990
Entonces ves que en efecto,

68
00:03:14,990 --> 00:03:17,320
Jonas aquí fue impreso en la consola,

69
00:03:17,320 --> 00:03:19,840
que es la primera variable de nombre.

70
00:03:19,840 --> 00:03:23,170
Entonces, cuando se ejecutó esta línea de código aquí,

71
00:03:23,170 --> 00:03:26,950
JavaScript no encontró esta variable en el alcance.

72
00:03:26,950 --> 00:03:29,380
Y entonces hizo una búsqueda de variables,

73
00:03:29,380 --> 00:03:31,500
dónde miró hacia arriba en la cadena de alcance

74
00:03:31,500 --> 00:03:34,150
para ver si encontró la variable allí.

75
00:03:34,150 --> 00:03:36,050
Y, de hecho, el ámbito principal

76
00:03:36,050 --> 00:03:38,980
de la función calcAge es el alcance global.

77
00:03:38,980 --> 00:03:41,530
Y la variable del primer nombre está ahí,

78
00:03:41,530 --> 00:03:44,690
y, por lo tanto, JavaScript podría usar eso.

79
00:03:44,690 --> 00:03:45,830
Ahora aquí, si lo intentamos,

80
00:03:45,830 --> 00:03:48,070
por ejemplo solo nombre,

81
00:03:48,070 --> 00:03:50,570
entonces JavaScript también haría una búsqueda,

82
00:03:50,570 --> 00:03:53,630
pero no encontraría esta variable en el ámbito global.

83
00:03:53,630 --> 00:03:56,250
Y por lo tanto, obtendríamos un error.

84
00:03:56,250 --> 00:03:57,310
Ahora con esta variable,

85
00:03:57,310 --> 00:03:59,350
en realidad no obtendríamos ningún error.

86
00:03:59,350 --> 00:04:01,000
Como te expliqué al principio,

87
00:04:01,000 --> 00:04:02,390
esto es algo especial

88
00:04:02,390 --> 00:04:04,850
nombre de variable que no debemos usar.

89
00:04:04,850 --> 00:04:07,560
Así que digamos que usé el apellido.

90
00:04:07,560 --> 00:04:09,360
Y así de nuevo, esta variable

91
00:04:09,360 --> 00:04:11,150
no se encuentra por ningún lado.

92
00:04:11,150 --> 00:04:12,910
Así que incluso mirando hacia arriba

93
00:04:12,910 --> 00:04:14,400
en el ámbito principal,

94
00:04:14,400 --> 00:04:15,953
y ahora, cuando guardé esto,

95
00:04:17,040 --> 00:04:20,623
luego obtengo este apellido que no define el error.

96
00:04:21,500 --> 00:04:22,670
¿Bueno?

97
00:04:22,670 --> 00:04:25,053
Y entonces, volviendo aquí al primer nombre,

98
00:04:26,090 --> 00:04:27,200
entonces por supuesto,

99
00:04:27,200 --> 00:04:29,120
todo funciona igual.

100
00:04:29,120 --> 00:04:30,060
Y eso es cierto,

101
00:04:30,060 --> 00:04:31,980
aunque esta variable aquí

102
00:04:31,980 --> 00:04:36,080
en realidad se definió después de la función calcAge.

103
00:04:36,080 --> 00:04:37,930
Pero eso no es un problema en absoluto.

104
00:04:37,930 --> 00:04:41,160
Porque recuerda que el código en la función

105
00:04:41,160 --> 00:04:44,730
solo se ejecuta una vez que se llama.

106
00:04:44,730 --> 00:04:46,840
Y eso sucede después

107
00:04:46,840 --> 00:04:50,080
la declaración de la variable del nombre.

108
00:04:50,080 --> 00:04:51,640
Así que aquí mismo.

109
00:04:51,640 --> 00:04:53,430
Y así, en este punto del código,

110
00:04:53,430 --> 00:04:55,700
la variable del primer nombre ya está

111
00:04:55,700 --> 00:04:58,880
en el entorno de variables de ejecución global.

112
00:04:58,880 --> 00:05:02,470
Así que en el ámbito global, listo para ser utilizado.

113
00:05:02,470 --> 00:05:06,470
Está bien, pero vamos a deshacernos de esto aquí.

114
00:05:06,470 --> 00:05:10,563
Y vamos a crear otra función dentro de esta función.

115
00:05:11,660 --> 00:05:15,123
Entonces funcion, printAge

116
00:05:15,123 --> 00:05:18,380
y esto imprimirá una buena cadena en la consola.

117
00:05:18,380 --> 00:05:21,040
Y como también ya sabes,

118
00:05:21,040 --> 00:05:23,350
también crea un nuevo alcance.

119
00:05:23,350 --> 00:05:25,650
Y vamos a crear una variable de salida,

120
00:05:25,650 --> 00:05:27,480
cual va a ser la cuerda

121
00:05:27,480 --> 00:05:28,793
que construiremos aquí.

122
00:05:30,040 --> 00:05:33,083
Entonces la salida es igual,

123
00:05:34,280 --> 00:05:35,280
eres

124
00:05:37,050 --> 00:05:38,570
la edad,

125
00:05:38,570 --> 00:05:40,800
y me olvidé de las llaves

126
00:05:41,870 --> 00:05:43,400
nacido en

127
00:05:46,990 --> 00:05:47,863
Año de nacimiento.

128
00:05:49,470 --> 00:05:54,150
Y luego simplemente registramos ese mensaje en la consola.

129
00:05:54,150 --> 00:05:56,530
Y ahora para ver este resultado aquí,

130
00:05:56,530 --> 00:05:59,380
necesitamos, por supuesto, llamar a la función.

131
00:05:59,380 --> 00:06:00,853
Entonces, hagámoslo aquí.

132
00:06:02,070 --> 00:06:02,903
Entonces imprimirEdad.

133
00:06:05,100 --> 00:06:07,850
Y ahora obtenemos una cadena con todos los datos.

134
00:06:07,850 --> 00:06:09,930
que en realidad calculamos,

135
00:06:09,930 --> 00:06:11,530
Y funciona bien.

136
00:06:11,530 --> 00:06:14,110
Entonces obtenemos la edad que se calculó aquí,

137
00:06:14,110 --> 00:06:15,590
y tambien el año de nacimiento

138
00:06:15,590 --> 00:06:18,150
que se pasó a esta función.

139
00:06:18,150 --> 00:06:19,190
Y así aquí de nuevo,

140
00:06:19,190 --> 00:06:22,900
vemos la magia de la cadena de alcance en acción.

141
00:06:22,900 --> 00:06:24,370
Así que una vez más,

142
00:06:24,370 --> 00:06:28,260
el motor mientras ejecuta esta función printAge

143
00:06:28,260 --> 00:06:29,670
está tratando de acceder

144
00:06:29,670 --> 00:06:32,270
o está tratando de encontrar la variable edad

145
00:06:32,270 --> 00:06:33,670
en el ámbito actual,

146
00:06:33,670 --> 00:06:35,890
sin embargo, no puede encontrarlo allí.

147
00:06:35,890 --> 00:06:36,723
Y por lo tanto,

148
00:06:36,723 --> 00:06:38,400
va al ámbito principal,

149
00:06:38,400 --> 00:06:40,200
donde luego encontrara

150
00:06:40,200 --> 00:06:42,120
esta variable de edad, por supuesto,

151
00:06:42,120 --> 00:06:43,283
que creamos aquí.

152
00:06:44,172 --> 00:06:47,210
Y lo mismo ocurre con la variable año de nacimiento,

153
00:06:47,210 --> 00:06:48,770
porque para el alcance

154
00:06:48,770 --> 00:06:50,410
el parámetro de una función

155
00:06:50,410 --> 00:06:53,620
funcionan como variables normales.

156
00:06:53,620 --> 00:06:55,770
Y también recuerda que dijimos

157
00:06:55,770 --> 00:06:58,030
que el alcance de una variable

158
00:06:58,030 --> 00:06:59,810
es toda la región del código

159
00:06:59,810 --> 00:07:02,660
en el que la variable es accesible.

160
00:07:02,660 --> 00:07:03,780
Así por ejemplo,

161
00:07:03,780 --> 00:07:05,907
el alcance de la variable edad

162
00:07:05,907 --> 00:07:08,480
es toda esta área aquí.

163
00:07:08,480 --> 00:07:09,884
Así que en todas partes aquí,

164
00:07:09,884 --> 00:07:11,950
la variable edad es accesible.

165
00:07:13,270 --> 00:07:14,103
Asi que por su puesto,

166
00:07:14,103 --> 00:07:16,610
en la función calcAge, donde se definió,

167
00:07:16,610 --> 00:07:19,630
y luego también en todos los ámbitos secundarios,

168
00:07:19,630 --> 00:07:22,010
así que todos los ámbitos internos, ¿de acuerdo?

169
00:07:22,010 --> 00:07:25,410
Pero, por supuesto, la edad no es accesible fuera

170
00:07:25,410 --> 00:07:27,750
del alcance de calcAge.

171
00:07:27,750 --> 00:07:29,843
Así que permítanme demostrar eso aquí.

172
00:07:31,640 --> 00:07:33,570
Así que aquí, no podremos

173
00:07:33,570 --> 00:07:35,800
para acceder a la variable edad.

174
00:07:35,800 --> 00:07:38,550
Y eso es porque como mencioné,

175
00:07:38,550 --> 00:07:41,440
la cadena de alcance es una calle de sentido único.

176
00:07:41,440 --> 00:07:43,050
Entonces solo un alcance interno

177
00:07:43,050 --> 00:07:46,570
puede tener acceso a las variables de su ámbito externo,

178
00:07:46,570 --> 00:07:48,250
pero no al revés.

179
00:07:48,250 --> 00:07:50,460
Así que ahora aquí estamos en el ámbito exterior,

180
00:07:50,460 --> 00:07:53,850
y no podemos tener acceso a las variables

181
00:07:53,850 --> 00:07:55,530
de un ámbito de niño,

182
00:07:55,530 --> 00:07:58,370
cuál es el alcance de la función calcAge aquí

183
00:07:59,690 --> 00:08:01,800
seguramente lo es, ¿de acuerdo?

184
00:08:01,800 --> 00:08:04,160
Y lo mismo ocurre con las funciones de nuevo.

185
00:08:04,160 --> 00:08:07,920
Y entonces no podemos llamar a la función imprimirEdad aquí,

186
00:08:07,920 --> 00:08:09,363
por la misma razón.

187
00:08:10,930 --> 00:08:12,863
Comentemos esto.

188
00:08:14,070 --> 00:08:17,063
Y ahora obtenemos que printAge no está definido.

189
00:08:18,150 --> 00:08:18,983
¿Bueno?

190
00:08:18,983 --> 00:08:21,140
Así que aquí en el ámbito global,

191
00:08:21,140 --> 00:08:24,860
no tenemos acceso a ninguna variable definida

192
00:08:24,860 --> 00:08:26,293
en cualquier otro ámbito.

193
00:08:28,070 --> 00:08:29,530
Ahora, ¿de acuerdo?

194
00:08:29,530 --> 00:08:32,840
Y aquí, llevémoslo al siguiente nivel,

195
00:08:32,840 --> 00:08:36,023
y también incluir el nombre de la persona.

196
00:08:37,080 --> 00:08:39,573
Así que digamos, primer nombre.

197
00:08:41,030 --> 00:08:43,280
Y probemos esto ahora.

198
00:08:43,280 --> 00:08:45,560
Y de hecho, tiene acceso

199
00:08:45,560 --> 00:08:47,520
a la variable del primer nombre.

200
00:08:47,520 --> 00:08:48,353
Y así aquí,

201
00:08:48,353 --> 00:08:50,730
el motor está haciendo un aún más grande,

202
00:08:50,730 --> 00:08:52,903
o una búsqueda de variables más larga.

203
00:08:53,940 --> 00:08:56,200
Así que ahora mismo, por supuesto,

204
00:08:56,200 --> 00:08:58,540
en el alcance de printAge aquí.

205
00:08:58,540 --> 00:09:01,550
Entonces JavaScript no puede encontrar una variable

206
00:09:01,550 --> 00:09:02,780
en el ámbito actual.

207
00:09:02,780 --> 00:09:04,970
Entonces busca en la cadena de alcance,

208
00:09:04,970 --> 00:09:07,400
que es entonces el siguiente paso,

209
00:09:07,400 --> 00:09:08,970
la función calcEdad.

210
00:09:08,970 --> 00:09:13,110
Sin embargo, tampoco puede encontrar el nombre en este ámbito,

211
00:09:13,110 --> 00:09:15,600
y por lo tanto sube aún más

212
00:09:15,600 --> 00:09:17,130
en el ámbito global.

213
00:09:17,130 --> 00:09:18,720
Y ahí está.

214
00:09:18,720 --> 00:09:20,170
Y este es el valor

215
00:09:20,170 --> 00:09:21,423
que se va a utilizar.

216
00:09:22,300 --> 00:09:24,430
Bien, entonces espero

217
00:09:24,430 --> 00:09:27,230
todo esto tenía sentido hasta este punto.

218
00:09:27,230 --> 00:09:28,630
Ahora vayamos más lejos

219
00:09:28,630 --> 00:09:30,750
y también crear un ámbito de bloque

220
00:09:30,750 --> 00:09:33,600
aquí mismo en esta función printAge.

221
00:09:33,600 --> 00:09:36,193
Así que hagamos una declaración if aquí.

222
00:09:37,060 --> 00:09:39,390
Y comprobaremos si la persona

223
00:09:39,390 --> 00:09:42,190
basado en el año de nacimiento es un millennial.

224
00:09:42,190 --> 00:09:44,120
Y asi es si naciste

225
00:09:44,120 --> 00:09:47,450
entre 1981 y 1996.

226
00:09:47,450 --> 00:09:48,950
Entonces eres un millennial,

227
00:09:48,950 --> 00:09:50,350
y entonces vamos a verificar eso.

228
00:09:51,430 --> 00:09:54,220
Así que el año de nacimiento debe ser

229
00:09:54,220 --> 00:09:56,080
al menos 1981

230
00:09:58,760 --> 00:09:59,803
y por debajo,

231
00:10:02,210 --> 00:10:04,003
por debajo de 1996.

232
00:10:06,994 --> 00:10:09,110
Y aquí estamos creando un bloque.

233
00:10:09,110 --> 00:10:13,370
Y por lo tanto, este será un nuevo ámbito de bloque.

234
00:10:13,370 --> 00:10:14,730
Y entonces vamos ahora

235
00:10:14,730 --> 00:10:17,663
defina una variable aquí usando const.

236
00:10:19,150 --> 00:10:21,030
Y lo llamaré cuerda.

237
00:10:21,030 --> 00:10:21,863
Y digamos,

238
00:10:23,160 --> 00:10:26,300
así que primero llevamos esta cadena aquí a la consola.

239
00:10:26,300 --> 00:10:27,890
Y entonces también podemos decir,

240
00:10:27,890 --> 00:10:29,500
entonces si la persona es millennial,

241
00:10:29,500 --> 00:10:30,530
diremos,

242
00:10:30,530 --> 00:10:34,460
Ah, y eres un millennial.

243
00:10:36,830 --> 00:10:38,633
Y luego otra vez, el primer nombre.

244
00:10:40,240 --> 00:10:41,610
Y ahora estamos agregando

245
00:10:41,610 --> 00:10:43,180
incluso un paso más aquí

246
00:10:43,180 --> 00:10:44,660
a la cadena de alcance,

247
00:10:44,660 --> 00:10:48,000
porque ahora la búsqueda de nombre

248
00:10:48,000 --> 00:10:50,010
es aún más largo.

249
00:10:50,010 --> 00:10:51,723
Pero aún funcionará.

250
00:10:53,320 --> 00:10:55,713
Así que déjame registrar eso en la consola.

251
00:10:59,220 --> 00:11:00,700
Y así en este caso,

252
00:11:00,700 --> 00:11:03,560
Claramente soy un millennial, ¿de acuerdo?

253
00:11:03,560 --> 00:11:06,920
Y de nuevo, Jonas aquí todavía se encuentra

254
00:11:06,920 --> 00:11:07,820
todo el camino hasta aquí

255
00:11:07,820 --> 00:11:09,433
desde el ámbito exterior.

256
00:11:10,550 --> 00:11:12,790
Pero ahora, ¿qué crees que pasará?

257
00:11:12,790 --> 00:11:15,490
mientras tratamos de registrar esta variable

258
00:11:15,490 --> 00:11:18,230
fuera de este ámbito de bloque?

259
00:11:18,230 --> 00:11:19,780
Así que básicamente haz lo mismo,

260
00:11:19,780 --> 00:11:21,963
pero fuera del bloque.

261
00:11:23,590 --> 00:11:28,590
De hecho, obtenemos un error de que str no está definido.

262
00:11:28,780 --> 00:11:32,500
Y de nuevo, eso es porque las variables const y let

263
00:11:32,500 --> 00:11:34,210
tienen alcance de bloque.

264
00:11:34,210 --> 00:11:35,620
Entonces son válidos.

265
00:11:35,620 --> 00:11:39,130
Entonces están disponibles solo dentro del bloque.

266
00:11:39,130 --> 00:11:40,573
en que fueron creados.

267
00:11:41,870 --> 00:11:45,560
Pero ahora observe cómo creamos otra variable más,

268
00:11:45,560 --> 00:11:47,283
que llamaré millennial.

269
00:11:50,020 --> 00:11:51,683
Y pongámoslo en verdadero.

270
00:11:52,960 --> 00:11:56,560
Y entonces esta es una antigua variable anterior a ES6.

271
00:11:56,560 --> 00:11:59,530
Y entonces, ¿qué crees que va a pasar,

272
00:11:59,530 --> 00:12:02,903
como lo registramos, también aquí fuera de este bloque?

273
00:12:05,170 --> 00:12:06,920
Así que tenemos que comentar esto.

274
00:12:08,230 --> 00:12:12,010
Así que de nuevo, ¿qué crees que va a pasar ahora?

275
00:12:12,010 --> 00:12:15,620
Y JavaScript realmente puede encontrarlo.

276
00:12:15,620 --> 00:12:17,650
Y eso es por el hecho

277
00:12:17,650 --> 00:12:19,830
que var variables,

278
00:12:19,830 --> 00:12:22,660
entonces las variables declaradas con la palabra clave var

279
00:12:22,660 --> 00:12:24,420
están en el ámbito de la función.

280
00:12:24,420 --> 00:12:26,480
Así que simplemente ignoran el bloqueo,

281
00:12:26,480 --> 00:12:29,180
porque no tienen un alcance de bloque en absoluto.

282
00:12:29,180 --> 00:12:30,910
Solo tienen un alcance de función.

283
00:12:30,910 --> 00:12:33,373
Y entonces aquí, todavía estamos en la misma función.

284
00:12:34,310 --> 00:12:35,250
Así que aquí,

285
00:12:35,250 --> 00:12:37,330
aquí estamos tratando de acceder a la variable

286
00:12:37,330 --> 00:12:41,990
que se definió en la misma función, ¿verdad?

287
00:12:41,990 --> 00:12:42,890
Así que ahora mismo,

288
00:12:42,890 --> 00:12:45,070
el alcance de la variable millennial

289
00:12:45,070 --> 00:12:47,120
es toda esta función,

290
00:12:47,120 --> 00:12:51,050
sin importar si fue declarado dentro de un bloque o no.

291
00:12:51,050 --> 00:12:54,470
Porque de nuevo, a las variables var no les importa

292
00:12:54,470 --> 00:12:56,110
sobre bloques en absoluto.

293
00:12:56,110 --> 00:12:57,090
Y por lo tanto,

294
00:12:57,090 --> 00:12:59,950
luego podemos acceder a la variable millennial

295
00:12:59,950 --> 00:13:01,890
dentro de su alcance.

296
00:13:01,890 --> 00:13:02,860
¿Bueno?

297
00:13:02,860 --> 00:13:05,400
Así que tenlo en cuenta mientras usas,

298
00:13:05,400 --> 00:13:08,200
o como ves una variable declarada

299
00:13:08,200 --> 00:13:10,250
con var, verdad?

300
00:13:10,250 --> 00:13:12,290
Porque, como dije,

301
00:13:12,290 --> 00:13:14,610
por su cuenta, probablemente no debería usar

302
00:13:14,610 --> 00:13:16,370
esta variable usted mismo,

303
00:13:16,370 --> 00:13:19,210
siempre use const, o let.

304
00:13:19,210 --> 00:13:21,740
Pero si está leyendo otras bases de código,

305
00:13:21,740 --> 00:13:24,120
o incluso trabajar con código antiguo,

306
00:13:24,120 --> 00:13:25,660
entonces ten en cuenta

307
00:13:25,660 --> 00:13:28,660
que así es como funciona la variable var.

308
00:13:28,660 --> 00:13:30,490
Y por eso es muy importante

309
00:13:30,490 --> 00:13:33,820
para aprender sobre str también.

310
00:13:33,820 --> 00:13:35,410
Bien, el siguiente,

311
00:13:35,410 --> 00:13:39,160
Probemos que las funciones también son de hecho,

312
00:13:39,160 --> 00:13:41,733
ámbito de bloque a partir de ES6.

313
00:13:43,490 --> 00:13:45,080
Así que vamos a crear un simple

314
00:13:46,440 --> 00:13:48,763
función aquí, que sumará dos valores.

315
00:13:52,730 --> 00:13:55,253
Devuelve A más B.

316
00:13:56,440 --> 00:13:58,020
y luego vamos

317
00:13:59,410 --> 00:14:02,273
intente llamarlo aquí fuera del bloque.

318
00:14:04,720 --> 00:14:07,293
Así que suma dos y tres.

319
00:14:08,960 --> 00:14:12,290
Y ahora obtenemos agregar no está definido.

320
00:14:12,290 --> 00:14:14,060
Y así de hecho,

321
00:14:14,060 --> 00:14:17,120
el alcance de esta función de añadir aquí

322
00:14:17,120 --> 00:14:20,380
es sólo el bloque en el que se definió.

323
00:14:20,380 --> 00:14:21,310
Así que solo aquí,

324
00:14:21,310 --> 00:14:23,300
Podemos usar la función de agregar.

325
00:14:23,300 --> 00:14:25,210
Y eso prueba que

326
00:14:25,210 --> 00:14:28,230
las funciones son ahora, de hecho, de ámbito de bloque.

327
00:14:28,230 --> 00:14:32,120
Pero recuerda que eso solo es cierto para el modo estricto.

328
00:14:32,120 --> 00:14:33,060
Y ese es el modo

329
00:14:33,060 --> 00:14:34,890
en el que estamos actualmente.

330
00:14:34,890 --> 00:14:36,660
Pero si apago esto,

331
00:14:36,660 --> 00:14:40,673
deberías ver ahora agregar que te llaman.

332
00:14:42,430 --> 00:14:46,563
Así que registremos el resultado de eso en la consola.

333
00:14:48,320 --> 00:14:50,003
Y ahora deberíamos ver cinco.

334
00:14:50,840 --> 00:14:52,503
Y efectivamente, ahora funciona.

335
00:14:54,240 --> 00:14:55,150
¿Ahora a la derecha?

336
00:14:55,150 --> 00:14:57,820
Pero siempre debemos usar el modo estricto.

337
00:14:57,820 --> 00:15:00,910
Y ahora deberíamos recuperar ese error.

338
00:15:00,910 --> 00:15:03,470
Y entonces, también comentemos esto.

339
00:15:03,470 --> 00:15:05,913
Y así puedes guardar esto aquí como referencia.

340
00:15:06,750 --> 00:15:07,590
Bueno.

341
00:15:07,590 --> 00:15:08,963
Y ahora a terminar.

342
00:15:10,070 --> 00:15:12,470
Hagamos algunos experimentos aquí.

343
00:15:12,470 --> 00:15:14,300
Entonces, ¿qué crees que va a pasar?

344
00:15:14,300 --> 00:15:17,493
si declaramos una variable en este ámbito aquí?

345
00:15:18,800 --> 00:15:21,980
Entonces, en este nuevo alcance de bloque que ya existe

346
00:15:21,980 --> 00:15:23,960
en un ámbito principal?

347
00:15:23,960 --> 00:15:26,073
Entonces, por ejemplo, digamos aquí,

348
00:15:27,630 --> 00:15:28,463
constante

349
00:15:30,410 --> 00:15:32,970
primer nombre, igual

350
00:15:34,900 --> 00:15:36,230
steven

351
00:15:36,230 --> 00:15:39,280
Entonces, ¿qué te parece esta cadena aquí?

352
00:15:39,280 --> 00:15:41,300
se verá como ahora?

353
00:15:41,300 --> 00:15:42,840
¿Entonces crees que aquí,

354
00:15:42,840 --> 00:15:45,283
dirá Jonas o Steven?

355
00:15:46,170 --> 00:15:47,553
Bueno, intentémoslo.

356
00:15:48,610 --> 00:15:49,800
Y de hecho,

357
00:15:49,800 --> 00:15:52,040
ahora dice Steven,

358
00:15:52,040 --> 00:15:52,910
y eso pasa,

359
00:15:52,910 --> 00:15:54,480
porque como siempre,

360
00:15:54,480 --> 00:15:57,410
JavaScript intenta buscar el nombre de la variable

361
00:15:57,410 --> 00:15:58,900
en el ámbito actual.

362
00:15:58,900 --> 00:16:02,620
Y en este momento, en realidad está en el ámbito actual.

363
00:16:02,620 --> 00:16:06,350
Entonces, el primer nombre está, de hecho, en este mismo bloque.

364
00:16:06,350 --> 00:16:07,930
Entonces, en este mismo ámbito,

365
00:16:07,930 --> 00:16:11,600
y por lo tanto, JavaScript usará esa variable

366
00:16:11,600 --> 00:16:14,670
y no realizar ninguna búsqueda de variables

367
00:16:14,670 --> 00:16:16,010
en la cadena de alcance.

368
00:16:16,010 --> 00:16:17,070
Así que la cadena de alcance

369
00:16:17,070 --> 00:16:18,780
no es necesario en absoluto,

370
00:16:18,780 --> 00:16:21,070
si la variable que estamos buscando

371
00:16:21,070 --> 00:16:23,510
ya está en el ámbito actual.

372
00:16:23,510 --> 00:16:27,400
Y ese es exactamente el caso aquí.

373
00:16:27,400 --> 00:16:28,233
Pero por supuesto,

374
00:16:28,233 --> 00:16:30,047
entonces fuera de este bloque,

375
00:16:30,047 --> 00:16:31,990
la variable del primer nombre

376
00:16:31,990 --> 00:16:33,530
todavía va a ser el

377
00:16:33,530 --> 00:16:35,770
procedente de la cadena de ámbito.

378
00:16:35,770 --> 00:16:36,780
Entonces por eso aquí,

379
00:16:36,780 --> 00:16:38,133
todavía ves a Jonas.

380
00:16:39,620 --> 00:16:41,950
Así que aquí mismo en la función imprimirEdad,

381
00:16:41,950 --> 00:16:43,890
que es otro alcance.

382
00:16:43,890 --> 00:16:48,123
Entonces, es el ámbito principal de este ámbito, ¿verdad?

383
00:16:49,120 --> 00:16:52,490
Y aquí, el primer nombre sigue siendo Jonas,

384
00:16:52,490 --> 00:16:56,410
porque no está en el alcance actual de esta función.

385
00:16:56,410 --> 00:16:59,740
Y por lo tanto, JavaScript hará una búsqueda de variables

386
00:16:59,740 --> 00:17:00,960
en la cadena de alcance,

387
00:17:00,960 --> 00:17:03,050
hasta que pueda encontrar el nombre,

388
00:17:03,050 --> 00:17:04,693
que sigue siendo Jonas,

389
00:17:06,120 --> 00:17:07,453
viniendo de aquí abajo.

390
00:17:08,560 --> 00:17:12,130
Así que aquí creamos una nueva variable

391
00:17:12,130 --> 00:17:14,403
con el mismo nombre de otra variable

392
00:17:14,403 --> 00:17:17,770
que ya habíamos creado en un ámbito principal.

393
00:17:17,770 --> 00:17:21,010
Así que tenemos dos variables de nombre en este momento.

394
00:17:21,010 --> 00:17:23,180
Pero eso no es un problema en absoluto.

395
00:17:23,180 --> 00:17:24,370
Porque de hecho,

396
00:17:24,370 --> 00:17:26,900
son variables completamente diferentes,

397
00:17:26,900 --> 00:17:29,380
simplemente sucede que tienen el mismo nombre.

398
00:17:29,380 --> 00:17:31,220
Pero eso no es un problema en absoluto,

399
00:17:31,220 --> 00:17:34,250
porque se definen en diferentes ámbitos.

400
00:17:34,250 --> 00:17:36,700
Y así puedes tener nombres de variables repetidos.

401
00:17:36,700 --> 00:17:38,960
Eso no es absolutamente ningún problema.

402
00:17:38,960 --> 00:17:40,270
Y esa es también la razón

403
00:17:40,270 --> 00:17:42,410
por qué puedes tener diferentes funciones

404
00:17:42,410 --> 00:17:44,240
con los mismos nombres de parámetros.

405
00:17:44,240 --> 00:17:45,470
porque de nuevo,

406
00:17:45,470 --> 00:17:48,890
cada parámetro solo se define en ese ámbito

407
00:17:48,890 --> 00:17:50,200
de esa función.

408
00:17:50,200 --> 00:17:52,380
Y por lo tanto, no es un problema en absoluto.

409
00:17:52,380 --> 00:17:56,610
tener muchas funciones con exactamente los mismos nombres de parámetros,

410
00:17:56,610 --> 00:17:58,650
de la misma manera que no es un problema

411
00:17:58,650 --> 00:18:01,320
tener funciones con los mismos nombres de variables

412
00:18:01,320 --> 00:18:03,000
dentro de ellos.

413
00:18:03,000 --> 00:18:07,360
Pero ahora mira lo que sucede cuando redefinimos una variable

414
00:18:07,360 --> 00:18:10,730
desde un ámbito principal dentro de un ámbito interno.

415
00:18:10,730 --> 00:18:12,870
Así que no crear una nueva variable,

416
00:18:12,870 --> 00:18:15,150
pero simplemente reasignando el valor

417
00:18:15,150 --> 00:18:16,313
de una variable

418
00:18:18,170 --> 00:18:20,270
Así que hagamos eso aquí.

419
00:18:20,270 --> 00:18:21,840
Y digamos ahora

420
00:18:21,840 --> 00:18:25,400
la salida es igual

421
00:18:25,400 --> 00:18:29,170
nueva salida

422
00:18:29,170 --> 00:18:30,730
Y aquí tenemos que cambiar

423
00:18:30,730 --> 00:18:32,223
la salida a un let.

424
00:18:33,500 --> 00:18:36,010
Pero analicemos lo que hicimos aquí.

425
00:18:36,010 --> 00:18:39,290
Entonces estamos en el alcance de printAge.

426
00:18:39,290 --> 00:18:41,190
Así que eso es todo esto aquí.

427
00:18:41,190 --> 00:18:44,150
Y aquí, tenemos la variable de salida,

428
00:18:44,150 --> 00:18:46,530
entonces tenemos un ámbito interior,

429
00:18:46,530 --> 00:18:48,630
así que como un alcance infantil aquí,

430
00:18:48,630 --> 00:18:52,260
que luego redefine esta variable de salida

431
00:18:52,260 --> 00:18:53,850
desde el ámbito exterior.

432
00:18:53,850 --> 00:18:57,563
Entonces, si luego tratamos de acceder a esa salida aquí nuevamente,

433
00:19:00,550 --> 00:19:02,603
¿Qué crees que va a pasar?

434
00:19:04,120 --> 00:19:07,360
Bueno, tenemos una nueva salida aquí.

435
00:19:07,360 --> 00:19:10,490
Y eso es porque en realidad manipulamos

436
00:19:10,490 --> 00:19:12,390
una variable existente aquí,

437
00:19:12,390 --> 00:19:14,650
dentro de un ámbito de niño.

438
00:19:14,650 --> 00:19:17,580
Entonces, dentro de un alcance interno, ¿verdad?

439
00:19:17,580 --> 00:19:19,900
No creamos una nueva variable,

440
00:19:19,900 --> 00:19:23,610
simplemente redefinimos una variable a la que accedimos aquí

441
00:19:23,610 --> 00:19:25,083
del ámbito principal.

442
00:19:26,270 --> 00:19:28,660
Así que si creamos un nuevo

443
00:19:28,660 --> 00:19:30,570
variable llamada salida aquí,

444
00:19:30,570 --> 00:19:32,390
entonces tendríamos la misma situación

445
00:19:32,390 --> 00:19:35,520
como antes con el primer nombre.

446
00:19:35,520 --> 00:19:38,510
Entonces esta sería una variable completamente diferente,

447
00:19:38,510 --> 00:19:43,430
y no afectaría en absoluto la salida del alcance externo.

448
00:19:43,430 --> 00:19:45,950
Y ahora que guardamos esto,

449
00:19:45,950 --> 00:19:48,160
entonces esta nueva salida debería desaparecer.

450
00:19:48,160 --> 00:19:50,690
Y debería volver a la salida original.

451
00:19:50,690 --> 00:19:53,053
como lo definimos en el alcance ahora.

452
00:19:54,520 --> 00:19:58,100
De hecho, ahora la nueva salida se ha ido.

453
00:19:58,100 --> 00:19:59,560
Y de nuevo, eso es porque

454
00:19:59,560 --> 00:20:01,950
ahora es su propia variable.

455
00:20:01,950 --> 00:20:03,290
Así que una nueva variable,

456
00:20:03,290 --> 00:20:05,860
que casualmente tiene el mismo nombre

457
00:20:05,860 --> 00:20:08,900
como una variable de su ámbito principal.

458
00:20:08,900 --> 00:20:10,570
Pero para ilustrar esto aquí,

459
00:20:10,570 --> 00:20:13,750
en realidad dejémoslo así.

460
00:20:13,750 --> 00:20:15,113
Y también lo comentaré,

461
00:20:16,960 --> 00:20:21,440
creando una nueva variable con

462
00:20:21,440 --> 00:20:23,050
mismo nombre que

463
00:20:23,940 --> 00:20:25,150
alcances exteriores

464
00:20:27,100 --> 00:20:27,933
variable.

465
00:20:30,330 --> 00:20:32,203
Y vamos a poner esto junto aquí.

466
00:20:37,240 --> 00:20:38,230
reasignación

467
00:20:39,980 --> 00:20:42,280
alcances exteriores

468
00:20:43,790 --> 00:20:45,060
variable.

469
00:20:45,060 --> 00:20:48,000
De nuevo, dos cosas completamente diferentes.

470
00:20:48,000 --> 00:20:50,410
Pero creo que este es un muy buen ejemplo.

471
00:20:50,410 --> 00:20:52,360
para ilustrar una vez más

472
00:20:52,360 --> 00:20:54,610
cómo funciona la cadena de alcance.

473
00:20:54,610 --> 00:20:55,520
Y con esto,

474
00:20:55,520 --> 00:20:58,140
Espero que ahora entiendas completamente

475
00:20:58,140 --> 00:21:01,210
cómo funciona el alcance en JavaScript.

476
00:21:01,210 --> 00:21:02,750
También ten en cuenta

477
00:21:02,750 --> 00:21:04,920
ese código real debería (risas)

478
00:21:04,920 --> 00:21:07,420
probablemente no sea tan confuso,

479
00:21:07,420 --> 00:21:11,143
pero esto fue solo para mostrarle cómo funciona el alcance.