1
00:00:01,120 --> 00:00:03,650
Así que hablé sobre el motor de JavaScript

2
00:00:03,650 --> 00:00:08,040
en la última lección, pero ¿qué es ese motor en realidad?

3
00:00:08,040 --> 00:00:10,830
¿Y qué es un tiempo de ejecución de JavaScript?

4
00:00:10,830 --> 00:00:15,700
Además, ¿cómo se traduce el código JavaScript a un código de máquina?

5
00:00:15,700 --> 00:00:17,470
Esos son solo algunos de los temas.

6
00:00:17,470 --> 00:00:19,550
del que hablamos en el último vídeo.

7
00:00:19,550 --> 00:00:23,483
Y ahora vamos a averiguar cómo funcionan en esta conferencia.

8
00:00:24,900 --> 00:00:27,660
Así que un motor de JavaScript es simplemente

9
00:00:27,660 --> 00:00:31,740
un programa de computadora que ejecuta código JavaScript.

10
00:00:31,740 --> 00:00:35,080
Hay muchos pasos involucrados en hacer eso,

11
00:00:35,080 --> 00:00:38,050
pero esencialmente ejecutando código JavaScript

12
00:00:38,050 --> 00:00:40,590
es lo que hace un motor.

13
00:00:40,590 --> 00:00:44,200
Ahora cada navegador tiene su propio motor JavaScript

14
00:00:44,200 --> 00:00:49,090
pero probablemente el motor más conocido es el V-Eight de Google.

15
00:00:49,090 --> 00:00:51,720
El motor V ocho impulsa Google Chrome,

16
00:00:51,720 --> 00:00:55,730
pero también Node.js, que es ese tiempo de ejecución de JavaScript

17
00:00:55,730 --> 00:00:58,630
de lo que hablábamos al principio del curso,

18
00:00:58,630 --> 00:01:02,560
entonces el que podemos usar para construir aplicaciones del lado del servidor

19
00:01:02,560 --> 00:01:06,990
con JavaScript, por lo que fuera de cualquier navegador.

20
00:01:06,990 --> 00:01:09,290
Y, por supuesto, todos los demás navegadores.

21
00:01:09,290 --> 00:01:11,510
tienen sus propios motores de JavaScript

22
00:01:11,510 --> 00:01:15,310
que puede buscar en línea si está interesado.

23
00:01:15,310 --> 00:01:19,430
De todos modos, es bastante fácil entender qué es un motor.

24
00:01:19,430 --> 00:01:22,610
pero lo más importante es entender realmente

25
00:01:22,610 --> 00:01:25,900
Sus componentes y su funcionamiento.

26
00:01:25,900 --> 00:01:29,030
Así que cualquier motor de JavaScript siempre contiene

27
00:01:29,030 --> 00:01:32,040
una pila de llamadas y un montón.

28
00:01:32,040 --> 00:01:36,250
La pila de llamadas es donde nuestro código se ejecuta realmente

29
00:01:36,250 --> 00:01:39,149
usando algo llamado contextos de ejecución.

30
00:01:39,149 --> 00:01:42,880
Entonces el montón es un grupo de memoria no estructurado

31
00:01:42,880 --> 00:01:47,420
que almacena todos los objetos que necesita nuestra aplicación.

32
00:01:47,420 --> 00:01:50,770
Muy bien, con este vistazo al motor,

33
00:01:50,770 --> 00:01:54,080
hemos respondido donde se ejecuta nuestro código.

34
00:01:54,080 --> 00:01:55,670
Pero ahora la pregunta es

35
00:01:55,670 --> 00:01:58,830
cómo se compila el código a código de máquina

36
00:01:58,830 --> 00:02:02,560
para que realmente se pueda ejecutar después.

37
00:02:02,560 --> 00:02:04,403
Bueno, averigüémoslo.

38
00:02:05,600 --> 00:02:07,040
Pero primero tenemos que hacer

39
00:02:07,040 --> 00:02:09,780
una breve nota al margen de informática aquí

40
00:02:09,780 --> 00:02:11,550
y hablar de la diferencia entre

41
00:02:11,550 --> 00:02:14,530
compilación e interpretación.

42
00:02:14,530 --> 00:02:15,900
Así que en la última conferencia,

43
00:02:15,900 --> 00:02:18,660
aprendimos que el procesador de la computadora

44
00:02:18,660 --> 00:02:21,630
solo entiende ceros y unos

45
00:02:21,630 --> 00:02:25,040
y eso es, por lo tanto, cada programa de computadora

46
00:02:25,040 --> 00:02:29,220
en última instancia, debe convertirse en este código de máquina

47
00:02:29,220 --> 00:02:33,860
y esto puede suceder usando compilación o interpretación.

48
00:02:33,860 --> 00:02:36,880
Entonces, en compilación, todo el código fuente

49
00:02:36,880 --> 00:02:39,890
se convierte en código de máquina a la vez.

50
00:02:39,890 --> 00:02:42,520
Y este código de máquina luego se escribe

51
00:02:42,520 --> 00:02:47,440
en un archivo portátil que se puede ejecutar en cualquier computadora.

52
00:02:47,440 --> 00:02:49,980
Así que tenemos dos pasos diferentes aquí.

53
00:02:49,980 --> 00:02:52,200
Primero, se construye el código máquina.

54
00:02:52,200 --> 00:02:56,870
y luego se ejecuta en la CPU por lo que en el procesador.

55
00:02:56,870 --> 00:02:58,510
Y la ejecución puede suceder

56
00:02:58,510 --> 00:03:01,390
mucho después de la compilación, por supuesto.

57
00:03:01,390 --> 00:03:04,080
Por ejemplo, cualquier aplicación que esté utilizando

58
00:03:04,080 --> 00:03:08,210
en su computadora en este momento ha sido compilado antes

59
00:03:08,210 --> 00:03:11,883
y ahora lo estás ejecutando mucho después de su compilación.

60
00:03:12,740 --> 00:03:15,960
Ahora, por otro lado en la interpretación,

61
00:03:15,960 --> 00:03:19,990
hay un intérprete que se ejecuta a través del código fuente

62
00:03:19,990 --> 00:03:22,840
y lo ejecuta línea por línea.

63
00:03:22,840 --> 00:03:27,010
Así que aquí no tenemos los mismos dos pasos que antes.

64
00:03:27,010 --> 00:03:32,010
En cambio, el código se lee y ejecuta todo al mismo tiempo.

65
00:03:32,230 --> 00:03:34,650
Por supuesto, el código fuente todavía

66
00:03:34,650 --> 00:03:37,430
necesita ser convertido en código de máquina,

67
00:03:37,430 --> 00:03:40,810
pero simplemente sucede justo antes de que se ejecute

68
00:03:40,810 --> 00:03:43,320
y no antes de tiempo.

69
00:03:43,320 --> 00:03:47,580
Ahora JavaScript solía ser un lenguaje puramente interpretado

70
00:03:47,580 --> 00:03:50,170
pero el problema con los lenguajes interpretados

71
00:03:50,170 --> 00:03:54,630
es que son mucho, mucho más lentos que los lenguajes compilados.

72
00:03:54,630 --> 00:03:57,450
Esto solía estar bien para JavaScript,

73
00:03:57,450 --> 00:03:59,770
pero ahora con JavaScript moderno

74
00:03:59,770 --> 00:04:02,890
y aplicaciones web completas que construimos

75
00:04:02,890 --> 00:04:07,890
y uso hoy en día, el bajo rendimiento ya no es aceptable.

76
00:04:07,930 --> 00:04:11,050
Imagínese que estaba usando mapas de Google en su navegador

77
00:04:11,050 --> 00:04:14,200
y estabas arrastrando el mapa y cada vez que arrastrabas

78
00:04:14,200 --> 00:04:17,370
tardaría un segundo en moverse.

79
00:04:17,370 --> 00:04:20,815
Eso sería completamente inaceptable, ¿verdad?

80
00:04:20,815 --> 00:04:23,060
Ahora mucha gente todavía piensa

81
00:04:23,060 --> 00:04:25,760
que JavaScript es un lenguaje interpretado

82
00:04:25,760 --> 00:04:28,410
pero eso ya no es cierto.

83
00:04:28,410 --> 00:04:31,380
Entonces, en lugar de una interpretación simple

84
00:04:31,380 --> 00:04:34,690
El motor JavaScript moderno ahora usa una mezcla entre

85
00:04:34,690 --> 00:04:37,370
recopilacion e interpretacion

86
00:04:37,370 --> 00:04:41,140
que se llama compilación justo a tiempo.

87
00:04:41,140 --> 00:04:44,130
Este enfoque básicamente compila todo el código.

88
00:04:44,130 --> 00:04:48,830
en código de máquina a la vez y luego lo ejecuta de inmediato.

89
00:04:48,830 --> 00:04:50,680
Así que todavía tenemos los dos pasos.

90
00:04:50,680 --> 00:04:53,960
de la compilación regular antes de tiempo

91
00:04:53,960 --> 00:04:57,240
pero no hay ningún archivo portátil para ejecutar.

92
00:04:57,240 --> 00:05:01,720
Y la ejecución ocurre inmediatamente después de una compilación.

93
00:05:01,720 --> 00:05:04,370
Y esto es perfecto para JavaScript.

94
00:05:04,370 --> 00:05:08,350
ya que es mucho más rápido que simplemente ejecutar código

95
00:05:08,350 --> 00:05:10,250
linea por linea.

96
00:05:10,250 --> 00:05:13,360
Ahora hojeé algunos detalles aquí

97
00:05:13,360 --> 00:05:16,120
pero esto es realmente todo lo que necesitas saber.

98
00:05:16,120 --> 00:05:19,130
De todos modos, ahora entendamos cómo funciona esto.

99
00:05:19,130 --> 00:05:22,023
en el caso particular de JavaScript.

100
00:05:23,840 --> 00:05:27,627
Entonces, cuando una pieza de código JavaScript ingresa al motor

101
00:05:27,627 --> 00:05:31,040
el primer paso es analizar el código

102
00:05:31,040 --> 00:05:34,400
lo que esencialmente significa leer el código.

103
00:05:34,400 --> 00:05:37,850
Durante el proceso de análisis, el código se analiza

104
00:05:37,850 --> 00:05:39,850
en una estructura de datos llamada

105
00:05:39,850 --> 00:05:43,630
el árbol de sintaxis abstracta o AST.

106
00:05:43,630 --> 00:05:46,670
Esto funciona dividiendo primero cada línea de código

107
00:05:46,670 --> 00:05:49,730
en piezas que son significativas para el lenguaje

108
00:05:49,730 --> 00:05:52,490
como las palabras clave const o function,

109
00:05:52,490 --> 00:05:54,500
y luego guardar todas estas piezas

110
00:05:54,500 --> 00:05:57,570
en el árbol de forma estructurada.

111
00:05:57,570 --> 00:06:01,590
Este paso también comprueba si hay errores de sintaxis.

112
00:06:01,590 --> 00:06:04,250
y el árbol resultante se utilizará más adelante

113
00:06:04,250 --> 00:06:06,840
para generar el código máquina.

114
00:06:06,840 --> 00:06:09,890
Ahora digamos que tenemos un programa muy simple.

115
00:06:09,890 --> 00:06:13,800
Todo lo que hace es declarar una variable como esta,

116
00:06:13,800 --> 00:06:15,900
y esto es lo que dice el AST

117
00:06:15,900 --> 00:06:19,560
porque solo se ve esta línea de código.

118
00:06:19,560 --> 00:06:21,900
Así que tenemos una declaración de variable

119
00:06:21,900 --> 00:06:23,900
que debe ser una constante

120
00:06:23,900 --> 00:06:28,500
con el nombre X y el valor de 23.

121
00:06:28,500 --> 00:06:32,050
Y además de eso hay muchas otras cosas aquí,

122
00:06:32,050 --> 00:06:33,620
como se puede ver.

123
00:06:33,620 --> 00:06:35,930
Así que imagina cómo sería

124
00:06:35,930 --> 00:06:38,910
para una gran aplicación real.

125
00:06:38,910 --> 00:06:41,230
Y por supuesto que no necesitas saber

126
00:06:41,230 --> 00:06:43,520
cómo se ve un AST.

127
00:06:43,520 --> 00:06:46,990
Esto es solo por curiosidad ok.

128
00:06:46,990 --> 00:06:48,850
Ahora a veces me preguntan

129
00:06:48,850 --> 00:06:53,030
si este árbol tiene algo que ver con el árbol DOM

130
00:06:53,030 --> 00:06:56,220
y la respuesta es un no muy claro.

131
00:06:56,220 --> 00:07:00,550
Entonces este árbol no tiene absolutamente nada que ver con el DOM.

132
00:07:00,550 --> 00:07:03,310
No está relacionado de ninguna manera.

133
00:07:03,310 --> 00:07:05,060
es solo una representacion

134
00:07:05,060 --> 00:07:08,662
de todo nuestro código dentro del motor.

135
00:07:08,662 --> 00:07:11,940
De todos modos, el siguiente paso es la compilación.

136
00:07:11,940 --> 00:07:14,610
que toma el AST generado

137
00:07:14,610 --> 00:07:17,330
y lo compila en código de máquina

138
00:07:17,330 --> 00:07:20,290
tal como aprendimos en la diapositiva anterior.

139
00:07:20,290 --> 00:07:24,100
Este código de máquina se ejecuta de inmediato

140
00:07:24,100 --> 00:07:27,720
porque recuerda el uso moderno del motor JavaScript

141
00:07:27,720 --> 00:07:30,180
compilación justo a tiempo.

142
00:07:30,180 --> 00:07:32,770
Y recuerda que la ejecución sucede

143
00:07:32,770 --> 00:07:35,670
en la pila de llamadas de los motores de JavaScript

144
00:07:35,670 --> 00:07:39,600
pero vamos a profundizar en esto en la próxima lección.

145
00:07:39,600 --> 00:07:42,210
Muy bien, hasta ahora todo bien.

146
00:07:42,210 --> 00:07:46,180
Tenemos nuestro código ejecutándose para que podamos terminar aquí, ¿verdad?

147
00:07:46,180 --> 00:07:50,120
Bueno, no tan rápido porque los motores modernos de JavaScript

148
00:07:50,120 --> 00:07:54,110
en realidad tienen algunas estrategias de optimización bastante inteligentes.

149
00:07:54,110 --> 00:07:57,870
Lo que hacen es crear una versión muy desoptimizada.

150
00:07:57,870 --> 00:07:59,800
de código máquina al principio

151
00:07:59,800 --> 00:08:04,400
solo para que pueda comenzar a ejecutarse lo más rápido posible.

152
00:08:04,400 --> 00:08:07,840
Luego, en segundo plano, este código se está optimizando.

153
00:08:07,840 --> 00:08:12,840
y recompilado durante la ejecución del programa ya en ejecución.

154
00:08:12,900 --> 00:08:15,060
Y esto se puede hacer la mayoría de las veces.

155
00:08:15,060 --> 00:08:17,170
y después de cada optimización

156
00:08:17,170 --> 00:08:20,240
el código no optimizado simplemente se barre

157
00:08:20,240 --> 00:08:22,790
para el nuevo código más optimizado

158
00:08:22,790 --> 00:08:26,000
sin detener nunca la ejecución, por supuesto.

159
00:08:26,000 --> 00:08:29,300
Y este proceso es lo que hace que los motores modernos

160
00:08:29,300 --> 00:08:32,720
como el V-Eight tan rápido

161
00:08:32,720 --> 00:08:36,480
y todo este análisis, compilación y optimización

162
00:08:36,480 --> 00:08:40,183
sucede en algunos hilos especiales dentro del motor

163
00:08:40,183 --> 00:08:42,730
que no podemos acceder desde nuestro código.

164
00:08:42,730 --> 00:08:45,850
Tan completamente separado del hilo principal.

165
00:08:45,850 --> 00:08:48,310
que básicamente se está ejecutando en la pila de llamadas

166
00:08:48,310 --> 00:08:50,910
ejecutando nuestro propio código.

167
00:08:50,910 --> 00:08:55,250
Ahora diferentes motores implementan de formas ligeramente diferentes,

168
00:08:55,250 --> 00:08:58,220
pero en pocas palabras esto es lo moderno

169
00:08:58,220 --> 00:09:02,700
la compilación justo a tiempo se parece a JavaScript.

170
00:09:02,700 --> 00:09:04,720
Y la próxima vez que alguien te diga

171
00:09:04,720 --> 00:09:07,490
JavaScript es un lenguaje interpretado,

172
00:09:07,490 --> 00:09:10,550
simplemente muéstreles esta diapositiva para que puedan aprender

173
00:09:10,550 --> 00:09:12,053
cómo funciona realmente.

174
00:09:13,280 --> 00:09:16,720
Muy bien, miramos el motor de JavaScript

175
00:09:16,720 --> 00:09:20,740
y cómo funciona detrás de escena con bastante detalle.

176
00:09:20,740 --> 00:09:23,060
Ahora para terminar esta conferencia

177
00:09:23,060 --> 00:09:27,050
también echemos un vistazo a lo que es un tiempo de ejecución de JavaScript.

178
00:09:27,050 --> 00:09:29,680
Y en particular, el más común,

179
00:09:29,680 --> 00:09:32,470
que es el navegador y al hacer esto,

180
00:09:32,470 --> 00:09:34,200
podemos obtener una imagen más grande

181
00:09:34,200 --> 00:09:38,750
de cómo encajan todas las piezas cuando usamos JavaScript.

182
00:09:38,750 --> 00:09:41,560
Así que esta es una diapositiva muy importante.

183
00:09:41,560 --> 00:09:46,480
Entonces podemos imaginar un tiempo de ejecución de JavaScript como una caja grande

184
00:09:46,480 --> 00:09:48,250
o un recipiente grande

185
00:09:48,250 --> 00:09:50,860
que incluye todas las cosas que necesitamos

186
00:09:50,860 --> 00:09:55,330
para usar JavaScript en este caso, en el navegador.

187
00:09:55,330 --> 00:09:58,197
Y al corazón de cualquier JavaScript,

188
00:09:58,197 --> 00:10:01,120
runtime es siempre un motor de JavaScript.

189
00:10:01,120 --> 00:10:04,490
Así que exactamente del que hemos estado hablando.

190
00:10:04,490 --> 00:10:07,570
Por eso tiene sentido hablar de motores

191
00:10:07,570 --> 00:10:09,690
y tiempos de ejecución juntos.

192
00:10:09,690 --> 00:10:12,510
Sin motor no hay autonomía

193
00:10:12,510 --> 00:10:15,710
y no hay JavaScript en absoluto.

194
00:10:15,710 --> 00:10:19,500
Sin embargo, el motor por sí solo no es suficiente.

195
00:10:19,500 --> 00:10:21,470
Para que funcione correctamente,

196
00:10:21,470 --> 00:10:24,990
también necesitamos acceso a las API web,

197
00:10:24,990 --> 00:10:28,480
y hablamos antes de las API web, ¿recuerdas?

198
00:10:28,480 --> 00:10:31,160
Así que eso es todo lo relacionado con el DOM.

199
00:10:31,160 --> 00:10:36,160
o temporizadores o incluso el console.log que usamos todo el tiempo.

200
00:10:36,420 --> 00:10:40,890
Entonces, esencialmente, las API web son funcionalidades provistas

201
00:10:40,890 --> 00:10:42,200
al motor,

202
00:10:42,200 --> 00:10:44,450
pero que en realidad no son parte

203
00:10:44,450 --> 00:10:47,060
del propio lenguaje JavaScript.

204
00:10:47,060 --> 00:10:50,550
JavaScript simplemente obtiene acceso a estas API

205
00:10:50,550 --> 00:10:53,020
a través del objeto de ventana global.

206
00:10:53,020 --> 00:10:55,720
Pero aún tiene sentido que las API web

207
00:10:55,720 --> 00:10:58,170
también son parte del tiempo de ejecución,

208
00:10:58,170 --> 00:11:02,460
porque nuevamente un tiempo de ejecución es como una caja

209
00:11:02,460 --> 00:11:07,050
que contiene todo el material relacionado con JavaScript que necesitamos.

210
00:11:07,050 --> 00:11:09,640
A continuación, un tiempo de ejecución típico de JavaScript

211
00:11:09,640 --> 00:11:13,300
también incluye una llamada cola de devolución de llamada.

212
00:11:13,300 --> 00:11:15,840
Esta es una estructura de datos que contiene

213
00:11:15,840 --> 00:11:20,180
todas las funciones de devolución de llamada que están listas para ser ejecutadas.

214
00:11:20,180 --> 00:11:23,350
Por ejemplo, adjuntamos funciones de controlador de eventos.

215
00:11:23,350 --> 00:11:26,010
a elementos DOM como un botón

216
00:11:26,010 --> 00:11:28,860
para reaccionar a ciertos eventos, ¿verdad?

217
00:11:28,860 --> 00:11:30,700
Y estas funciones de controlador de eventos

218
00:11:30,700 --> 00:11:34,540
también se denominan funciones de devolución de llamada.

219
00:11:34,540 --> 00:11:36,570
Entonces, a medida que sucede el evento,

220
00:11:36,570 --> 00:11:40,900
por ejemplo, un clic, se llamará a la función de devolución de llamada.

221
00:11:40,900 --> 00:11:44,240
Y así es como funciona realmente detrás de escena.

222
00:11:44,240 --> 00:11:47,900
Entonces, lo primero que realmente sucede después del evento

223
00:11:47,900 --> 00:11:50,310
es que la función de devolución de llamada se pone

224
00:11:50,310 --> 00:11:52,340
en la cola de devolución de llamada.

225
00:11:52,340 --> 00:11:54,430
Luego, cuando la pila está vacía

226
00:11:54,430 --> 00:11:57,980
la función de devolución de llamada se pasa a la pila

227
00:11:57,980 --> 00:12:00,690
para que se pueda ejecutar.

228
00:12:00,690 --> 00:12:04,430
Y esto sucede por algo llamado bucle de eventos.

229
00:12:04,430 --> 00:12:07,430
Entonces, básicamente, el ciclo de eventos toma funciones de devolución de llamada

230
00:12:07,430 --> 00:12:08,960
de la cola de devolución de llamada

231
00:12:08,960 --> 00:12:11,150
y los pone en la pila de llamadas

232
00:12:11,150 --> 00:12:13,850
para que puedan ser ejecutados.

233
00:12:13,850 --> 00:12:16,570
Y recuerda cómo dije en la última conferencia

234
00:12:16,570 --> 00:12:17,550
que el bucle de eventos

235
00:12:17,550 --> 00:12:21,000
es cómo el modelo de concurrencia sin bloqueo de JavaScript

236
00:12:21,000 --> 00:12:22,740
¿está implementado?

237
00:12:22,740 --> 00:12:26,830
Bueno, aquí hay una descripción general de cómo funciona.

238
00:12:26,830 --> 00:12:31,380
Ahora veremos por qué esto hace que JavaScript no bloquee

239
00:12:31,380 --> 00:12:33,900
en una conferencia especial sobre el bucle de eventos

240
00:12:33,900 --> 00:12:35,200
más adelante en el curso,

241
00:12:35,200 --> 00:12:37,760
porque esta es realmente una pieza fundamental

242
00:12:37,760 --> 00:12:39,770
de desarrollo JavaScript

243
00:12:39,770 --> 00:12:43,083
que todo desarrollador necesita entender profundamente.

244
00:12:44,180 --> 00:12:48,560
Muy bien, como ya dijeron, el enfoque en este curso

245
00:12:48,560 --> 00:12:51,100
está en JavaScript en el navegador

246
00:12:51,100 --> 00:12:55,660
y es por eso que analizamos el tiempo de ejecución de JavaScript del navegador.

247
00:12:55,660 --> 00:12:58,120
Sin embargo, también es importante recordar

248
00:12:58,120 --> 00:13:01,630
que JavaScript puede existir fuera de los navegadores,

249
00:13:01,630 --> 00:13:03,830
por ejemplo, en Node.js.

250
00:13:03,830 --> 00:13:07,440
Y esto es lo que el tiempo de ejecución de JavaScript JS del nodo

251
00:13:07,440 --> 00:13:08,880
parece.

252
00:13:08,880 --> 00:13:12,300
Es bastante similar, pero como no tenemos un navegador

253
00:13:12,300 --> 00:13:15,360
por supuesto, no podemos tener las API web

254
00:13:15,360 --> 00:13:18,450
porque es el navegador quien los proporciona.

255
00:13:18,450 --> 00:13:21,970
En cambio, tenemos múltiples enlaces C ++

256
00:13:21,970 --> 00:13:24,570
y un llamado grupo de subprocesos.

257
00:13:24,570 --> 00:13:27,110
Ahora los detalles no importan aquí en absoluto.

258
00:13:27,110 --> 00:13:28,470
Solo quiero que sepas

259
00:13:28,470 --> 00:13:32,200
que existen diferentes tiempos de ejecución de JavaScript.

260
00:13:32,200 --> 00:13:35,460
Muy bien, genial, eso es todo lo que tenía que decirte.

261
00:13:35,460 --> 00:13:39,010
sobre motores y tiempos de ejecución de JavaScript.

262
00:13:39,010 --> 00:13:43,260
En nuestra próxima lección, aprenderemos cómo se ejecuta JavaScript.

263
00:13:43,260 --> 00:13:44,533
en la pila de llamadas.