1
00:00:03,650 --> 00:00:06,180
En el ejercicio anterior,

2
00:00:06,180 --> 00:00:09,414
aprendimos sobre dos nuevos aspectos de JavaScript,

3
00:00:09,414 --> 00:00:13,155
su soporte para funciones de primera clase y cierres.

4
00:00:13,155 --> 00:00:20,250
También vimos cómo Node maneja el aspecto de programación asíncrona y cómo Node

5
00:00:20,250 --> 00:00:24,015
soporta la ejecución asíncrona de código con

6
00:00:24,015 --> 00:00:28,365
el uso de devoluciones de llamada y también el manejo de errores.

7
00:00:28,365 --> 00:00:31,815
Veamos un ejemplo de cómo hacemos uso de esto

8
00:00:31,815 --> 00:00:36,650
dentro de nuestra aplicación Node en este ejercicio.

9
00:00:36,650 --> 00:00:42,315
Continuando con lo que dejamos en el ejercicio anterior,

10
00:00:42,315 --> 00:00:48,025
ahora voy a ir y modificar el módulo Nodo rectángulo,

11
00:00:48,025 --> 00:00:51,670
para que pueda tomar la ayuda de devoluciones de llamada.

12
00:00:51,670 --> 00:00:55,375
Así que voy a eliminar estas exportaciones aquí,

13
00:00:55,375 --> 00:00:59,800
y en su lugar, van a modificar esta función.

14
00:00:59,800 --> 00:01:03,190
Voy a hacer uso de estas dos funciones un poco más tarde,

15
00:01:03,190 --> 00:01:05,925
así que es por eso que las estoy guardando en la parte inferior.

16
00:01:05,925 --> 00:01:07,515
Así que déjame mantenerlos a un lado.

17
00:01:07,515 --> 00:01:11,530
Y luego modificaré este módulo rectángulo de la siguiente manera.

18
00:01:11,530 --> 00:01:15,270
Así que diremos module.exports.

19
00:01:15,270 --> 00:01:20,025
Así que estamos usando la forma estándar en que se maneja el módulo.

20
00:01:20,025 --> 00:01:26,185
Y esto va a exportar esta función que toma estos tres parámetros,

21
00:01:26,185 --> 00:01:30,565
x e y y devolución de llamada.

22
00:01:30,565 --> 00:01:37,300
La devolución de llamada es una función que se va a suministrar cuando se llama a este módulo.

23
00:01:37,300 --> 00:01:43,825
Así que este es el uso de las funciones de primera clase de las que hemos hablado anteriormente.

24
00:01:43,825 --> 00:01:46,775
Así que dentro de esta devolución de llamada, para

25
00:01:46,775 --> 00:01:49,940
que pueda ver que está obteniendo dos parámetros, x e y.

26
00:01:49,940 --> 00:01:51,965
En este caso, para

27
00:01:51,965 --> 00:01:55,520
el rectángulo, la x e y corresponden a la longitud y anchura

28
00:01:55,520 --> 00:02:01,550
del rectángulo que se está pasando como los dos valores.

29
00:02:01,550 --> 00:02:05,090
Así que dentro de aquí, vamos a comprobar

30
00:02:05,090 --> 00:02:10,300
si x es menor o igual a cero o y es menor o igual a cero.

31
00:02:10,300 --> 00:02:13,255
Hemos escrito código como este aquí.

32
00:02:13,255 --> 00:02:17,630
Así que voy a copiar este código desde aquí

33
00:02:17,630 --> 00:02:23,330
y luego traerlo aquí y luego vamos a editar.

34
00:02:23,330 --> 00:02:26,090
Entonces, en este caso, esto es si x es

35
00:02:26,090 --> 00:02:30,135
menor o igual a cero o y es menor que o igual a cero.

36
00:02:30,135 --> 00:02:32,810
En este caso, ¿qué hacemos?

37
00:02:32,810 --> 00:02:35,435
En este caso, notamos que

38
00:02:35,435 --> 00:02:39,750
las dimensiones del rectángulo son menores o iguales a cero.

39
00:02:39,750 --> 00:02:43,775
Así que tenemos que manejarlo

40
00:02:43,775 --> 00:02:46,330
de manera diferente, y haremos lo demás.

41
00:02:46,330 --> 00:02:52,790
La otra parte donde manejamos la situación en la que el rectángulo es un rectángulo válido.

42
00:02:52,790 --> 00:02:54,245
Entonces, en este caso,

43
00:02:54,245 --> 00:03:04,580
lo que haremos es usar un setTimeout.

44
00:03:04,580 --> 00:03:08,090
Así que aquí, estoy simulando el hecho de que lo que

45
00:03:08,090 --> 00:03:11,860
sea que se esté haciendo en este rectángulo va a tomar algún tiempo.

46
00:03:11,860 --> 00:03:14,375
Entonces este es el procesamiento asincrónico.

47
00:03:14,375 --> 00:03:18,710
Ahora, como no tengo mucho trabajo que hacer en segundo plano,

48
00:03:18,710 --> 00:03:22,530
así que voy a simular eso simplemente usando la

49
00:03:22,530 --> 00:03:24,830
función setTimeout de JavaScript y luego

50
00:03:24,830 --> 00:03:28,825
retrasar antes de que se llame a la función de devolución de llamada.

51
00:03:28,825 --> 00:03:32,210
Así que la forma en que arreglo esto es la siguiente.

52
00:03:32,210 --> 00:03:34,270
Entonces, dentro del setTimeout,

53
00:03:34,270 --> 00:03:40,445
voy a llamar a esta función allí

54
00:03:40,445 --> 00:03:44,855
y organizar un retraso de

55
00:03:44,855 --> 00:03:50,570
2.000 milisegundos o dos segundos después de lo cual se va a llamar a esta función.

56
00:03:50,570 --> 00:03:52,003
Así que si recuerdas,

57
00:03:52,003 --> 00:03:54,890
el setTimeout que es compatible con JavaScript,

58
00:03:54,890 --> 00:03:58,070
toma como primer parámetro una función y

59
00:03:58,070 --> 00:04:03,450
el segundo parámetro sería el período de tiempo para el que esto se va a retrasar.

60
00:04:03,450 --> 00:04:07,120
Así que déjame sangrar esto.

61
00:04:07,120 --> 00:04:09,255
Ahora, necesito completar esta función aquí.

62
00:04:09,255 --> 00:04:11,915
Así que he empezado con la función de flecha aquí

63
00:04:11,915 --> 00:04:15,575
que no toma parámetros y luego cuando se llama,

64
00:04:15,575 --> 00:04:20,745
voy a emitir una llamada a la devolución de llamada.

65
00:04:20,745 --> 00:04:22,880
Esta devolución de llamada es una función de devolución de llamada que

66
00:04:22,880 --> 00:04:25,760
se va a pasar como el tercer parámetro aquí.

67
00:04:25,760 --> 00:04:33,440
Esta función de devolución de llamada, como notó, toma dos parámetros.

68
00:04:33,440 --> 00:04:38,245
El primero es el error y el segundo es el valor devuelto.

69
00:04:38,245 --> 00:04:40,625
Entonces, en este caso, ya que tenemos un error,

70
00:04:40,625 --> 00:04:44,750
porque x es menor o igual a cero e y es menor o igual a cero,

71
00:04:44,750 --> 00:04:50,820
por lo que el primer valor que voy a pasar como nuevo error,

72
00:04:50,820 --> 00:05:00,603
y este error es exactamente esta cadena que estaba usando en el console.log entonces,

73
00:05:00,603 --> 00:05:03,915
y eso es lo que pasaré como el error aquí.

74
00:05:03,915 --> 00:05:06,160
Permítanme ahora eliminar ese console.log,

75
00:05:06,160 --> 00:05:07,625
ya no lo necesito.

76
00:05:07,625 --> 00:05:08,890
Entonces, para la devolución de llamada,

77
00:05:08,890 --> 00:05:13,210
voy a generar un nuevo objeto de error y luego pasar esto

78
00:05:13,210 --> 00:05:18,850
como el valor de retorno para la función de devolución de llamada, el primer parámetro.

79
00:05:18,850 --> 00:05:23,770
Así que diré que las dimensiones del rectángulo deben ser mayores que cero.

80
00:05:23,770 --> 00:05:28,240
Así que diremos l,

81
00:05:28,240 --> 00:05:39,000
este es el valor x y el y que obtenemos como los valores de entrada allí.

82
00:05:39,000 --> 00:05:40,650
Así que esa es la devolución de llamada.

83
00:05:40,650 --> 00:05:43,890
Y la segunda parte de esta devolución de llamada,

84
00:05:43,890 --> 00:05:51,290
voy a pasar como nulo porque esto va a devolver un error.

85
00:05:51,290 --> 00:05:54,345
Entonces, cuando devuelva un error como el primer parámetro,

86
00:05:54,345 --> 00:05:59,250
el segundo parámetro será ignorado cuando esa devolución de llamada fue recibida por

87
00:05:59,250 --> 00:06:06,510
el módulo de nodo desde donde estamos llamando a esta función en particular allí.

88
00:06:06,510 --> 00:06:09,085
Así que, con este arreglo,

89
00:06:09,085 --> 00:06:10,700
tan menos de cero,

90
00:06:10,700 --> 00:06:18,590
así que permítanme darle un poco de espacio aquí para que esté correctamente sangrada aquí.

91
00:06:18,590 --> 00:06:21,650
Entonces, la forma en que estoy organizando esto

92
00:06:21,650 --> 00:06:26,135
aquí es que si x es menor que cero e y es menor que cero,

93
00:06:26,135 --> 00:06:30,040
voy a devolver la llamada a la función de devolución de llamada que se ha pasado,

94
00:06:30,040 --> 00:06:32,424
pero el primer parámetro pasará en

95
00:06:32,424 --> 00:06:36,307
error porque aquí notamos que hay un error,

96
00:06:36,307 --> 00:06:38,930
y el segundo parámetro será nulo.

97
00:06:38,930 --> 00:06:40,940
Si este no es el caso,

98
00:06:40,940 --> 00:06:44,550
entonces voy a llamar a la misma devolución de llamada,

99
00:06:44,550 --> 00:06:46,910
pero con el primer parámetro.

100
00:06:46,910 --> 00:06:51,800
Así que déjame copiar ese código aquí.

101
00:06:51,800 --> 00:07:05,490
Todavía voy a usar el setTimeout aquí.

102
00:07:05,490 --> 00:07:10,727
Pero esa primera parte no va a ser un error,

103
00:07:10,727 --> 00:07:13,005
en cambio, la primera parte,

104
00:07:13,005 --> 00:07:15,235
en este caso, no hay error.

105
00:07:15,235 --> 00:07:20,455
Así que solo voy a pasar ese valor como nulo.

106
00:07:20,455 --> 00:07:22,950
Entonces eso significa que el error se establece en nulo.

107
00:07:22,950 --> 00:07:26,335
Así que este es un rectángulo válido.

108
00:07:26,335 --> 00:07:29,965
Así que podemos calcular los valores para el rectángulo.

109
00:07:29,965 --> 00:07:35,165
Pero en su lugar, simplemente voy a pasar

110
00:07:35,165 --> 00:07:40,020
un objeto JavaScript que contiene las dos funciones

111
00:07:40,020 --> 00:07:45,330
como los dos valores dentro de este objeto JavaScript.

112
00:07:45,330 --> 00:07:50,355
Así que, aquí voy a tomar estos dos,

113
00:07:50,355 --> 00:07:54,530
el perímetro y el área,

114
00:07:55,250 --> 00:08:05,639
y luego estos dos serán pasados como los dos valores aquí, el

115
00:08:05,639 --> 00:08:07,807
perímetro y el área.

116
00:08:07,807 --> 00:08:12,740
Y estos dos, ya que resultan ser un objeto JavaScript,

117
00:08:12,740 --> 00:08:16,544
por lo que el perímetro y

118
00:08:16,544 --> 00:08:22,690
el área serán las dos propiedades que pasaré dentro de esos objetos JavaScript,

119
00:08:22,690 --> 00:08:25,295
y eso es todo.

120
00:08:25,295 --> 00:08:28,570
Así que aquí, en el segundo caso,

121
00:08:28,570 --> 00:08:32,034
el error se establece en nulo porque no hay error,

122
00:08:32,034 --> 00:08:33,190
pero la segunda parte,

123
00:08:33,190 --> 00:08:37,715
observe que estoy pasando un objeto JavaScript que contiene dos propiedades,

124
00:08:37,715 --> 00:08:41,530
perímetro y área, que son dos funciones aquí.

125
00:08:41,530 --> 00:08:46,060
Así que las dos funciones son la función perimetral y la función de área.

126
00:08:46,060 --> 00:08:49,390
Por lo tanto, este objeto JavaScript se pasará como

127
00:08:49,390 --> 00:08:53,705
el valor devuelto para la devolución de llamada aquí, el segundo valor.

128
00:08:53,705 --> 00:08:56,035
Y de nuevo, voy a retrasar esto por

129
00:08:56,035 --> 00:09:02,900
un intervalo de dos segundos antes de que el valor sea pasado por esta función.

130
00:09:02,900 --> 00:09:07,075
La razón por la que estoy usando setTimeout es para simular

131
00:09:07,075 --> 00:09:11,780
un retraso antes de que la devolución de llamada llegue desde el otro lado.

132
00:09:11,780 --> 00:09:15,280
Entonces, este tipo de representa situaciones en las

133
00:09:15,280 --> 00:09:18,565
que, por ejemplo, emite una llamada a la base de datos a la base de datos,

134
00:09:18,565 --> 00:09:23,300
y la base de datos debe leerse antes de que el valor se vuelva a transferir a usted.

135
00:09:23,300 --> 00:09:25,855
Así que eso va a tomar una cierta cantidad de tiempo.

136
00:09:25,855 --> 00:09:32,560
Así que básicamente estoy simulando esto en este momento usando la función setTimeout aquí.

137
00:09:32,560 --> 00:09:37,000
Más adelante, verá que cuando integremos el MongoDB con

138
00:09:37,000 --> 00:09:43,060
nuestro Express en los ejercicios posteriores,

139
00:09:43,060 --> 00:09:45,580
ese retraso tendría que ser simulado,

140
00:09:45,580 --> 00:09:48,670
será causado automáticamente por el hecho de que necesita realizar

141
00:09:48,670 --> 00:09:54,190
operaciones de base de datos entre bastidores antes de obtener los datos.

142
00:09:54,190 --> 00:10:00,325
Así que aquí, después de haber completado esta actualización de módulos de rectángulo,

143
00:10:00,325 --> 00:10:03,135
aquí ves que el módulo rectángulo toma

144
00:10:03,135 --> 00:10:06,830
tres parámetros, ya que es una llamada de entrada aquí,

145
00:10:06,830 --> 00:10:08,920
x, y y devolución de llamada.

146
00:10:08,920 --> 00:10:12,445
Y así, la devolución de llamada es la función de devolución de llamada que se suministra aquí.

147
00:10:12,445 --> 00:10:16,585
Y esta función de devolución de llamada se llamará aquí dentro,

148
00:10:16,585 --> 00:10:18,685
y cuando se llame a la función de devolución

149
00:10:18,685 --> 00:10:22,495
de llamada, o se devuelve

150
00:10:22,495 --> 00:10:28,045
un error o se devuelve una función que le permite calcular el perímetro y el área del rectángulo.

151
00:10:28,045 --> 00:10:33,835
Ahora, este patrón de llamar y pasar una función de devolución de llamada

152
00:10:33,835 --> 00:10:40,300
desde un módulo de nodo y luego el segundo módulo de nodo que cuando se complete,

153
00:10:40,300 --> 00:10:44,800
pasará de nuevo el resultado usando la función de devolución de llamada es

154
00:10:44,800 --> 00:10:50,135
exactamente el patrón que verá a menudo repetido en las aplicaciones de nodo.

155
00:10:50,135 --> 00:10:52,360
Así que esa es la razón por la que lo estoy ilustrando.

156
00:10:52,360 --> 00:10:58,735
Por supuesto, este es un ejemplo artificial que estoy ilustrando aquí, pero muestra

157
00:10:58,735 --> 00:11:02,525
todos los patrones estándar que usará con

158
00:11:02,525 --> 00:11:07,065
las funciones de nodo y devolución de llamada y también el manejo de errores.

159
00:11:07,065 --> 00:11:10,955
Ahora, hemos actualizado el módulo rectángulo aquí.

160
00:11:10,955 --> 00:11:16,870
Vamos a arreglar ese archivo index.js para que pueda pasar en la función de devolución de llamada y

161
00:11:16,870 --> 00:11:23,770
luego manejar el valor devuelto que se envía desde el módulo rectángulo.

162
00:11:23,770 --> 00:11:26,940
Volviendo a index.js,

163
00:11:26,940 --> 00:11:31,270
ahora vamos a actualizar el archivo index.js de la siguiente manera.

164
00:11:31,270 --> 00:11:37,955
Voy a eliminar esto del archivo index.js en su lugar.

165
00:11:37,955 --> 00:11:42,430
Aquí, lo que terminaremos haciendo es llamar a

166
00:11:42,430 --> 00:11:49,120
este módulo rectángulo y

167
00:11:49,120 --> 00:11:53,880
luego pasar el l y el b como los dos parámetros.

168
00:11:53,880 --> 00:12:00,300
Y el tercer parámetro que voy a pasar es esa función de devolución de llamada.

169
00:12:00,300 --> 00:12:10,080
Entonces, la función de devolución de llamada tiene dos parámetros, err y rectángulo.

170
00:12:10,080 --> 00:12:15,860
Y esta función de devolución de llamada se implementa de la siguiente manera aquí.

171
00:12:15,860 --> 00:12:19,090
Así que aquí, ves que estoy llamando a

172
00:12:19,090 --> 00:12:23,785
este módulo de nodo rectángulo y estoy

173
00:12:23,785 --> 00:12:29,050
pasando la longitud y la amplitud de los dos primeros parámetros.

174
00:12:29,050 --> 00:12:31,285
Y el tercer parámetro es, por supuesto,

175
00:12:31,285 --> 00:12:34,355
una función de devolución de llamada que estoy implementando aquí.

176
00:12:34,355 --> 00:12:38,250
Entonces, esta es una función de flecha que estoy implementando aquí.

177
00:12:38,250 --> 00:12:40,510
Entonces, dentro de esta función de devolución de llamada,

178
00:12:40,510 --> 00:12:43,245
¿cómo manejo el valor de retorno?

179
00:12:43,245 --> 00:12:46,860
Así que aquí diré si (err),

180
00:12:46,860 --> 00:12:51,335
por lo que si se devuelve el valor de error,

181
00:12:51,335 --> 00:12:59,500
entonces simplemente haré console.log y diré

182
00:12:59,500 --> 00:13:09,100
«ERROR» y luego el segundo valor es err.message.

183
00:13:09,100 --> 00:13:11,445
Recordemos que en el rectángulo,

184
00:13:11,445 --> 00:13:14,820
habíamos creado este nuevo objeto de error

185
00:13:14,820 --> 00:13:18,155
y luego pasado en esta cadena dentro de este objeto de error.

186
00:13:18,155 --> 00:13:20,100
Esta cadena se adjuntará

187
00:13:20,100 --> 00:13:24,380
al objeto error a la propiedad message del objeto error aquí.

188
00:13:24,380 --> 00:13:26,830
Entonces, en el archivo index.js,

189
00:13:26,830 --> 00:13:30,090
estoy recuperando la propiedad de mensaje del objeto de error

190
00:13:30,090 --> 00:13:33,755
y luego la imprimo en mi consola aquí.

191
00:13:33,755 --> 00:13:35,310
Entonces, si ocurre un error,

192
00:13:35,310 --> 00:13:39,215
voy a imprimir el mensaje de error usando esto.

193
00:13:39,215 --> 00:13:45,820
Y entonces, así es como manejaría el error que fue devuelto por una función de devolución de llamada.

194
00:13:45,820 --> 00:13:51,360
De lo contrario, por supuesto, en este caso,

195
00:13:51,360 --> 00:13:57,450
el módulo rectángulo ha devuelto la función rectángulo,

196
00:13:57,450 --> 00:14:01,620
el objeto que contiene el perímetro y las funciones de área, por

197
00:14:01,620 --> 00:14:08,108
lo que puedo seguir adelante e imprimir ese valor.

198
00:14:08,108 --> 00:14:14,175
Así que aquí, voy a decir que el área del rectángulo

199
00:14:14,175 --> 00:14:23,030
de dimensiones l igual a,

200
00:14:23,140 --> 00:14:28,270
así que voy a decir,

201
00:14:29,170 --> 00:14:37,155
y b igual a.

202
00:14:37,155 --> 00:14:40,530
La razón por la que lo estoy identificando

203
00:14:40,530 --> 00:14:47,340
explícitamente será muy clara cuando ejecutemos este ejemplo.

204
00:14:47,340 --> 00:15:01,480
Diré que es rectangle.area.

205
00:15:01,480 --> 00:15:04,188
Ahora, observe que para esta área,

206
00:15:04,188 --> 00:15:09,555
no estoy enviando ningún parámetro aquí porque va a valores,

207
00:15:09,555 --> 00:15:14,540
la longitud y la respiración ya se han pasado aquí en l y b,

208
00:15:14,540 --> 00:15:19,065
y esos ya estarían disponibles para esto

209
00:15:19,065 --> 00:15:24,245
y aquí debido al cierre que admite JavaScript.

210
00:15:24,245 --> 00:15:27,470
Debido a que estos x e y han entrado como los parámetros,

211
00:15:27,470 --> 00:15:32,710
por lo que serán accesibles allí mismo en esta función de devolución de llamada.

212
00:15:32,710 --> 00:15:37,315
Así que esos x_y estarán disponibles automáticamente para nosotros aquí.

213
00:15:37,315 --> 00:15:39,890
Por lo tanto, de hecho,

214
00:15:39,890 --> 00:15:43,970
no necesito proporcionar estos parámetros x e y aquí en absoluto porque

215
00:15:43,970 --> 00:15:49,090
esos x e y se recuperarán de este x e y de allí.

216
00:15:49,090 --> 00:15:53,375
Así que ni siquiera necesito pasar esos dos valores aquí.

217
00:15:53,375 --> 00:15:55,385
Así que por eso, ahí mismo,

218
00:15:55,385 --> 00:15:57,905
puedo llamar a rectangle.area.

219
00:15:57,905 --> 00:16:03,170
Y este cálculo de área obtendrá automáticamente los l y b que han sido pasados

220
00:16:03,170 --> 00:16:09,505
por la llamada rectángulo al módulo de nodo directo anteriormente.

221
00:16:09,505 --> 00:16:14,980
Así que este es el cierre de JavaScript que opera aquí.

222
00:16:14,980 --> 00:16:17,945
Entonces, ése es el primero.

223
00:16:17,945 --> 00:16:23,305
Estoy imprimiendo el área del rectángulo.

224
00:16:23,305 --> 00:16:32,990
Lo mismo, permítanme también imprimir los perímetros.

225
00:16:32,990 --> 00:16:34,608
Así que para imprimir los perímetros,

226
00:16:34,608 --> 00:16:36,720
así que diré console.log.

227
00:16:36,720 --> 00:16:46,560
El perímetro del rectángulo será el perímetro del rectángulo.

228
00:16:46,560 --> 00:16:53,280
Ahora, debo decirles que este tipo de enfoque para implementar requiere un poco

229
00:16:53,280 --> 00:17:02,335
de esfuerzo para comprender e internalizar la capacidad de la función asíncrona.

230
00:17:02,335 --> 00:17:06,360
Toma algo de tiempo para que entiendas completamente cómo funciona realmente.

231
00:17:06,360 --> 00:17:08,550
Ahora para ilustrar el hecho de que

232
00:17:08,550 --> 00:17:14,642
esta llamada a la función resultará en una llamada al módulo Node,

233
00:17:14,642 --> 00:17:19,280
pero esta parte se ejecutará sólo después de

234
00:17:19,280 --> 00:17:24,830
un retraso de dos segundos debido al hecho de que estamos utilizando la marca de tiempo establecida.

235
00:17:24,830 --> 00:17:28,745
Ahora, como estudiamos en la operación asíncrona,

236
00:17:28,745 --> 00:17:33,155
porque hemos pasado del procesamiento a la parte posterior,

237
00:17:33,155 --> 00:17:41,420
permítanme también presentar un console.log más aquí para hacer un punto.

238
00:17:41,420 --> 00:17:46,175
Así que diremos que esta declaración es

239
00:17:46,175 --> 00:17:53,869
después de la llamada a rect.

240
00:17:53,869 --> 00:18:00,210
La razón por la que estoy ilustrando este punto es que cuando emite esta llamada,

241
00:18:00,210 --> 00:18:06,130
este código no se ejecutará hasta después de un retraso de dos segundos.

242
00:18:06,130 --> 00:18:08,070
Entonces, mientras tanto,

243
00:18:08,070 --> 00:18:10,360
su función, la función principal aquí,

244
00:18:10,360 --> 00:18:16,340
continuará y luego ejecutará la siguiente línea de código que vea aquí.

245
00:18:16,340 --> 00:18:19,745
Así que esta es la continuación que verá aquí.

246
00:18:19,745 --> 00:18:21,805
Por lo tanto, con estos cambios,

247
00:18:21,805 --> 00:18:27,815
vamos a guardar los cambios y luego ver cómo se ejecuta esta aplicación ahora.

248
00:18:27,815 --> 00:18:29,410
Así que guardando los cambios.

249
00:18:29,410 --> 00:18:35,220
Vamos a la terminal y ejecutar esta aplicación de nodo.

250
00:18:35,220 --> 00:18:37,570
Ahora, yendo a la terminal, agregue el mensaje.

251
00:18:37,570 --> 00:18:43,795
Permítanme escribir npm start e inmediatamente notará

252
00:18:43,795 --> 00:18:51,790
que la resolución y esta declaración se imprimieron antes.

253
00:18:51,790 --> 00:18:54,505
Y luego de este cierto retraso,

254
00:18:54,505 --> 00:18:57,855
el área y el perímetro fueron impresos.

255
00:18:57,855 --> 00:19:02,130
Así que ese es un retraso de dos segundos que introdujimos usando el tiempo de espera establecido.

256
00:19:02,130 --> 00:19:05,755
Por lo tanto, notó que en la versión anterior,

257
00:19:05,755 --> 00:19:10,290
esto fue impreso e inmediatamente el área y el perímetro se imprimieron justo debajo de eso.

258
00:19:10,290 --> 00:19:15,120
Pero ahora, observe que esos valores se imprimen un poco más tarde.

259
00:19:15,120 --> 00:19:20,460
Entonces, en el medio, sus llamadas de función con los diferentes parámetros que ya se han ido

260
00:19:20,460 --> 00:19:26,505
y luego las devoluciones de llamada se vuelven a llamar después de dos segundos de retraso para cada uno de ellos.

261
00:19:26,505 --> 00:19:32,500
Y debido al hecho de que existe el cierre que admite JavaScript,

262
00:19:32,500 --> 00:19:35,980
por lo que se conservan los valores que se pasan.

263
00:19:35,980 --> 00:19:38,440
Y así, cuando se llama a la función de devolución de llamada,

264
00:19:38,440 --> 00:19:40,615
se imprime el valor apropiado.

265
00:19:40,615 --> 00:19:42,730
Así que es por eso que ves que el área y

266
00:19:42,730 --> 00:19:46,330
el perímetro están impresos correctamente y estos dos aquí,

267
00:19:46,330 --> 00:19:48,070
estas dos declaraciones aquí,

268
00:19:48,070 --> 00:19:51,340
corresponden a esta llamada particular a dirigir

269
00:19:51,340 --> 00:19:55,100
con l es igual a dos y b es igual a cuatro.

270
00:19:55,100 --> 00:19:56,605
Y luego estos dos,

271
00:19:56,605 --> 00:19:58,150
los próximos a dos, por supuesto,

272
00:19:58,150 --> 00:20:05,000
corresponden a este particular y a los restantes como ven aquí. Por

273
00:20:05,000 --> 00:20:10,410
lo tanto, lo que quería ilustrar es el hecho de que cuando realiza un cálculo asíncrono,

274
00:20:10,410 --> 00:20:12,730
el cálculo asíncrono toma su propio tiempo

275
00:20:12,730 --> 00:20:16,270
para devolver el valor mientras que su cálculo principal

276
00:20:16,270 --> 00:20:22,460
continuará adelante sin esperar a que se complete la devolución de llamada.

277
00:20:22,460 --> 00:20:25,245
Por lo tanto, cuando necesita hacer una cierta cantidad de trabajo,

278
00:20:25,245 --> 00:20:29,365
pasó como una devolución de llamada a ese otro módulo.

279
00:20:29,365 --> 00:20:31,375
Y cuando ese otro módulo complete su trabajo,

280
00:20:31,375 --> 00:20:35,010
va a devolver la llamada y luego ese código se ejecutará.

281
00:20:35,010 --> 00:20:40,350
Así que ese es el punto que he ilustrado usando este ejemplo.

282
00:20:40,350 --> 00:20:41,565
Una vez más, como dije,

283
00:20:41,565 --> 00:20:45,210
esto requiere un poco de imaginación y comprensión

284
00:20:45,210 --> 00:20:48,930
para que internalice la forma en que esto funciona,

285
00:20:48,930 --> 00:20:55,185
pero verá que con Node y también Express y cuando usamos MongoDB,

286
00:20:55,185 --> 00:21:01,785
verá este tipo de patrón que se repite muy a menudo en la forma en que escribimos nuestro código.

287
00:21:01,785 --> 00:21:06,210
Así que con esta sencilla ilustración de devoluciones de llamada y manejo de errores,

288
00:21:06,210 --> 00:21:08,940
completamos este ejercicio.

289
00:21:08,940 --> 00:21:13,675
Este es un buen momento para que usted haga un comentario get con ese mensaje,

290
00:21:13,675 --> 00:21:17,700
nodo, devoluciones de llamada y manejo de errores.