1
00:00:03,680 --> 00:00:07,140
Una discusión sobre los módulos de nodos está incompleta

2
00:00:07,140 --> 00:00:10,310
sin hablar de devoluciones de llamada y manejo de errores.

3
00:00:10,310 --> 00:00:14,820
¿ Qué son las devoluciones de llamada y por qué son esenciales para

4
00:00:14,820 --> 00:00:17,250
soportar el cálculo asincrónico que es muy

5
00:00:17,250 --> 00:00:20,610
útil cuando escribimos aplicaciones Node.js?

6
00:00:20,610 --> 00:00:25,130
¿ Cómo se realiza el manejo de errores en las aplicaciones de Node?

7
00:00:25,130 --> 00:00:29,615
Hablemos brevemente sobre esto en esta conferencia.

8
00:00:29,615 --> 00:00:34,305
Antes de proceder a hablar sobre los módulos de nodo y las devoluciones de llamada,

9
00:00:34,305 --> 00:00:40,315
necesitamos entender dos características destacadas sobre el lenguaje JavaScript en sí.

10
00:00:40,315 --> 00:00:46,295
En primer lugar, JavaScript admite lo que se llama funciones de primera clase.

11
00:00:46,295 --> 00:00:48,430
¿ Qué queremos decir con funciones de primera clase?

12
00:00:48,430 --> 00:00:52,838
Es que una función puede ser tratada como cualquier otra variable.

13
00:00:52,838 --> 00:00:55,620
Y por lo tanto, las funciones se pueden pasar como

14
00:00:55,620 --> 00:01:00,955
parámetros dentro de las llamadas de función a otras funciones.

15
00:01:00,955 --> 00:01:06,630
Y eso esencialmente nos permite enviar funciones como funciones de devolución de llamada que se pueden

16
00:01:06,630 --> 00:01:14,110
llamar desde otro módulo de Node con el fin de realizar algún trabajo.

17
00:01:14,110 --> 00:01:20,010
Luego mire cómo esto es muy útil para admitir devoluciones de llamada en Node.js.

18
00:01:20,010 --> 00:01:25,107
El segundo aspecto sobre JavaScript es el soporte para cierres.

19
00:01:25,107 --> 00:01:26,835
¿ Qué queremos decir con cierres?

20
00:01:26,835 --> 00:01:31,185
Especialmente, si está familiarizado con los lenguajes de programación funcionales,

21
00:01:31,185 --> 00:01:33,325
entiende cómo funciona el cierre.

22
00:01:33,325 --> 00:01:37,050
Una función definida dentro de otra función

23
00:01:37,050 --> 00:01:42,955
obtiene automáticamente acceso a las variables que se declaran en la función externa.

24
00:01:42,955 --> 00:01:46,185
Entonces, incluso si la función externa se completa la ejecución,

25
00:01:46,185 --> 00:01:51,000
cuando la función interna se ejecuta más adelante, la función interna todavía tendrá acceso a

26
00:01:51,000 --> 00:01:56,020
los valores de las variables dentro de esa función externa.

27
00:01:56,020 --> 00:01:57,465
Y esto se

28
00:01:57,465 --> 00:02:05,244
usa de nuevo, de manera muy efectiva cuando usamos Callbacks en aplicaciones de Node.

29
00:02:05,244 --> 00:02:08,790
Si está acostumbrado a la forma estándar de escribir aplicaciones,

30
00:02:08,790 --> 00:02:12,870
entonces está familiarizado con el cálculo sincrónico donde

31
00:02:12,870 --> 00:02:17,918
especifica un cálculo como un conjunto de pasos que se deben realizar uno tras otro.

32
00:02:17,918 --> 00:02:21,165
Ahora, si organiza el cálculo de la siguiente manera,

33
00:02:21,165 --> 00:02:27,885
como se muestra en el lado izquierdo de la diapositiva aquí,

34
00:02:27,885 --> 00:02:33,260
tenemos el cálculo uno seguido de un cálculo de larga ejecución,

35
00:02:33,260 --> 00:02:36,095
seguido por el cálculo dos y el cálculo tres.

36
00:02:36,095 --> 00:02:38,400
Entonces, en este arreglo,

37
00:02:38,400 --> 00:02:41,940
supongamos que el cálculo dos depende de que

38
00:02:41,940 --> 00:02:45,250
el cálculo de larga ejecución complete su trabajo,

39
00:02:45,250 --> 00:02:48,690
entonces tiene sentido que el cálculo dos espere hasta que se

40
00:02:48,690 --> 00:02:53,430
complete el cálculo de larga ejecución antes de que se ejecute.

41
00:02:53,430 --> 00:02:56,670
Ahora, podríamos tener otra pieza de

42
00:02:56,670 --> 00:03:00,435
trabajo que se define por el cálculo tres. El

43
00:03:00,435 --> 00:03:05,055
cálculo tres puede depender de ninguna manera del cálculo dos,

44
00:03:05,055 --> 00:03:11,092
o del cálculo de larga ejecución para completar antes de ejecutarlo.

45
00:03:11,092 --> 00:03:12,420
Entonces, en este caso,

46
00:03:12,420 --> 00:03:16,635
si hacemos la ejecución sincrónica de este

47
00:03:16,635 --> 00:03:18,825
cálculo, entonces el cálculo tres se atascará,

48
00:03:18,825 --> 00:03:23,895
aunque de ninguna manera depende de la finalización del cálculo dos,

49
00:03:23,895 --> 00:03:25,800
o el cálculo de larga ejecución.

50
00:03:25,800 --> 00:03:29,310
Por lo tanto, la cantidad de trabajo que se debe hacer mediante el cálculo tres,

51
00:03:29,310 --> 00:03:35,625
se retrasará debido a ninguna razón propia, ¿verdad?

52
00:03:35,625 --> 00:03:41,725
En su lugar se retrasa debido a algo que lo precede en la secuencia de cálculo.

53
00:03:41,725 --> 00:03:45,735
Ahora, el cálculo asíncrono, podemos reorganizar este trabajo de

54
00:03:45,735 --> 00:03:50,265
tal manera que el cálculo uno, cuando se completa,

55
00:03:50,265 --> 00:03:57,350
pueda generar esos cálculos de larga ejecución que se realizan detrás de las escenas de forma independiente,

56
00:03:57,350 --> 00:04:02,706
y dado que el cálculo dos depende del cálculo de larga ejecución para terminar,

57
00:04:02,706 --> 00:04:09,314
entonces el cálculo dos se puede ejecutar cuando finalice el cálculo de larga ejecución.

58
00:04:09,314 --> 00:04:14,265
Ahora, esto libera el cálculo tres para continuar,

59
00:04:14,265 --> 00:04:16,820
justo después de que termine el cálculo uno.

60
00:04:16,820 --> 00:04:18,585
Así que esta forma de organizar,

61
00:04:18,585 --> 00:04:22,815
asegura que el cálculo tres terminará mucho más rápido que

62
00:04:22,815 --> 00:04:28,000
estar atascado detrás del cálculo de larga ejecución, y el cálculo dos.

63
00:04:28,000 --> 00:04:33,945
Por lo tanto, este enfoque de reorganizar su trabajo es muy útil especialmente,

64
00:04:33,945 --> 00:04:37,650
cuando tiene un cálculo de larga ejecución, especialmente, cómputos

65
00:04:37,650 --> 00:04:40,000
enlazados de E/S que se deben realizar.

66
00:04:40,000 --> 00:04:43,174
Entonces, en este caso, puede generar fuera del cálculo enlazado de E/S,

67
00:04:43,174 --> 00:04:44,700
y cuando eso se complete,

68
00:04:44,700 --> 00:04:47,580
entonces cualquier cosa que deba hacerse a partir de entonces,

69
00:04:47,580 --> 00:04:51,830
se puede enviar a él como una devolución de llamada.

70
00:04:51,830 --> 00:04:54,540
Por lo tanto, el cálculo dos se convertirá en

71
00:04:54,540 --> 00:04:58,490
una devolución de llamada y luego se dará al cálculo de larga ejecución.

72
00:04:58,490 --> 00:05:01,440
Entonces, cuando eso complete su trabajo,

73
00:05:01,440 --> 00:05:07,015
devolverá la llamada a la función que está encerrada dentro de la devolución de llamada.

74
00:05:07,015 --> 00:05:11,020
Así que esto es aprovechado de manera muy efectiva por Node.js al

75
00:05:11,020 --> 00:05:17,250
reorganizar el cálculo dentro de nuestras aplicaciones Node.

76
00:05:17,250 --> 00:05:20,740
Ahora, esto es muy,

77
00:05:20,740 --> 00:05:25,520
muy útil cuando miramos la forma en que Node.js se ejecuta.

78
00:05:25,520 --> 00:05:26,735
Entonces, como nos damos cuenta,

79
00:05:26,735 --> 00:05:31,830
Node.js está organizado en un solo bucle de eventos subprocesos.

80
00:05:31,830 --> 00:05:34,690
Este bucle de eventos de subproceso único, básicamente,

81
00:05:34,690 --> 00:05:39,620
recoge las solicitudes a medida que entran y lo ejecutan una tras otra.

82
00:05:39,620 --> 00:05:42,592
Siempre que necesite generar una solicitud de E/S,

83
00:05:42,592 --> 00:05:44,650
la solicitud de E/S se generará

84
00:05:44,650 --> 00:05:48,910
y cualquier trabajo que deba hacerse después de que se complete la solicitud de E/S,

85
00:05:48,910 --> 00:05:51,330
se incluirá dentro de una devolución de llamada.

86
00:05:51,330 --> 00:05:52,940
Entonces, cuando se complete la solicitud de E/S,

87
00:05:52,940 --> 00:05:55,660
colocará la devolución de llamada en la cola de solicitudes,

88
00:05:55,660 --> 00:05:58,510
y la devolución de llamada será manejada a partir de entonces,

89
00:05:58,510 --> 00:06:00,030
por el bucle de eventos.

90
00:06:00,030 --> 00:06:02,890
Entonces, el bucle de eventos es un bucle en ejecución continua

91
00:06:02,890 --> 00:06:06,595
que básicamente recoge las solicitudes de la cola de solicitudes,

92
00:06:06,595 --> 00:06:09,240
y luego las presta de una a la vez.

93
00:06:09,240 --> 00:06:11,470
Entonces, cuando lo piensas,

94
00:06:11,470 --> 00:06:14,093
te das cuenta de que Node.js es un único subproceso,

95
00:06:14,093 --> 00:06:15,340
pero al mismo tiempo,

96
00:06:15,340 --> 00:06:19,645
es capaz de lograr una tasa mucho más rápida de finalización del trabajo,

97
00:06:19,645 --> 00:06:24,580
simplemente debido al uso juicioso de las devoluciones de llamada

98
00:06:24,580 --> 00:06:29,680
y la ejecución asíncrona de solicitudes de E/S,

99
00:06:29,680 --> 00:06:32,815
como para el archivo accesos o bases de datos,

100
00:06:32,815 --> 00:06:39,280
o procesamiento de larga duración que se puede realizar de forma independiente detrás de escena.

101
00:06:39,280 --> 00:06:43,045
Ahora, la forma en que el bucle de eventos Node.js maneja todo esto,

102
00:06:43,045 --> 00:06:48,410
es que el bucle de eventos está organizado en una secuencia de fases.

103
00:06:48,410 --> 00:06:51,710
Como puede ver en el diagrama que se muestra aquí,

104
00:06:51,710 --> 00:06:55,060
las fases incluyen el manejo del temporizador, el manejo de

105
00:06:55,060 --> 00:06:58,390
devolución de llamada de E/S, luego tiene inactivo, prepara,

106
00:06:58,390 --> 00:07:05,800
luego la encuesta donde se manejan las solicitudes entrantes de conexiones o datos,

107
00:07:05,800 --> 00:07:07,585
y luego la fase de comprobación,

108
00:07:07,585 --> 00:07:10,290
y luego, finalmente, la fase de devolución de llamada de cierre.

109
00:07:10,290 --> 00:07:16,351
Ahora, algunos detalles sobre lo que se hace en cada una de estas fases se enumeran en el lado derecho.

110
00:07:16,351 --> 00:07:17,905
En la fase del temporizador,

111
00:07:17,905 --> 00:07:21,550
el bucle de eventos maneja cualquier cosa que se active por la

112
00:07:21,550 --> 00:07:25,770
función setTimeout () en JavaScript.

113
00:07:25,770 --> 00:07:29,010
Las devoluciones de llamada de E/S se ejecutan,

114
00:07:29,010 --> 00:07:32,620
casi todas las devoluciones de llamada que vuelven a

115
00:07:32,620 --> 00:07:36,795
ejecutarse después de una solicitud de E/S serán manejadas por la cola de devoluciones de llamada de E/S.

116
00:07:36,795 --> 00:07:41,065
Por lo tanto, cada una de estas fases mantiene su propia cola separada,

117
00:07:41,065 --> 00:07:46,053
y el bucle de eventos Node.js recoge las solicitudes de cada una de estas colas y las maneja.

118
00:07:46,053 --> 00:07:52,150
El, inactivo, preparar, está destinado para uso interno por Node.js.

119
00:07:52,150 --> 00:07:57,910
La encuesta es donde recupera nuevos eventos de E/S para ser manejados y tal vez,

120
00:07:57,910 --> 00:08:00,313
las solicitudes que llegan desde fuera.

121
00:08:00,313 --> 00:08:08,354
La fase de devolución de llamada de cierre maneja los cierres de socket que necesitan ser manejados, y así sucesivamente.

122
00:08:08,354 --> 00:08:11,050
Ahora, no necesitamos preocuparnos demasiado por

123
00:08:11,050 --> 00:08:15,430
todos estos detalles si realmente necesitamos escribir una aplicación Node.js.

124
00:08:15,430 --> 00:08:19,720
Cuando sea necesario, veremos algunos de estos detalles como y cuándo

125
00:08:19,720 --> 00:08:25,030
es esencial para entender cómo funciona nuestra aplicación Node.

126
00:08:25,030 --> 00:08:27,985
Pero por el momento, esto le da una visión general

127
00:08:27,985 --> 00:08:31,990
de cómo se maneja el bucle de eventos Node.js.

128
00:08:31,990 --> 00:08:35,830
Baste decir que esta es suficiente información para que podamos

129
00:08:35,830 --> 00:08:40,590
entender las aplicaciones Node y cómo funcionan por el momento.

130
00:08:40,590 --> 00:08:42,895
Si desea saber más detalles,

131
00:08:42,895 --> 00:08:46,810
entonces le he dado un enlace a una descripción detallada en la

132
00:08:46,810 --> 00:08:53,930
documentación Node.js que explica sobre el bucle de eventos con más detalle.

133
00:08:53,930 --> 00:08:58,615
Con esta rápida comprensión del nodo, las

134
00:08:58,615 --> 00:09:01,445
devoluciones de llamada y el manejo de errores,

135
00:09:01,445 --> 00:09:03,296
pasaremos al ejercicio,

136
00:09:03,296 --> 00:09:09,280
donde veremos cómo una aplicación de nodo puede escribir con devoluciones de llamada,

137
00:09:09,280 --> 00:09:14,110
y cómo se pueden manejar los errores dentro de una aplicación de nodo.

138
00:09:14,110 --> 00:09:18,840
Veremos el uso repetido de este patrón en ejercicios posteriores,

139
00:09:18,840 --> 00:09:21,421
y lecciones posteriores específicamente,

140
00:09:21,421 --> 00:09:22,960
cuando nos fijamos en Express,

141
00:09:22,960 --> 00:09:26,860
y cómo construimos aplicaciones del lado del servidor usando Express con

142
00:09:26,860 --> 00:09:32,720
más detalle en la parte posterior de este curso.