1
00:00:01,120 --> 00:00:03,120
‫Istruttore: In questo video

2
00:00:03,120 --> 00:00:06,030
‫e nel prossimo ci addentreremo in un

3
00:00:06,030 --> 00:00:08,870
‫altro pezzo importante dell'architettura Node JS con

4
00:00:08,870 --> 00:00:11,093
‫eventi JS e architettura event-driven.

5
00:00:12,370 --> 00:00:15,210
‫Quindi la maggior parte dei moduli principali

6
00:00:15,210 --> 00:00:19,780
‫di Node, come quelli che abbiamo già usato, come HTTP, File System

7
00:00:19,780 --> 00:00:23,200
‫e Timer, sono costruiti attorno a un'architettura guidata dagli

8
00:00:23,200 --> 00:00:25,830
‫eventi e ovviamente possiamo anche usare

9
00:00:25,830 --> 00:00:28,720
‫questa architettura a nostro vantaggio nel nostro codice.

10
00:00:28,720 --> 00:00:31,910
‫E il concetto è in realtà abbastanza semplice.

11
00:00:31,910 --> 00:00:34,780
‫Quindi, in Node, ci sono alcuni oggetti chiamati

12
00:00:34,780 --> 00:00:37,843
‫emettitori di eventi che emettono eventi con nome non

13
00:00:37,843 --> 00:00:41,520
‫appena accade qualcosa di importante nell'app, come una richiesta che

14
00:00:41,520 --> 00:00:45,360
‫colpisce il server, o un timer in scadenza, o un file

15
00:00:45,360 --> 00:00:47,660
‫che sta finendo di leggere.

16
00:00:47,660 --> 00:00:51,030
‫Questi eventi possono quindi essere rilevati dagli ascoltatori

17
00:00:51,030 --> 00:00:54,380
‫di eventi impostati da noi sviluppatori,

18
00:00:54,380 --> 00:00:58,870
‫che attiveranno le funzioni di callback associate a ciascun ascoltatore, ok.

19
00:00:58,870 --> 00:01:02,150
‫Quindi, di nuovo, da un lato, abbiamo

20
00:01:02,150 --> 00:01:05,470
‫emettitori di eventi e, dall'altro, ascoltatori di eventi che

21
00:01:05,470 --> 00:01:08,940
‫reagiranno agli eventi emessi chiamando la funzione di callback.

22
00:01:08,940 --> 00:01:10,540
‫Semplice, vero?

23
00:01:10,540 --> 00:01:12,900
‫E probabilmente il modo migliore per capirlo

24
00:01:12,900 --> 00:01:14,630
‫è guardare un esempio.

25
00:01:14,630 --> 00:01:17,760
‫E quindi capiamo brevemente come Node

26
00:01:17,760 --> 00:01:21,330
‫usa l'architettura event-driven per gestire le richieste del

27
00:01:21,330 --> 00:01:25,950
‫server nel modulo HTTP che abbiamo già usato in un'altra sezione.

28
00:01:25,950 --> 00:01:28,600
‫Quindi, quando vogliamo creare un server,

29
00:01:28,600 --> 00:01:30,384
‫usiamo il metodo Create

30
00:01:30,384 --> 00:01:33,900
‫Server e lo salviamo in una variabile server.

31
00:01:33,900 --> 00:01:36,260
‫Questa implementazione qui è leggermente diversa

32
00:01:36,260 --> 00:01:40,270
‫da quella che abbiamo fatto prima, ma funziona esattamente allo stesso modo.

33
00:01:40,270 --> 00:01:44,040
‫Comunque, questo server. on è il modo

34
00:01:44,040 --> 00:01:49,040
‫in cui creiamo effettivamente un listener, e in questo caso per l'evento "richiesta".

35
00:01:49,070 --> 00:01:51,390
‫Quindi diciamo che il nostro server è

36
00:01:51,390 --> 00:01:53,770
‫in esecuzione e viene effettuata una nuova richiesta.

37
00:01:53,770 --> 00:01:57,410
‫Il server funge da emettitore ed emetterà automaticamente

38
00:01:57,410 --> 00:02:01,220
‫un evento chiamato "richiesta" ogni volta che una richiesta

39
00:02:01,220 --> 00:02:02,810
‫raggiunge il server.

40
00:02:02,810 --> 00:02:04,350
‫Semplice, vero?

41
00:02:04,350 --> 00:02:07,100
‫Quindi, poiché abbiamo già impostato un

42
00:02:07,100 --> 00:02:10,830
‫listener per questo evento esatto, verrà chiamata automaticamente la funzione

43
00:02:10,830 --> 00:02:14,000
‫di callback che abbiamo collegato a questo listener.

44
00:02:14,000 --> 00:02:16,780
‫E questo tipo di funzione che conosciamo

45
00:02:16,780 --> 00:02:20,040
‫già da prima, invierà semplicemente alcuni dati al client.

46
00:02:20,040 --> 00:02:22,970
‫Ora, funziona in questo modo perché dietro le

47
00:02:22,970 --> 00:02:26,074
‫quinte il server è in realtà un'istanza della

48
00:02:26,074 --> 00:02:28,980
‫classe Node JS EventEmitter, quindi eredita tutta

49
00:02:28,980 --> 00:02:32,500
‫questa logica di emissione e ascolto di eventi da

50
00:02:32,500 --> 00:02:35,410
‫quella classe EventEmitter, e non preoccuparti, useremo

51
00:02:35,410 --> 00:02:38,410
‫tutto bene nel prossimo video, in modo da

52
00:02:38,410 --> 00:02:41,210
‫acquisire familiarità con tutte queste logiche.

53
00:02:41,210 --> 00:02:43,340
‫Ora, solo per finire questa lezione,

54
00:02:43,340 --> 00:02:46,800
‫credo sia importante menzionare che questa logica EventEmitter è

55
00:02:46,800 --> 00:02:49,960
‫chiamata il pattern Observer nella programmazione Javascript in

56
00:02:49,960 --> 00:02:53,160
‫generale, ed è un pattern abbastanza popolare con

57
00:02:53,160 --> 00:02:54,740
‫molti casi usati.

58
00:02:54,740 --> 00:02:57,090
‫Quindi l'idea è di impostare lì

59
00:02:57,090 --> 00:03:00,370
‫un osservatore, in questo caso l'ascoltatore di eventi, che

60
00:03:00,370 --> 00:03:03,450
‫continua ad aspettare, continua ad osservare il soggetto che

61
00:03:03,450 --> 00:03:06,486
‫alla fine emetterà l'evento che l'ascoltatore sta aspettando.

62
00:03:06,486 --> 00:03:09,680
‫E l'opposto di questo schema sono semplicemente le funzioni che

63
00:03:09,680 --> 00:03:12,370
‫chiamano altre funzioni, che è qualcosa a cui

64
00:03:12,370 --> 00:03:14,530
‫siamo più abituati in realtà, giusto?

65
00:03:14,530 --> 00:03:16,490
‫Ma il modello dell'osservatore è

66
00:03:16,490 --> 00:03:19,020
‫stato progettato per reagire piuttosto che per chiamare.

67
00:03:19,020 --> 00:03:22,330
‫E questo perché c'è un enorme vantaggio nell'usare

68
00:03:22,330 --> 00:03:25,248
‫questa architettura, che è il fatto che

69
00:03:25,248 --> 00:03:27,420
‫tutto è più disaccoppiato.

70
00:03:27,420 --> 00:03:30,340
‫Non abbiamo, ad esempio, funzioni dal modulo

71
00:03:30,340 --> 00:03:33,610
‫File System che chiamano funzioni dal modulo HTTP

72
00:03:33,610 --> 00:03:35,770
‫perché sarebbe un gran casino.

73
00:03:35,770 --> 00:03:38,690
‫Invece, questi moduli sono piacevolmente disaccoppiati e

74
00:03:38,690 --> 00:03:41,470
‫autonomi, ciascuno emettendo eventi a cui

75
00:03:41,470 --> 00:03:44,380
‫altre funzioni, anche se provengono da altri

76
00:03:44,380 --> 00:03:46,120
‫moduli, possono rispondere.

77
00:03:46,120 --> 00:03:49,170
‫Inoltre, l'utilizzo di un'architettura basata sugli eventi

78
00:03:49,170 --> 00:03:52,390
‫rende molto più semplice reagire più volte allo

79
00:03:52,390 --> 00:03:53,760
‫stesso evento.

80
00:03:53,760 --> 00:03:58,210
‫Tutto quello che dobbiamo fare è impostare più ascoltatori, giusto?

81
00:03:58,210 --> 00:04:01,760
‫Ok, questa è l'architettura basata sugli eventi di Node

82
00:04:01,760 --> 00:04:03,020
‫in poche parole.

83
00:04:03,020 --> 00:04:06,050
‫E non preoccuparti se questo sembra un po'

84
00:04:06,050 --> 00:04:08,730
‫troppo teorico, vedrai questa logica utilizzata in

85
00:04:08,730 --> 00:04:12,183
‫molte situazioni durante il corso, a partire dal prossimo video.