1
00:00:03,680 --> 00:00:07,140
Una discussione sui moduli nodo è incompleta

2
00:00:07,140 --> 00:00:10,310
senza parlare di callback e gestione degli errori.

3
00:00:10,310 --> 00:00:14,820
Cosa sono i callback e perché sono essenziali per

4
00:00:14,820 --> 00:00:17,250
supportare il calcolo asincrono che è molto

5
00:00:17,250 --> 00:00:20,610
utile quando scriviamo applicazioni Node.js?

6
00:00:20,610 --> 00:00:25,130
Come viene eseguita la gestione degli errori nelle applicazioni Node?

7
00:00:25,130 --> 00:00:29,615
Parliamo brevemente di questi in questa lezione.

8
00:00:29,615 --> 00:00:34,305
Prima di procedere a parlare di moduli nodo e callback,

9
00:00:34,305 --> 00:00:40,315
abbiamo bisogno di capire due caratteristiche salienti circa il linguaggio JavaScript stesso.

10
00:00:40,315 --> 00:00:46,295
Innanzitutto, JavaScript supporta ciò che viene chiamato come funzioni di prima classe.

11
00:00:46,295 --> 00:00:48,430
Cosa intendiamo per funzioni di prima classe?

12
00:00:48,430 --> 00:00:52,838
È che una funzione può essere trattata proprio come qualsiasi altra variabile.

13
00:00:52,838 --> 00:00:55,620
E quindi, le funzioni possono essere passate come

14
00:00:55,620 --> 00:01:00,955
parametri all'interno delle chiamate di funzione ad altre funzioni.

15
00:01:00,955 --> 00:01:06,630
E questo essenzialmente ci permette di inviare funzioni come funzioni di callback che possono essere

16
00:01:06,630 --> 00:01:14,110
chiamate da un altro modulo Node per ottenere un po 'di lavoro compiuto.

17
00:01:14,110 --> 00:01:20,010
Quindi guarda come questo è molto utile nel supportare i callback in Node.js.

18
00:01:20,010 --> 00:01:25,107
Il secondo aspetto su JavaScript è il supporto per le chiusure.

19
00:01:25,107 --> 00:01:26,835
Cosa intendiamo per Chiusure?

20
00:01:26,835 --> 00:01:31,185
Soprattutto, se hai familiarità con i linguaggi di programmazione funzionali,

21
00:01:31,185 --> 00:01:33,325
capisci come funziona la chiusura.

22
00:01:33,325 --> 00:01:37,050
Una funzione definita all'interno di un'altra funzione

23
00:01:37,050 --> 00:01:42,955
ottiene automaticamente l'accesso alle variabili dichiarate nella funzione esterna.

24
00:01:42,955 --> 00:01:46,185
Quindi, anche se la funzione esterna è completata,

25
00:01:46,185 --> 00:01:51,000
quando la funzione interna viene eseguita in seguito, la funzione interna avrà ancora accesso ai

26
00:01:51,000 --> 00:01:56,020
valori delle variabili all'interno di quella funzione esterna.

27
00:01:56,020 --> 00:01:57,465
E questo è di nuovo,

28
00:01:57,465 --> 00:02:05,244
utilizzato in modo molto efficace quando usiamo i callback nelle applicazioni Node.

29
00:02:05,244 --> 00:02:08,790
Se sei abituato al modo standard di scrivere applicazioni,

30
00:02:08,790 --> 00:02:12,870
allora hai familiarità con il calcolo sincrono in cui

31
00:02:12,870 --> 00:02:17,918
specifichi un calcolo come un insieme di passaggi da eseguire uno dopo l'altro.

32
00:02:17,918 --> 00:02:21,165
Ora, se si organizza il calcolo come segue,

33
00:02:21,165 --> 00:02:27,885
come mostrato sul lato sinistro della diapositiva qui,

34
00:02:27,885 --> 00:02:33,260
abbiamo il calcolo uno poi seguito da un calcolo lungo in esecuzione,

35
00:02:33,260 --> 00:02:36,095
seguito dal calcolo due, e il calcolo tre.

36
00:02:36,095 --> 00:02:38,400
Quindi, in questa disposizione,

37
00:02:38,400 --> 00:02:41,940
supponiamo che

38
00:02:41,940 --> 00:02:45,250
il calcolo due dipenda dal calcolo a lungo termine che completa il suo lavoro,

39
00:02:45,250 --> 00:02:48,690
quindi ha senso che il calcolo due attenda fino

40
00:02:48,690 --> 00:02:53,430
al completamento del calcolo a lungo termine prima che venga eseguito.

41
00:02:53,430 --> 00:02:56,670
Ora, potremmo avere un altro pezzo di lavoro

42
00:02:56,670 --> 00:03:00,435
da fare che è definito dal calcolo tre. Il

43
00:03:00,435 --> 00:03:05,055
calcolo tre può non dipendere in alcun modo dal calcolo due,

44
00:03:05,055 --> 00:03:11,092
o il calcolo a lungo termine da completare prima che venga eseguito.

45
00:03:11,092 --> 00:03:12,420
Quindi, in questo caso,

46
00:03:12,420 --> 00:03:16,635
se eseguiamo l'esecuzione sincrona di questo

47
00:03:16,635 --> 00:03:18,825
calcolo, il calcolo tre rimarrà bloccato,

48
00:03:18,825 --> 00:03:23,895
anche se non dipende dal completamento del calcolo due

49
00:03:23,895 --> 00:03:25,800
o dal calcolo a lungo termine.

50
00:03:25,800 --> 00:03:29,310
Quindi, la quantità di lavoro da fare con il calcolo tre,

51
00:03:29,310 --> 00:03:35,625
sarà ritardata a causa della sua ragione, giusto?

52
00:03:35,625 --> 00:03:41,725
Invece è ritardato a causa di qualcosa che lo precede nella sequenza di calcolo.

53
00:03:41,725 --> 00:03:45,735
Ora, calcolo asincrono, possiamo riorganizzare questo lavoro

54
00:03:45,735 --> 00:03:50,265
in modo tale che il calcolo uno, una volta completato,

55
00:03:50,265 --> 00:03:57,350
possa generare quei calcoli lunghi da eseguire dietro le quinte in modo indipendente,

56
00:03:57,350 --> 00:04:02,706
e poiché il calcolo due dipende dal calcolo a lungo termine per finire,

57
00:04:02,706 --> 00:04:09,314
quindi il calcolo due può essere eseguito al termine del calcolo a esecuzione prolungata.

58
00:04:09,314 --> 00:04:14,265
Ora, questo libera il calcolo tre per continuare,

59
00:04:14,265 --> 00:04:16,820
subito dopo il calcolo uno termina.

60
00:04:16,820 --> 00:04:18,585
Quindi questo modo di organizzare,

61
00:04:18,585 --> 00:04:22,815
assicura che il calcolo tre finisca molto più velocemente di

62
00:04:22,815 --> 00:04:28,000
essere bloccato dietro il calcolo a lungo termine e il calcolo due.

63
00:04:28,000 --> 00:04:33,945
Quindi questo approccio di riorganizzare il tuo lavoro è molto utile specialmente,

64
00:04:33,945 --> 00:04:37,650
quando hai un calcolo a lungo termine in particolare, il

65
00:04:37,650 --> 00:04:40,000
calcolo legato all'I/O da fare.

66
00:04:40,000 --> 00:04:43,174
Quindi, in questo caso, è possibile generare il calcolo associato all'I/O,

67
00:04:43,174 --> 00:04:44,700
e quando ciò viene completato,

68
00:04:44,700 --> 00:04:47,580
allora qualsiasi cosa debba essere eseguita in seguito,

69
00:04:47,580 --> 00:04:51,830
può essere inviata ad esso come callback.

70
00:04:51,830 --> 00:04:54,540
Quindi il calcolo due verrà trasformato in

71
00:04:54,540 --> 00:04:58,490
un callback e quindi distribuito al calcolo a lungo termine.

72
00:04:58,490 --> 00:05:01,440
Quindi, quando questo completa il suo lavoro,

73
00:05:01,440 --> 00:05:07,015
richiamerà la funzione che è racchiusa all'interno del callback.

74
00:05:07,015 --> 00:05:11,020
Quindi questo è sfruttato in modo molto efficace da Node.js

75
00:05:11,020 --> 00:05:17,250
nel riorganizzare il calcolo all'interno delle nostre applicazioni Node.

76
00:05:17,250 --> 00:05:20,740
Ora, questo è molto,

77
00:05:20,740 --> 00:05:25,520
molto utile quando guardiamo il modo in cui Node.js viene eseguito.

78
00:05:25,520 --> 00:05:26,735
Quindi, come ci rendiamo conto,

79
00:05:26,735 --> 00:05:31,830
Node.js è organizzato in un singolo ciclo di eventi thread.

80
00:05:31,830 --> 00:05:34,690
Questo ciclo di eventi a thread singolo fondamentalmente,

81
00:05:34,690 --> 00:05:39,620
raccoglie le richieste man mano che entrano ed eseguono una dopo l'altra.

82
00:05:39,620 --> 00:05:42,592
Ogni volta che ha bisogno di generare fuori una richiesta di

83
00:05:42,592 --> 00:05:44,650
I/O, la richiesta di I/O verrà generato fuori,

84
00:05:44,650 --> 00:05:48,910
e qualsiasi lavoro che deve essere fatto dopo che la richiesta di I/O è completata,

85
00:05:48,910 --> 00:05:51,330
sarà racchiuso all'interno di un callback.

86
00:05:51,330 --> 00:05:52,940
Quindi, quando la richiesta I/O viene completata,

87
00:05:52,940 --> 00:05:55,660
inserirà il callback nella coda delle richieste

88
00:05:55,660 --> 00:05:58,510
e il callback verrà gestito successivamente,

89
00:05:58,510 --> 00:06:00,030
dal ciclo degli eventi.

90
00:06:00,030 --> 00:06:02,890
Quindi il ciclo degli eventi è un ciclo in esecuzione continua

91
00:06:02,890 --> 00:06:06,595
che raccoglie fondamentalmente le richieste dalla coda delle richieste

92
00:06:06,595 --> 00:06:09,240
e quindi le gestisce una alla volta.

93
00:06:09,240 --> 00:06:11,470
Quindi, quando ci ripensi,

94
00:06:11,470 --> 00:06:14,093
ti rendi conto che Node.js è un singolo thread,

95
00:06:14,093 --> 00:06:15,340
ma allo stesso tempo,

96
00:06:15,340 --> 00:06:19,645
è in grado di ottenere un tasso molto più veloce di completamento del lavoro,

97
00:06:19,645 --> 00:06:24,580
semplicemente a causa dell'uso giudizioso dei callback

98
00:06:24,580 --> 00:06:29,680
e dell'esecuzione asincrona di richieste I/O,

99
00:06:29,680 --> 00:06:32,815
come per file accessi o database,

100
00:06:32,815 --> 00:06:39,280
o elaborazione a esecuzione prolungata che può essere eseguita indipendentemente dietro le quinte.

101
00:06:39,280 --> 00:06:43,045
Ora, il modo in cui il ciclo di eventi Node.js gestisce tutto questo,

102
00:06:43,045 --> 00:06:48,410
è che il ciclo di eventi è organizzato in una sequenza di fasi.

103
00:06:48,410 --> 00:06:51,710
Quindi, come si vede nel diagramma mostrato qui,

104
00:06:51,710 --> 00:06:55,060
le fasi includono la gestione del timer, la gestione del

105
00:06:55,060 --> 00:06:58,390
callback I/O, quindi si dispone di inattività, preparare,

106
00:06:58,390 --> 00:07:05,800
quindi il sondaggio in cui vengono gestite le richieste in arrivo per le connessioni o i dati,

107
00:07:05,800 --> 00:07:07,585
e quindi la fase di controllo,

108
00:07:07,585 --> 00:07:10,290
e infine, la fase di callback di chiusura.

109
00:07:10,290 --> 00:07:16,351
Ora, alcuni dettagli su ciò che viene fatto in ciascuna di queste fasi sono elencati sul lato destro.

110
00:07:16,351 --> 00:07:17,905
Nella fase di timer,

111
00:07:17,905 --> 00:07:21,550
il ciclo di eventi gestisce tutto ciò che viene attivato dalla

112
00:07:21,550 --> 00:07:25,770
funzione setTimeout () in JavaScript.

113
00:07:25,770 --> 00:07:29,010
I callback I/O vengono eseguiti,

114
00:07:29,010 --> 00:07:32,620
quasi tutti i callback che ritornano per essere

115
00:07:32,620 --> 00:07:36,795
eseguiti dopo una richiesta I/O saranno gestiti dalla coda di callback I/O.

116
00:07:36,795 --> 00:07:41,065
Quindi ognuna di queste fasi mantiene la propria coda separata

117
00:07:41,065 --> 00:07:46,053
e il ciclo di eventi Node.js raccoglie le richieste da ciascuna di queste code e le gestisce.

118
00:07:46,053 --> 00:07:52,150
Il, inattivo, preparare, è pensato per l'uso interno da parte di Node.js.

119
00:07:52,150 --> 00:07:57,910
Il sondaggio è dove recupera nuovi eventi I/O da gestire e, forse,

120
00:07:57,910 --> 00:08:00,313
le richieste provenienti dall'esterno.

121
00:08:00,313 --> 00:08:08,354
La fase di callback di chiusura gestisce tutte le chiusure di socket che devono essere gestite e così via.

122
00:08:08,354 --> 00:08:11,050
Ora, non abbiamo bisogno di preoccuparci troppo di

123
00:08:11,050 --> 00:08:15,430
tutti questi dettagli se abbiamo bisogno di scrivere davvero un'applicazione Node.js.

124
00:08:15,430 --> 00:08:19,720
Quando richiesto, esamineremo alcuni di questi dettagli come e quando

125
00:08:19,720 --> 00:08:25,030
è essenziale per capire come funziona la nostra applicazione Node.

126
00:08:25,030 --> 00:08:27,985
Ma per il momento, questo ti dà una visione

127
00:08:27,985 --> 00:08:31,990
d'insieme di come viene gestito il ciclo degli eventi Node.js.

128
00:08:31,990 --> 00:08:35,830
Basti dire che questa è sufficiente informazione per noi per

129
00:08:35,830 --> 00:08:40,590
capire le applicazioni Node e come funzionano per il momento.

130
00:08:40,590 --> 00:08:42,895
Se vuoi saperne di più,

131
00:08:42,895 --> 00:08:46,810
ti ho dato un link a una descrizione dettagliata nella

132
00:08:46,810 --> 00:08:53,930
documentazione Node.js che spiega il ciclo degli eventi in modo più dettagliato.

133
00:08:53,930 --> 00:08:58,615
Con questa rapida comprensione del nodo,

134
00:08:58,615 --> 00:09:01,445
callback, e gestione degli errori,

135
00:09:01,445 --> 00:09:03,296
passeremo all'esercizio,

136
00:09:03,296 --> 00:09:09,280
dove vedremo come un'applicazione nodo può scritto con callback,

137
00:09:09,280 --> 00:09:14,110
e come gli errori possono essere gestiti all'interno di un'applicazione nodo.

138
00:09:14,110 --> 00:09:18,840
Vedremo l'uso ripetuto di questo modello negli esercizi successivi,

139
00:09:18,840 --> 00:09:21,421
e le lezioni successive in particolare,

140
00:09:21,421 --> 00:09:22,960
quando guardiamo a Express,

141
00:09:22,960 --> 00:09:26,860
e come costruiamo applicazioni lato server utilizzando Express

142
00:09:26,860 --> 00:09:32,720
in modo più dettagliato nella parte successiva di questo corso.