1
00:00:03,980 --> 00:00:08,700
Abbiamo appena imparato a conoscere Callback Hell e

2
00:00:08,700 --> 00:00:13,455
come le promesse possono permetterci di superare questo problema.

3
00:00:13,455 --> 00:00:19,575
Sappiamo che il driver MongoDB nodo supporta nativamente le promesse.

4
00:00:19,575 --> 00:00:22,485
Quindi, se non si specifica una richiamata,

5
00:00:22,485 --> 00:00:26,385
le chiamate alle loro funzioni restituiranno promesse.

6
00:00:26,385 --> 00:00:31,445
Quindi, stiamo andando ad aggiornare la nostra applicazione per fare uso di promesse per

7
00:00:31,445 --> 00:00:38,005
evitare il problema inferno di callback che abbiamo appena imparato nella lezione precedente.

8
00:00:38,005 --> 00:00:40,644
Tornando alla nostra applicazione,

9
00:00:40,644 --> 00:00:48,035
ancora una volta dando un'occhiata al motivo per cui l'inferno di callback si è sviluppato nel nostro codice.

10
00:00:48,035 --> 00:00:52,520
Si noti che qui quando abbiamo implementato le operazioni,

11
00:00:52,520 --> 00:00:56,899
abbiamo un'operazione e poi all'interno del callback di tale operazione,

12
00:00:56,899 --> 00:01:00,770
quindi abbiamo bisogno di avviare l'operazione successiva e all'interno

13
00:01:00,770 --> 00:01:04,910
del callback di tale operazione stiamo iniziando l'operazione successiva e così via.

14
00:01:04,910 --> 00:01:10,040
Quindi stai finendo con questa struttura piramidale qui.

15
00:01:10,040 --> 00:01:14,290
Un' operazione all'interno del callback di un'altra e all'interno del callback.

16
00:01:14,290 --> 00:01:21,240
Ora, questo codice diventerà presto ingombrante e complicato da capire.

17
00:01:21,240 --> 00:01:24,760
Ecco perché vogliamo trasformare questo codice utilizzando

18
00:01:24,760 --> 00:01:29,380
il supporto promessa che Mongo DB Driver già fornisce

19
00:01:29,380 --> 00:01:33,205
per noi in modo che possiamo invece utilizzare le promesse

20
00:01:33,205 --> 00:01:37,735
piuttosto che utilizzare le funzioni di callback come abbiamo fatto in questo esercizio.

21
00:01:37,735 --> 00:01:42,760
Naturalmente, ho fatto la versione precedente solo per illustrarvi come possiamo

22
00:01:42,760 --> 00:01:48,595
atterrare con callback hell e come possiamo usare le promesse per superare questo problema.

23
00:01:48,595 --> 00:01:53,560
Quindi, prima di aggiornare il file index.js,

24
00:01:53,560 --> 00:01:59,989
lasciami andare nel file operations.jsfile e quindi aggiorneremo prima questo.

25
00:01:59,989 --> 00:02:06,950
Quindi qui, noterai che quando chiamiamo questa funzione qui,

26
00:02:06,950 --> 00:02:14,630
stiamo passando il secondo parametro che è una funzione di callback qui.

27
00:02:14,630 --> 00:02:18,210
Quindi, perché useremo le promesse qui.

28
00:02:18,210 --> 00:02:21,545
Quindi ho intenzione di eliminare quella funzione di callback e quindi

29
00:02:21,545 --> 00:02:25,744
dal momento che questa chiamata all'inserto restituirà comunque le promesse,

30
00:02:25,744 --> 00:02:29,710
restituirò solo la promessa da questa funzione.

31
00:02:29,710 --> 00:02:33,605
Quindi nota come il codice è stato semplificato.

32
00:02:33,605 --> 00:02:36,090
Allo stesso modo per il secondo,

33
00:02:36,090 --> 00:02:42,740
rimuoverò semplicemente questa funzione di callback e

34
00:02:42,740 --> 00:02:47,900
quindi restituirò la promessa che

35
00:02:47,900 --> 00:02:55,580
viene restituita da questo e quindi gestirla nel codice in index.js.

36
00:02:55,580 --> 00:02:58,495
Allo stesso modo per quello di eliminare anche,

37
00:02:58,495 --> 00:03:08,280
rimuoverò il callback e poi restituirò quel crash e anche per uptade.

38
00:03:10,600 --> 00:03:16,730
Per l'aggiornamento, rimuoveremo il callback che abbiamo dato

39
00:03:16,730 --> 00:03:22,564
qui e quindi restituiremo la promessa.

40
00:03:22,564 --> 00:03:25,100
Quindi in questo modo tutte queste quattro funzioni

41
00:03:25,100 --> 00:03:27,575
restituiranno la promessa che è già restituita

42
00:03:27,575 --> 00:03:33,110
da queste chiamate alle funzioni del driver MongoDB.

43
00:03:33,110 --> 00:03:34,760
Ora una volta che abbiamo completato questo,

44
00:03:34,760 --> 00:03:38,210
torniamo a index.js.

45
00:03:38,210 --> 00:03:44,090
In index.js, ho intenzione di aggiornare di nuovo questa funzione qui.

46
00:03:44,090 --> 00:03:53,105
Quindi l'uso delle promesse dirà MongoClient.connect (url) e quindi

47
00:03:53,105 --> 00:04:03,470
lo sostituiremo dicendo «then» e questo riceve solo il db come parametro.

48
00:04:03,470 --> 00:04:10,390
E qui dentro, gestiremo il resto e anche possiamo

49
00:04:10,390 --> 00:04:18,350
fare notare che questa particolare funzione chiude il «Poi» qui e la promessa,

50
00:04:18,350 --> 00:04:20,505
la seconda parte della promessa,

51
00:04:20,505 --> 00:04:22,845
possiamo gestire l'errore.

52
00:04:22,845 --> 00:04:28,055
Possiamo dire consolelog.

53
00:04:28,055 --> 00:04:33,755
Quindi possiamo usare la cattura della promessa anche per catturare gli errori.

54
00:04:33,755 --> 00:04:36,275
In questo modo, abbiamo colto gli errori.

55
00:04:36,275 --> 00:04:39,815
Ora, miglioriamo il codice qui dentro.

56
00:04:39,815 --> 00:04:45,530
Quindi dentro qui stiamo facendo il documento di inserimento dell'operazione DB,

57
00:04:45,530 --> 00:04:49,685
e invece di chiamare questa funzione qui,

58
00:04:49,685 --> 00:04:59,115
quello che ho intenzione di fare è trasformarlo in «allora» qui.

59
00:04:59,115 --> 00:05:06,870
Quindi ho intenzione di chiudere questo e dire.then risultato.

60
00:05:06,870 --> 00:05:08,800
Quindi all'interno di questi risultati,

61
00:05:08,800 --> 00:05:11,600
stiamo andando a stampare il registro della console e poi.

62
00:05:11,600 --> 00:05:20,630
Quindi ho intenzione di chiudere questo fuori qui e poi

63
00:05:20,630 --> 00:05:25,505
chiuderemo il «allora» qui e poi

64
00:05:25,505 --> 00:05:31,950
questo sarà collegato a un «allora» qui.

65
00:05:32,600 --> 00:05:36,640
Quindi vedi che sto incatenando due «allora»

66
00:05:36,640 --> 00:05:40,070
uno nell'altro qui e poi dentro di noi poi,

67
00:05:40,070 --> 00:05:47,570
faremo un registro della console e poi faremo un ritorno della prossima operazione.

68
00:05:47,570 --> 00:05:51,390
Ma poi, per questa operazione,

69
00:05:52,540 --> 00:06:02,070
ho intenzione di chiudere questo e chiudere questo

70
00:06:02,070 --> 00:06:06,920
poi e poi questa chiamata di nuovo ora

71
00:06:06,920 --> 00:06:13,320
verrà gestita all'interno di una funzione «allora» qui.

72
00:06:13,460 --> 00:06:20,510
Quindi nota come hai la prima funzione e nel «then» stiamo chiamando

73
00:06:20,510 --> 00:06:27,870
i documenti dboper find e che torneranno e questo restituirà una promessa.

74
00:06:27,870 --> 00:06:30,410
Quella promessa sarà gestita da questo allora.

75
00:06:30,410 --> 00:06:35,720
Quindi stiamo concatenando due allora insieme e poi di nuovo concatenando un altro «allora» qui.

76
00:06:35,720 --> 00:06:47,005
Permettetemi di reinventare il codice qui e poi restituiremo

77
00:06:47,005 --> 00:06:57,610
questo qui e questo di nuovo chiuderà e chiuderà quel «

78
00:06:57,610 --> 00:07:07,850
allora» e poi questo viene racchiuso all'interno del prossimo «allora» e

79
00:07:07,850 --> 00:07:13,280
chiameremo la prossima funzione qui «quel

80
00:07:13,280 --> 00:07:21,130
db.DropCollection ('Piatti' e chiuderà «questo allora» e il prossimo qui.

81
00:07:26,660 --> 00:07:31,390
Ci occuperemo del «allora» del risultato qui.

82
00:07:39,650 --> 00:07:48,690
Restituisci dbclose e tutti

83
00:07:48,690 --> 00:07:56,785
questi qui possono essere ora rimossi perché non sono più necessari.

84
00:07:56,785 --> 00:08:04,520
E poi finalmente se c'è un errore catturerà l'errore questa funzione.

85
00:08:04,520 --> 00:08:12,930
Quindi ho intenzione di copiare questo e poi incollarlo qui. Questo è tutto.

86
00:08:12,930 --> 00:08:14,755
Con questa modifica ora,

87
00:08:14,755 --> 00:08:20,220
il tuo codice è molto più facile da gestire qui.

88
00:08:20,220 --> 00:08:21,510
Quindi, come puoi vedere,

89
00:08:21,510 --> 00:08:24,560
hai il mongoClient.connect che

90
00:08:24,560 --> 00:08:28,040
restituisce una promessa e all'interno della gestione di quella promessa,

91
00:08:28,040 --> 00:08:31,700
stanno chiamando questi metodi e uno dopo l'

92
00:08:31,700 --> 00:08:35,490
altro stanno restituendo la promessa e poi li stai concatenando usando il.

93
00:08:35,490 --> 00:08:41,635
Questa struttura degli accordi è molto più facile da seguire rispetto a quanto avevamo implementato in precedenza.

94
00:08:41,635 --> 00:08:46,280
Quindi usando le promesse abbiamo letteralmente girato e quindi evitato

95
00:08:46,280 --> 00:08:51,250
l'inferno di callback che abbiamo visto nella versione precedente di questa applicazione.

96
00:08:51,250 --> 00:08:53,590
Quindi salviamo le modifiche sia a

97
00:08:53,590 --> 00:08:58,715
index.jsn.operation.js e quindi diamo un'occhiata a questa applicazione.

98
00:08:58,715 --> 00:09:00,840
Ancora una volta andando al terminale,

99
00:09:00,840 --> 00:09:03,105
al prompt digitare «npm

100
00:09:03,105 --> 00:09:09,515
start» e vedrai che la tua applicazione viene eseguita esattamente come prima,

101
00:09:09,515 --> 00:09:12,200
inserisce il documento, trova il documento,

102
00:09:12,200 --> 00:09:15,080
aggiorna il documento e quindi trova

103
00:09:15,080 --> 00:09:18,530
il documento aggiornato e quindi chiude il database dell'atto.

104
00:09:18,530 --> 00:09:23,630
Quindi usando le promesse abbiamo ristrutturato il codice per essere molto più facile ed

105
00:09:23,630 --> 00:09:29,945
evitato l'inferno di callback che abbiamo visto nella versione precedente di questa applicazione.

106
00:09:29,945 --> 00:09:33,705
Con questo, completiamo questo esercizio.

107
00:09:33,705 --> 00:09:36,470
In questo esercizio, avete visto come possiamo fare uso

108
00:09:36,470 --> 00:09:39,590
di promesse per evitare l'inferno di callback.

109
00:09:39,590 --> 00:09:42,920
Questo è un buon momento per fare un commit git con

110
00:09:42,920 --> 00:09:47,950
il messaggio callback hell and promise.