1
00:00:01,180 --> 00:00:04,670
A medida que avanzamos hacia el final de esta sección,

2
00:00:04,670 --> 00:00:06,940
tenemos que aprender acerca de la gran diferencia

3
00:00:06,940 --> 00:00:10,030
entre la forma en que los tipos primitivos y los objetos

4
00:00:10,030 --> 00:00:12,467
se almacenan y la memoria.

5
00:00:12,467 --> 00:00:15,760
Y esto es en realidad un aspecto muy práctico.

6
00:00:15,760 --> 00:00:20,290
y uno que causa mucha confusión en los principiantes.

7
00:00:20,290 --> 00:00:24,230
Así que comencemos escribiendo algo de código esta vez

8
00:00:24,230 --> 00:00:27,660
para entender cuál es la confusión en realidad,

9
00:00:27,660 --> 00:00:29,280
para que luego pueda mostrarte

10
00:00:29,280 --> 00:00:31,483
cómo funciona todo detrás de escena.

11
00:00:33,200 --> 00:00:35,240
Así que ahora mismo no voy a explicar

12
00:00:35,240 --> 00:00:38,290
cómo funciona el código que veremos ahora,

13
00:00:38,290 --> 00:00:43,040
pero solo les mostraré cuál es la fuente de confusión.

14
00:00:43,040 --> 00:00:44,470
Pero por ahora empecemos con

15
00:00:44,470 --> 00:00:47,480
un ejemplo simple con primitivas.

16
00:00:47,480 --> 00:00:50,310
Y recuerda que las primitivas son como números,

17
00:00:50,310 --> 00:00:52,503
cadenas, booleanos, etcétera.

18
00:00:53,720 --> 00:00:56,273
Así que simplemente establecer la edad en 30,

19
00:00:57,609 --> 00:01:01,453
y luego estoy creando una variable de vejez.

20
00:01:02,370 --> 00:01:04,620
Y éste lo pondré en la edad

21
00:01:04,620 --> 00:01:07,920
porque ahora es mi cumpleaños básicamente.

22
00:01:07,920 --> 00:01:10,890
Y así mi edad cambia a 31,

23
00:01:10,890 --> 00:01:14,130
pero aún quería preservar mi vejez aquí

24
00:01:14,130 --> 00:01:15,490
en esta variable.

25
00:01:15,490 --> 00:01:16,600
¿Bueno?

26
00:01:16,600 --> 00:01:20,217
Entonces registremos los resultados en la consola ahora.

27
00:01:20,217 --> 00:01:25,217
Y deberían ser más o menos lo que esperamos en este momento.

28
00:01:25,770 --> 00:01:30,350
Entonces ves que mi edad actual es 31 porque, bueno,

29
00:01:30,350 --> 00:01:34,640
Cambié el original de 30 a 31.

30
00:01:34,640 --> 00:01:38,190
Pero la vejez sigue siendo 30 aquí.

31
00:01:38,190 --> 00:01:41,880
Y eso es porque lo configuré aquí en este punto del código.

32
00:01:42,800 --> 00:01:46,770
a la edad, que todavía era 30 en este punto.

33
00:01:46,770 --> 00:01:51,410
Y entonces cambiando la edad aquí de 30 a 31

34
00:01:51,410 --> 00:01:55,120
por supuesto, no volvió a afectar la variable de la vejez.

35
00:01:55,120 --> 00:01:59,773
Nuevamente porque en este punto aquí la edad todavía era 30.

36
00:02:01,063 --> 00:02:06,063
Muy bien, así que aquí, espero que no haya mucha confusión,

37
00:02:06,120 --> 00:02:09,000
todo funciona como se esperaba.

38
00:02:09,000 --> 00:02:12,913
Pero ahora vamos a crear otro escenario que tenga un objeto.

39
00:02:14,470 --> 00:02:17,563
Así que simplemente voy a crear un objeto para mí,

40
00:02:19,080 --> 00:02:23,443
con el nombre de Jonas y 30 años.

41
00:02:25,220 --> 00:02:28,000
Y ahora copiemos este objeto.

42
00:02:28,000 --> 00:02:30,560
porque digamos que tengo un amigo

43
00:02:30,560 --> 00:02:32,660
que también se llama Jonas.

44
00:02:32,660 --> 00:02:36,510
Y así, en lugar de crear un objeto completamente nuevo desde cero,

45
00:02:36,510 --> 00:02:39,080
Simplemente copiaría el objeto me.

46
00:02:39,080 --> 00:02:43,637
Entonces const Amigo es igual a Mí.

47
00:02:45,680 --> 00:02:46,530
¿Bueno?

48
00:02:46,530 --> 00:02:50,240
Y ahora tanto el nombre como la edad son los mismos,

49
00:02:50,240 --> 00:02:52,980
pero digamos que tenemos diferentes edades.

50
00:02:52,980 --> 00:02:56,120
Y entonces cambiemos la edad de mi amigo

51
00:02:57,220 --> 00:03:00,920
y eso es bastante sencillo, ¿verdad?

52
00:03:00,920 --> 00:03:04,610
Así que digamos que tiene 27 años.

53
00:03:04,610 --> 00:03:09,433
Pero, por supuesto, no me cambiamos la edad, ¿verdad?

54
00:03:10,410 --> 00:03:15,410
Así que ahora echemos un vistazo a ambos en la consola.

55
00:03:16,980 --> 00:03:18,023
Así que primero mi amigo,

56
00:03:20,850 --> 00:03:25,743
así que ese es el objeto Amigo y luego también Yo,

57
00:03:26,730 --> 00:03:29,850
o podríamos decir Jonas, en realidad no importa.

58
00:03:29,850 --> 00:03:34,190
Pero lo que importa es que veremos el objeto Me

59
00:03:34,190 --> 00:03:37,610
y ¿qué creemos que pasará ahora?

60
00:03:37,610 --> 00:03:39,800
Así que déjame mostrártelo.

61
00:03:39,800 --> 00:03:43,290
Y ahora entendemos que tanto yo como mi amigo

62
00:03:43,290 --> 00:03:45,847
tener la edad de 27.

63
00:03:45,847 --> 00:03:49,530
Y eso se ve un poco extraño porque todo lo que hicimos

64
00:03:49,530 --> 00:03:53,540
era cambiar la edad del amigo, ¿no?

65
00:03:53,540 --> 00:03:57,760
Aquí en ninguna parte, me tengo. La edad es igual a 27,

66
00:03:57,760 --> 00:04:02,140
pero aún para mí mismo, así que aquí en el objeto Me,

67
00:04:02,140 --> 00:04:04,840
la edad tambien es 27

68
00:04:04,840 --> 00:04:08,980
Y eso es lo que quiero decir con fuente de confusión.

69
00:04:08,980 --> 00:04:10,200
Y así en este video,

70
00:04:10,200 --> 00:04:13,233
Veamos ahora por qué funciona de esta manera.

71
00:04:14,720 --> 00:04:18,700
Ahora, antes de que podamos entender el código que acabamos de escribir,

72
00:04:18,700 --> 00:04:21,450
Necesitamos revisar algunos conceptos básicos aquí.

73
00:04:21,450 --> 00:04:23,363
En primer lugar, debemos recordar acerca de

74
00:04:23,363 --> 00:04:25,900
Tipos de datos primitivos de JavaScript,

75
00:04:25,900 --> 00:04:30,900
que son número, cadena, booleano, indefinido, nulo, símbolo,

76
00:04:31,060 --> 00:04:32,860
y BigInt.

77
00:04:32,860 --> 00:04:36,660
Entonces todo lo demás son básicamente objetos.

78
00:04:36,660 --> 00:04:40,900
Así que los objetos creados con el objeto literal, matrices

79
00:04:40,900 --> 00:04:44,670
e incluso las funciones son todos objetos.

80
00:04:44,670 --> 00:04:48,660
Ahora, cuando hablamos de memoria y administración de memoria,

81
00:04:48,660 --> 00:04:52,010
es habitual llamar primitivos, tipos primitivos

82
00:04:52,010 --> 00:04:56,260
y tipos de referencia de objetos debido a la forma diferente

83
00:04:56,260 --> 00:04:58,573
en el que se almacenan en la memoria.

84
00:04:59,410 --> 00:05:03,810
A continuación, debemos recordar sobre el motor de JavaScript.

85
00:05:03,810 --> 00:05:07,330
Entonces, el motor tiene dos componentes, la pila de llamadas,

86
00:05:07,330 --> 00:05:11,470
donde se ejecutan las funciones y en el montón donde se ejecutan los objetos

87
00:05:11,470 --> 00:05:13,780
se almacenan en la memoria.

88
00:05:13,780 --> 00:05:16,710
Y así es, todos los objetos,

89
00:05:16,710 --> 00:05:19,510
o en otras palabras, tipos de referencia

90
00:05:19,510 --> 00:05:23,020
se almacenará directamente en el montón de memoria.

91
00:05:23,020 --> 00:05:26,780
Y mencioné que cuando hablamos por primera vez sobre el motor,

92
00:05:26,780 --> 00:05:31,100
pero ahora finalmente aprenderá cómo funciona eso realmente.

93
00:05:31,100 --> 00:05:35,010
Por otro lado, los primitivos o tipos primitivos

94
00:05:35,010 --> 00:05:37,640
se almacenan en la pila de llamadas.

95
00:05:37,640 --> 00:05:40,650
Y con eso quiero decir que los tipos primitivos

96
00:05:40,650 --> 00:05:43,680
se almacenan en los contextos de ejecución

97
00:05:43,680 --> 00:05:45,830
en que se declaran.

98
00:05:45,830 --> 00:05:47,960
Pero en aras de la simplicidad,

99
00:05:47,960 --> 00:05:50,220
ignoremos ese detalle ahora.

100
00:05:50,220 --> 00:05:52,600
Y simplemente decir que los tipos primitivos

101
00:05:52,600 --> 00:05:54,890
se almacenan en una pila de llamadas

102
00:05:54,890 --> 00:05:58,850
porque ahí es donde se ejecuta el contexto de ejecución.

103
00:05:58,850 --> 00:06:03,030
Muy bien, pero ahora, ¿cómo funciona todo eso realmente?

104
00:06:03,030 --> 00:06:06,060
¿Y por qué nuestro ejemplo de código anterior se comportó

105
00:06:06,060 --> 00:06:08,220
de esa manera rara?

106
00:06:08,220 --> 00:06:09,953
Bueno, averigüémoslo.

107
00:06:11,380 --> 00:06:14,860
Así que aquí tenemos los dos ejemplos de código de antes,

108
00:06:14,860 --> 00:06:19,380
así como el motor con la pila de llamadas y el montón.

109
00:06:19,380 --> 00:06:24,020
Y comencemos mirando el ejemplo de valores primitivos.

110
00:06:24,020 --> 00:06:28,580
Entonces, cuando declaramos una variable como la edad es igual a 30,

111
00:06:28,580 --> 00:06:32,060
lo que realmente sucede dentro del motor de JavaScript

112
00:06:32,060 --> 00:06:33,453
y la memoria de la computadora?

113
00:06:34,390 --> 00:06:37,460
Bueno, primero JavaScript creará

114
00:06:37,460 --> 00:06:42,140
un llamado identificador único con el nombre de la variable.

115
00:06:42,140 --> 00:06:45,450
Luego se asignará una parte de la memoria.

116
00:06:45,450 --> 00:06:49,778
con una determinada dirección, por lo que 0001 en este ejemplo,

117
00:06:49,778 --> 00:06:54,180
y finalmente el valor se almacenaría en la memoria

118
00:06:54,180 --> 00:06:56,310
en la dirección especificada.

119
00:06:56,310 --> 00:06:58,260
Así que en este caso, el valor 30

120
00:06:58,260 --> 00:07:02,463
se especificará en la dirección de memoria 0001.

121
00:07:03,360 --> 00:07:06,400
Y recuerda que todo esto sucede en una pila de llamadas

122
00:07:06,400 --> 00:07:08,653
donde se almacenan los valores primitivos.

123
00:07:09,570 --> 00:07:12,830
Ahora, lo que es extremadamente importante entender aquí

124
00:07:12,830 --> 00:07:17,070
es que el identificador en realidad apunta a la dirección

125
00:07:17,070 --> 00:07:19,690
y no al valor mismo.

126
00:07:19,690 --> 00:07:24,010
Entonces diríamos que la variable edad es igual a 30,

127
00:07:24,010 --> 00:07:28,680
pero de hecho, la edad es igual a la dirección de memoria 0001,

128
00:07:30,420 --> 00:07:33,730
que tiene el valor de 30, ¿de acuerdo?

129
00:07:33,730 --> 00:07:35,310
Y esta sutil distinción

130
00:07:35,310 --> 00:07:38,380
es muy importante tener en cuenta.

131
00:07:38,380 --> 00:07:41,420
Ahora, en la siguiente línea, declaramos la vejez

132
00:07:41,420 --> 00:07:43,540
ser igual a la edad.

133
00:07:43,540 --> 00:07:48,240
Entonces, sabiendo que una variable en realidad tiene una dirección de memoria,

134
00:07:48,240 --> 00:07:51,200
¿Cómo debe ser la vejez?

135
00:07:51,200 --> 00:07:55,290
Bueno, simplemente apuntará a la misma dirección de memoria.

136
00:07:55,290 --> 00:07:57,080
como la variable edad.

137
00:07:57,080 --> 00:08:02,080
Y por lo que se verá como la vejez, es simplemente 30 también.

138
00:08:02,140 --> 00:08:07,140
Genial, pero ahora en la siguiente línea, establecemos ocho a 31.

139
00:08:07,160 --> 00:08:09,060
Entonces, ¿qué pasará entonces?

140
00:08:09,060 --> 00:08:12,070
El valor en la dirección 0001

141
00:08:12,070 --> 00:08:15,270
ciertamente no se convertirá en 31

142
00:08:15,270 --> 00:08:18,560
porque eso también cambiaría la vejez,

143
00:08:18,560 --> 00:08:21,560
ya que ambos apuntan a la misma dirección.

144
00:08:21,560 --> 00:08:24,480
Así que eso no tendría ningún sentido en absoluto.

145
00:08:24,480 --> 00:08:28,590
Además, el valor en una determinada dirección de memoria es inmutable,

146
00:08:28,590 --> 00:08:32,000
o en otras palabras, no se puede cambiar.

147
00:08:32,000 --> 00:08:34,630
Entonces, en cambio, ¿qué va a pasar aquí?

148
00:08:34,630 --> 00:08:38,190
es que se asigna una nueva pieza de memoria.

149
00:08:38,190 --> 00:08:42,477
Entonces se crea y el identificador de edad ahora simplemente apunta

150
00:08:42,477 --> 00:08:47,023
a la nueva dirección, que contiene el nuevo valor de 31,

151
00:08:47,920 --> 00:08:48,753
¿está bien?

152
00:08:48,753 --> 00:08:51,060
Y por eso cuando cerramos los dos

153
00:08:51,060 --> 00:08:53,720
o variables a la consola al final,

154
00:08:53,720 --> 00:08:58,050
ambos devuelven exactamente los valores que esperamos.

155
00:08:58,050 --> 00:09:02,200
Ahora con los valores de referencia, las cosas funcionan un poco diferente,

156
00:09:02,200 --> 00:09:05,230
que es la razón por la que este ejemplo nos dio

157
00:09:05,230 --> 00:09:09,910
ese inesperado y extraño comportamiento anterior en la práctica.

158
00:09:09,910 --> 00:09:14,590
Entonces, ¿cuál es el origen de este extraño resultado inesperado?

159
00:09:14,590 --> 00:09:19,590
Bueno, cuando se crea un nuevo objeto como este objeto Me,

160
00:09:19,790 --> 00:09:21,930
se almacena en el montón.

161
00:09:21,930 --> 00:09:25,030
Y como antes hay una dirección de memoria

162
00:09:25,030 --> 00:09:27,360
y luego el valor en sí.

163
00:09:27,360 --> 00:09:29,710
Ahora bien, en el caso de los valores de referencia

164
00:09:29,710 --> 00:09:33,300
como este objeto Me el identificador Me

165
00:09:33,300 --> 00:09:35,920
en realidad no apunta directamente

166
00:09:35,920 --> 00:09:39,790
a esta dirección de memoria recién creada en el montón.

167
00:09:39,790 --> 00:09:43,360
Entonces, en este ejemplo, D30F,

168
00:09:43,360 --> 00:09:46,890
en cambio, apuntará a una nueva pieza de memoria

169
00:09:46,890 --> 00:09:49,350
que se crea en la pila.

170
00:09:49,350 --> 00:09:53,247
Y esta nueva pieza de memoria apuntará al objeto.

171
00:09:53,247 --> 00:09:58,247
eso está en el montón usando la dirección de memoria como su valor.

172
00:09:59,220 --> 00:10:02,620
En otras palabras, la pieza de memoria en la pila de llamadas

173
00:10:02,620 --> 00:10:06,290
tiene una referencia a la pieza de memoria en el montón,

174
00:10:06,290 --> 00:10:09,810
que sostiene o Me objeto, ¿de acuerdo?

175
00:10:09,810 --> 00:10:13,670
Y esa es la razón por la que llamamos tipos de referencia a los objetos.

176
00:10:13,670 --> 00:10:15,300
en este contexto.

177
00:10:15,300 --> 00:10:19,650
De nuevo, cuando declaramos una variable como objeto,

178
00:10:19,650 --> 00:10:21,930
se crea un identificador,

179
00:10:21,930 --> 00:10:25,130
que apunta a una parte de la memoria en la pila,

180
00:10:25,130 --> 00:10:29,010
que a su vez apunta a un fragmento de memoria en el montón.

181
00:10:29,010 --> 00:10:32,770
Y ahí es donde se almacena realmente el objeto.

182
00:10:32,770 --> 00:10:35,870
Y funciona de esta manera porque los objetos pueden ser

183
00:10:35,870 --> 00:10:39,230
demasiado grande para ser almacenado en la pila.

184
00:10:39,230 --> 00:10:42,210
En su lugar, se almacenan en el montón,

185
00:10:42,210 --> 00:10:45,620
que es como un grupo de memoria casi ilimitado.

186
00:10:45,620 --> 00:10:48,060
Y la pila solo mantiene una referencia.

187
00:10:48,060 --> 00:10:51,610
a donde el objeto está realmente almacenado en el montón

188
00:10:51,610 --> 00:10:54,363
para que pueda encontrarlo cuando sea necesario.

189
00:10:55,260 --> 00:10:57,390
Ahora, avanzando en el código,

190
00:10:57,390 --> 00:11:00,540
creamos una nueva variable llamada Amigo

191
00:11:00,540 --> 00:11:03,900
que igualamos al objeto Me.

192
00:11:03,900 --> 00:11:06,340
Entonces, ¿qué pasará aquí?

193
00:11:06,340 --> 00:11:09,570
Bueno, al igual que con los valores primitivos,

194
00:11:09,570 --> 00:11:11,760
el identificador de amigo señalará

195
00:11:11,760 --> 00:11:16,560
exactamente a la misma dirección de memoria que el identificador Me.

196
00:11:16,560 --> 00:11:20,000
Y de nuevo, esa dirección contiene la referencia,

197
00:11:20,000 --> 00:11:23,280
que luego apunta al objeto mismo.

198
00:11:23,280 --> 00:11:27,010
Y así, el objeto Amigo ahora es esencialmente

199
00:11:27,010 --> 00:11:30,290
exactamente lo mismo que el objeto Me.

200
00:11:30,290 --> 00:11:32,313
¿Ves eso aquí en el diagrama?

201
00:11:33,230 --> 00:11:35,690
Así que aquí viene la parte interesante.

202
00:11:35,690 --> 00:11:38,870
porque ahora vamos a cambiar una propiedad

203
00:11:38,870 --> 00:11:43,870
en el objeto Amigo estableciendo friend.age en 27.

204
00:11:44,420 --> 00:11:46,840
Entonces lo que sucede entonces es que el objeto

205
00:11:46,840 --> 00:11:51,800
se encuentra en el montón, y el 30 se cambia a 27.

206
00:11:51,800 --> 00:11:52,970
Excelente.

207
00:11:52,970 --> 00:11:56,410
Y por cierto, aunque definimos la variable Amigo

208
00:11:56,410 --> 00:12:01,170
como una constante, en realidad todavía podemos manipular el objeto

209
00:12:01,170 --> 00:12:03,100
sin problemas.

210
00:12:03,100 --> 00:12:06,180
Y cuando pensamos en eso, tiene sentido

211
00:12:06,180 --> 00:12:09,840
porque en realidad no estamos cambiando el valor en la memoria

212
00:12:09,840 --> 00:12:14,810
para el identificador de Amigo, sigue siendo D30F.

213
00:12:14,810 --> 00:12:17,440
Así que la referencia al objeto.

214
00:12:17,440 --> 00:12:20,800
Todo lo que hicimos fue cambiar el valor en el montón,

215
00:12:20,800 --> 00:12:22,690
y eso no es un problema.

216
00:12:22,690 --> 00:12:26,230
Así que es un error pensar que todas las variables declaradas

217
00:12:26,230 --> 00:12:28,920
con const son inmutables.

218
00:12:28,920 --> 00:12:32,610
De hecho, eso solo es cierto para valores primitivos,

219
00:12:32,610 --> 00:12:35,200
pero no para valores de referencia.

220
00:12:35,200 --> 00:12:39,440
Así que tenlo en cuenta cada vez que trabajes con const.

221
00:12:39,440 --> 00:12:43,000
De todos modos, cuando bloqueamos la variable Amigo en la consola,

222
00:12:43,000 --> 00:12:47,690
obtenemos la edad de 27, tal como lo dijimos antes.

223
00:12:47,690 --> 00:12:50,350
Pero luego, cuando bloqueamos el objeto Me,

224
00:12:50,350 --> 00:12:52,580
tenemos ese comportamiento extraño

225
00:12:52,580 --> 00:12:56,690
que antes no podíamos explicar y no entender.

226
00:12:56,690 --> 00:12:59,750
Pero con todo lo que aprendimos en esta conferencia,

227
00:12:59,750 --> 00:13:01,520
en realidad ahora tiene sentido

228
00:13:01,520 --> 00:13:05,950
que en el objeto Me, la edad ahora también es 27,

229
00:13:05,950 --> 00:13:10,100
aunque nunca me cambiamos la edad directamente.

230
00:13:10,100 --> 00:13:13,410
Y la razón de esto, como podemos ver en esta diapositiva

231
00:13:13,410 --> 00:13:16,430
es el hecho de que yo y un amigo

232
00:13:16,430 --> 00:13:21,400
en realidad apuntan exactamente al mismo objeto en el montón de memoria.

233
00:13:21,400 --> 00:13:24,370
Así que cada vez que cambiamos algo en este objeto,

234
00:13:24,370 --> 00:13:28,490
siempre se reflejará en el Amigo y en Mí.

235
00:13:28,490 --> 00:13:30,430
Así que en estos dos objetos.

236
00:13:30,430 --> 00:13:34,040
Estos son básicamente dos identificadores diferentes

237
00:13:34,040 --> 00:13:36,960
apuntando exactamente al mismo valor.

238
00:13:36,960 --> 00:13:40,907
Y una vez más, ese valor es la dirección de memoria D30F

239
00:13:42,750 --> 00:13:46,800
que apunta a la referencia en el montón de memoria.

240
00:13:46,800 --> 00:13:49,430
Y una implicación importante de esto

241
00:13:49,430 --> 00:13:53,330
es que cada vez que piensas que estás copiando un objeto,

242
00:13:53,330 --> 00:13:55,950
en realidad solo estás creando una nueva variable

243
00:13:55,950 --> 00:13:59,050
que apunta exactamente al mismo objeto.

244
00:13:59,050 --> 00:14:01,380
Y esto tiene enormes implicaciones.

245
00:14:01,380 --> 00:14:04,280
por la forma en que JavaScript funciona en la práctica.

246
00:14:04,280 --> 00:14:06,760
Y eso lo veremos en el siguiente video.

247
00:14:06,760 --> 00:14:08,670
y durante todo el curso.

248
00:14:08,670 --> 00:14:11,450
Ahora, en realidad hay formas de evitar esto,

249
00:14:11,450 --> 00:14:13,600
como también aprenderemos más adelante.

250
00:14:13,600 --> 00:14:17,020
pero en general, así es como funcionan los valores de referencia

251
00:14:17,020 --> 00:14:18,580
en JavaScript.

252
00:14:18,580 --> 00:14:21,370
Así que asegúrese de entender realmente esto,

253
00:14:21,370 --> 00:14:25,170
así como las implicaciones que tiene este comportamiento,

254
00:14:25,170 --> 00:14:28,620
incluso si eso significa que tienes que volver a ver esta conferencia

255
00:14:28,620 --> 00:14:33,570
o al menos la explicación de esta diapositiva, ¿de acuerdo?

256
00:14:33,570 --> 00:14:36,570
Luego, una vez que realmente entiendas lo que sucedió aquí,

257
00:14:36,570 --> 00:14:40,260
en este ejemplo, entendamos los valores primitivos

258
00:14:40,260 --> 00:14:43,430
y valores de referencia aún mejores en la práctica

259
00:14:43,430 --> 00:14:44,843
en la próxima conferencia.

260
00:14:45,900 --> 00:14:49,750
Pero antes de hacer eso, permítanme tomarme un segundo rápidamente

261
00:14:49,750 --> 00:14:52,920
y mencionar otros tres temas realmente importantes

262
00:14:52,920 --> 00:14:56,100
sobre cómo funciona JavaScript entre bastidores

263
00:14:56,100 --> 00:14:58,250
que no estará en la sección,

264
00:14:58,250 --> 00:15:02,400
pero más cerca de donde realmente necesitamos aprender sobre ellos.

265
00:15:02,400 --> 00:15:06,220
Por ejemplo, un concepto fundamental de JavaScript

266
00:15:06,220 --> 00:15:08,710
es la herencia prototípica.

267
00:15:08,710 --> 00:15:10,690
Pero solo hablaremos de eso.

268
00:15:10,690 --> 00:15:14,610
en la sección de programación orientada a objetos de este curso.

269
00:15:14,610 --> 00:15:18,110
Porque no tiene sentido aprender sobre esto ahora.

270
00:15:18,110 --> 00:15:20,550
solo para luego olvidarlo todo

271
00:15:20,550 --> 00:15:23,083
hasta que finalmente llegamos a ese tramo.

272
00:15:23,960 --> 00:15:28,930
Lo mismo es cierto para una lectura detallada sobre el bucle de eventos.

273
00:15:28,930 --> 00:15:32,720
Así que ya introduje el bucle de eventos en esta sección,

274
00:15:32,720 --> 00:15:36,080
pero en la sección sobre JavaScript asíncrono,

275
00:15:36,080 --> 00:15:38,010
nos sumergiremos muy profundamente en

276
00:15:38,010 --> 00:15:40,370
cómo funciona exactamente el bucle de eventos

277
00:15:40,370 --> 00:15:42,910
y por qué es una pieza tan fundamental

278
00:15:42,910 --> 00:15:44,393
del motor JavaScript.

279
00:15:45,270 --> 00:15:47,390
Finalmente, tendremos conferencias sobre

280
00:15:47,390 --> 00:15:51,100
cómo el DOM realmente funciona detrás de escena también.

281
00:15:51,100 --> 00:15:52,430
y eso va a ser

282
00:15:52,430 --> 00:15:55,530
en la sección avanzada de DOM y eventos

283
00:15:55,530 --> 00:15:57,160
para que luego puedas aplicar

284
00:15:57,160 --> 00:16:00,000
lo que aprendiste allí de inmediato.

285
00:16:00,000 --> 00:16:01,190
¿Bueno?

286
00:16:01,190 --> 00:16:03,893
Y dicho esto, ahora sigamos.