1
00:00:00,000 --> 00:00:04,722
[MUSIC]

2
00:00:04,722 --> 00:00:10,212
Quando stavamo parlando di servizi nel modulo precedente, avevo menzionato delle

3
00:00:10,212 --> 00:00:16,070
promesse e poi ho promesso che tornerò alle promesse in questo modulo.

4
00:00:17,360 --> 00:00:20,360
Quindi, eccoci qui, sto per adempiere la mia promessa che ti ho fatto.

5
00:00:22,090 --> 00:00:28,310
Un calcolo sincrono è dappertutto nel world wide web.

6
00:00:28,310 --> 00:00:31,410
E come funziona il web.

7
00:00:32,880 --> 00:00:35,810
Se vieni dal mondo della programmazione sequenziale,

8
00:00:37,040 --> 00:00:41,640
avvolgere la testa attorno a un calcolo sincrono richiede un bel po 'di sforzo.

9
00:00:42,680 --> 00:00:48,570
Ci sono stati molti tentativi di rendere il calcolo asincrono il più indolore

10
00:00:48,570 --> 00:00:54,680
possibile per le persone che transitano in esso dal libro di calcolo sequenziale.

11
00:00:56,850 --> 00:01:01,470
Uno di questi tentativi è quello di rendere il calcolo asincrono

12
00:01:01,470 --> 00:01:04,790
più facile da realizzare sono le promesse.

13
00:01:06,040 --> 00:01:10,304
Come ci rendiamo conto, quando facciamo qualsiasi richiesta a qualsiasi

14
00:01:10,304 --> 00:01:15,220
servizio o a un server di back-end, ci

15
00:01:16,530 --> 00:01:21,180
vorrà del tempo perché i risultati diventino disponibili per noi.

16
00:01:22,550 --> 00:01:30,840
Se facciamo una tale richiesta mentre stiamo procedendo con il nostro lavoro,

17
00:01:30,840 --> 00:01:35,680
allora c'è un'alta probabilità che il nostro calcolo rimanga bloccato nel punto, in

18
00:01:35,680 --> 00:01:37,890
attesa dei risultati.

19
00:01:37,890 --> 00:01:44,070
Questo è un no-no in termini di fare una buona esperienza utente.

20
00:01:46,090 --> 00:01:52,420
Quindi è importante che ogni volta che i risultati stanno per prendere tempo

21
00:01:52,420 --> 00:01:57,660
si dovrebbe essere in grado di procedere avanti senza attendere le regole.

22
00:01:57,660 --> 00:02:01,492
Ed è qui che il calcolo asincrono viene a tuo vantaggio.

23
00:02:01,492 --> 00:02:04,640
Nel calcolo asincrono quando invii una richiesta,

24
00:02:04,640 --> 00:02:07,800
ti aspetti che i risultati tornino in un secondo momento e

25
00:02:07,800 --> 00:02:12,720
dovresti essere in grado di gestire il fatto, i risultati di base tornano in un momento

26
00:02:14,490 --> 00:02:20,410
molto più tardi rispetto a dove ti trovavi nel punto in cui hai fatto la richiesta.

27
00:02:21,830 --> 00:02:25,710
Le promesse ci forniscono un modo per affrontare questo problema.

28
00:02:26,790 --> 00:02:32,540
Diamo un'occhiata alle promesse in un po 'più in dettaglio in questa lezione.

29
00:02:32,540 --> 00:02:35,910
E poi vedremo anche l'uso delle promesse

30
00:02:35,910 --> 00:02:39,490
nella nostra applicazione angolare un po 'più tardi.

31
00:02:39,490 --> 00:02:44,750
Promesse, il concetto generale è un'area molto vasta di per sé.

32
00:02:44,750 --> 00:02:49,030
E in questo corso, non ho tempo di passare attraverso i dettagli delle promesse.

33
00:02:49,030 --> 00:02:51,780
Questo diventerà un intero corso di per sé.

34
00:02:51,780 --> 00:02:56,950
Vi darò solo l'essenziale delle promesse che sono necessarie per

35
00:02:56,950 --> 00:03:02,490
capire come fare uso delle promesse all'interno della nostra applicazione angolare.

36
00:03:02,490 --> 00:03:07,230
Ti fornisco un sacco di cavi per

37
00:03:07,230 --> 00:03:11,380
risorse aggiuntive dove puoi andare ed esaminare le promesse in modo più dettagliato.

38
00:03:13,110 --> 00:03:17,230
Quindi, venendo a questa domanda, cos'e' esattamente una promessa?

39
00:03:17,230 --> 00:03:21,690
Una promessa è un meccanismo che supporta il calcolo asincrono.

40
00:03:21,690 --> 00:03:26,580
Ho appena dato una lunga spiegazione del perché il calcolo asincrono

41
00:03:26,580 --> 00:03:31,340
è essenziale per il funzionamento del web.

42
00:03:31,340 --> 00:03:36,720
Ora, usando una promessa, la promessa fornisce un meccanismo o

43
00:03:36,720 --> 00:03:42,760
un proxy per un valore che non è disponibile nel momento in cui lo chiedi.

44
00:03:42,760 --> 00:03:46,050
Quindi una promessa ti restituirà una promessa, dicendo che

45
00:03:46,050 --> 00:03:51,430
quando il risultato sarà disponibile, tornerà e ti consegnerà i risultati.

46
00:03:51,430 --> 00:03:56,850
Quindi una promessa ti restituisce un oggetto proxy e ti aggrappi all'oggetto proxy.

47
00:03:56,850 --> 00:04:02,030
E quell'oggetto proxy ti darà accesso ai risultati quando diventano disponibili.

48
00:04:02,030 --> 00:04:07,290
E c'è un metodo in come aspetti i risultati.

49
00:04:07,290 --> 00:04:11,560
In realtà non sospendi il tuo calcolo a quel punto invece

50
00:04:13,110 --> 00:04:19,948
configuri un modo per accettare i risultati quando ritorna da quella promessa.

51
00:04:19,948 --> 00:04:23,780
Per dirla in poche parole,

52
00:04:23,780 --> 00:04:27,960
promessa rappresenta un valore che sarà disponibile in un momento futuro.

53
00:04:27,960 --> 00:04:29,680
Potrebbe anche essere immediatamente disponibile,

54
00:04:29,680 --> 00:04:32,960
nel qual caso la promessa restituirà immediatamente il valore.

55
00:04:32,960 --> 00:04:37,940
Ma nel caso in cui debba restituire un valore in una data futura, ti dà

56
00:04:37,940 --> 00:04:42,040
la promessa che quel valore quando diventa disponibile ti verrà restituito.

57
00:04:43,400 --> 00:04:47,820
C' è sempre la possibilità che la promessa non possa essere soddisfatta,

58
00:04:47,820 --> 00:04:50,730
perché i risultati non sono disponibili per qualsiasi motivo.

59
00:04:51,950 --> 00:04:57,150
In tal caso, ti verrà consegnato un errore o ti verrà consegnato un rifiuto

60
00:04:57,150 --> 00:05:02,430
, e spetta a te affrontare il fatto che la promessa è stata respinta.

61
00:05:03,930 --> 00:05:06,890
Esaminiamo come affrontiamo questo nella prossima diapositiva.

62
00:05:07,950 --> 00:05:11,180
Come abbiamo appreso in precedenza, una promessa è un proxy per

63
00:05:11,180 --> 00:05:15,080
qualcosa che sarebbe accaduto in futuro o che potrebbe non accadere mai in futuro.

64
00:05:15,080 --> 00:05:19,745
Quindi una promessa quando ti verrà data, sarà nello stato in sospeso.

65
00:05:20,860 --> 00:05:25,130
Ora, quando la promessa si risolve, cioè i risultati diventano disponibili e

66
00:05:25,130 --> 00:05:30,080
la promessa è in grado di consegnare i risultati a voi, allora la promessa si

67
00:05:30,080 --> 00:05:31,490
risolverà o soddisferà.

68
00:05:31,490 --> 00:05:37,130
E in tal caso la promessa passerà dallo stato in sospeso alla risoluzione o

69
00:05:37,130 --> 00:05:38,490
allo stato di adempimento.

70
00:05:38,490 --> 00:05:41,220
Quindi a quel punto i tuoi risultati sono a tua disposizione.

71
00:05:42,540 --> 00:05:48,760
C' è una piccola possibilità che la promessa possa essere rifiutata a causa di un errore,

72
00:05:48,760 --> 00:05:50,590
o qualunque sia la ragione.

73
00:05:50,590 --> 00:05:53,280
In tale circostanza remota,

74
00:05:53,280 --> 00:05:57,980
ti verrà consegnato un rifiuto e in tal caso, la promessa sarà

75
00:05:57,980 --> 00:06:02,209
considerata nello stato rifiutato al momento della consegna del rifiuto.

76
00:06:03,380 --> 00:06:06,710
Quindi, quando generi una promessa, come ho detto,

77
00:06:06,710 --> 00:06:10,560
una promessa è un oggetto proxy che ti viene consegnato.

78
00:06:10,560 --> 00:06:14,580
Quindi, quando si consegna una promessa a qualcuno, la promessa internamente avrà

79
00:06:14,580 --> 00:06:17,500
una funzione che si occuperà sia della risoluzione che

80
00:06:17,500 --> 00:06:20,310
delle opzioni di rifiuto all'interno.

81
00:06:21,480 --> 00:06:22,540
Quando scrivi codice,

82
00:06:22,540 --> 00:06:28,190
vedrai che scriverai il codice come nuova promessa (funzione (risolvi, rifiuta).

83
00:06:28,190 --> 00:06:33,350
Quindi, che si risolva o venga rifiutato, dobbiamo essere in grado di

84
00:06:33,350 --> 00:06:38,290
restituire le informazioni a chiunque abbiamo promesso.

85
00:06:39,570 --> 00:06:41,600
Come facciamo a farlo nel codice?

86
00:06:41,600 --> 00:06:44,040
Diamo un'occhiata a questo nella diapositiva successiva.

87
00:06:45,280 --> 00:06:50,430
Ecco un esempio di come la promessa è configurata nel codice.

88
00:06:50,430 --> 00:06:53,870
In effetti, questo esempio è derivato dall'esercizio che farai

89
00:06:53,870 --> 00:06:55,850
un po 'più tardi.

90
00:06:55,850 --> 00:07:01,100
Quindi qui, quando configuriamo il nostro servizio, possiamo fare in modo che il nostro servizio

91
00:07:01,100 --> 00:07:06,830
restituisca una promessa a un componente che richiede i dati dal servizio.

92
00:07:06,830 --> 00:07:08,368
Quindi, quando viene restituita la promessa,

93
00:07:08,368 --> 00:07:13,810
la promessa di ritorno è disponibile come oggetto.

94
00:07:13,810 --> 00:07:18,190
E questa promessa fornisce due metodi, il metodo then e il metodo catch.

95
00:07:19,420 --> 00:07:23,416
Ora, allora, la promessa è risolta con successo.

96
00:07:23,416 --> 00:07:28,300
Quindi la promessa comporterà la

97
00:07:28,300 --> 00:07:32,810
chiamata di una risoluzione.

98
00:07:32,810 --> 00:07:36,960
Come hai visto, la promessa è costruita, e all'interno della promessa,

99
00:07:36,960 --> 00:07:42,170
hai la funzione, la risoluzione e il rifiuto, come i due parametri.

100
00:07:42,170 --> 00:07:46,820
Quindi, se la promessa è in grado di fornire con successo il risultato,

101
00:07:46,820 --> 00:07:51,680
chiamerà il metodo di risoluzione e quindi restituirà il risultato a te.

102
00:07:51,680 --> 00:07:53,520
Dove ottiene il risultato realtà?

103
00:07:54,820 --> 00:07:58,820
Quando si scrive il codice in attesa

104
00:07:58,820 --> 00:08:04,400
della promessa, è necessario specificare cosa fare quando la promessa restituisce il risultato

105
00:08:04,400 --> 00:08:09,370
nell'opzione then per quella promessa.

106
00:08:09,370 --> 00:08:14,590
Quindi diciamo per esempio, si direbbe getdishes.Then e all'interno di allora

107
00:08:14,590 --> 00:08:18,810
si dovrebbe fornire la funzione che si occuperà del risultato quando si arriva in.

108
00:08:20,370 --> 00:08:25,700
Se la promessa non è in grado di risolvere correttamente, si rifiuterà

109
00:08:25,700 --> 00:08:28,570
con l'errore che ti viene inviato di nuovo.

110
00:08:28,570 --> 00:08:31,600
L' errore è un oggetto errore che ti verrà inviato di nuovo.

111
00:08:31,600 --> 00:08:36,560
Quindi, quando la loro promessa viene rifiutata, ti occupi

112
00:08:36,560 --> 00:08:41,020
del rifiuto usando un fermo all'interno del tuo codice.

113
00:08:41,020 --> 00:08:47,460
Quindi all'interno della cattura, fornirai una funzione che gestirà l'errore.

114
00:08:47,460 --> 00:08:51,470
Ad esempio, puoi semplicemente emettere il messaggio di errore,

115
00:08:51,470 --> 00:08:56,770
il registro della console e gestire l'errore in questo modo.

116
00:08:56,770 --> 00:09:01,080
Oppure potresti avere un modo più elaborato di gestire l'errore.

117
00:09:01,080 --> 00:09:06,670
Ciò sarebbe fornito nell'opzione catch che fornisci per quel codice di promessa

118
00:09:06,670 --> 00:09:12,130
dalla tua parte quando la promessa ti offre un rifiuto.

119
00:09:12,130 --> 00:09:17,690
Quindi è così che le due facce della medaglia affrontano le promesse.

120
00:09:17,690 --> 00:09:21,160
Da un lato, ti viene inviato un oggetto promessa, e

121
00:09:21,160 --> 00:09:24,730
quando ricevi l'oggetto promessa, con l'oggetto promessa, dovresti fare

122
00:09:24,730 --> 00:09:28,300
il then e il catch, quindi dovresti implementare sia le

123
00:09:28,300 --> 00:09:33,510
metriche then che quelle catch modificate in quell'oggetto promessa.

124
00:09:34,780 --> 00:09:39,910
E poi, da quella promessa a parte, se la promessa risulta correttamente,

125
00:09:39,910 --> 00:09:44,757
allora la risoluzione sarà chiamata e quindi, il risultato sarà consegnato

126
00:09:44,757 --> 00:09:48,770
nel metodo allora della tua promessa.

127
00:09:48,770 --> 00:09:51,175
Se la promessa viene rifiutata,

128
00:09:51,175 --> 00:09:55,530
la chiamata di rifiuto invierà l'errore nella cattura.

129
00:09:56,760 --> 00:10:01,725
Quindi questo è il modo in cui implementeresti il codice usando le promesse.

130
00:10:01,725 --> 00:10:07,375
Ci occuperemo dell'esempio nell'esercizio che segue questa lezione.

131
00:10:07,375 --> 00:10:09,786
Ora, ovviamente, la domanda che chiedo è perché promesse?

132
00:10:11,347 --> 00:10:13,927
Più tardi, quando ci occupiamo di Node JS,

133
00:10:13,927 --> 00:10:18,237
ci occuperemo di come possiamo costruire callback.

134
00:10:18,237 --> 00:10:21,677
E spiegherò i dettagli dei callback e il modo di gestire i

135
00:10:21,677 --> 00:10:29,920
callback quando copriamo il Node JS nell'ultimo corso di questa specializzazione.

136
00:10:29,920 --> 00:10:37,400
I callback hanno un problema di creare ciò che viene definito inferno di callback.

137
00:10:37,400 --> 00:10:40,000
Quindi hai un codice di callback pesantemente annidato

138
00:10:40,000 --> 00:10:44,650
che è molto complicato per essere in grado di capire cosa sta cercando di fare.

139
00:10:44,650 --> 00:10:50,970
Le promesse forniscono un modo per affrontare questo problema dell'inferno di callback.

140
00:10:50,970 --> 00:10:55,270
Ma per il momento ci stiamo concentrando su Angular, parlerò solo di questo punto.

141
00:10:55,270 --> 00:10:59,050
E poi torneremo per affrontare questa domanda nell'ultimo corso.

142
00:11:00,760 --> 00:11:05,600
L' altro vantaggio dell'uso delle promesse è che le promesse possono essere modificate.

143
00:11:05,600 --> 00:11:08,780
Una promessa quando fornisce il risultato nel bin,

144
00:11:08,780 --> 00:11:11,130
puoi generare un'altra promessa e restituire, e

145
00:11:11,130 --> 00:11:16,280
quella promessa può essere gestita concatenando un altro metodo a quello e così via.

146
00:11:16,280 --> 00:11:21,720
Quindi puoi concatenare un insieme di metodi allora per gestire le

147
00:11:21,720 --> 00:11:23,470
promesse uno dietro l'altro.

148
00:11:25,610 --> 00:11:31,850
Se il risultato è immediatamente disponibile o se hai intenzione di rifiutare immediatamente,

149
00:11:31,850 --> 00:11:37,190
prometti fornisce un metodo per tornare immediatamente senza attendere che

150
00:11:37,190 --> 00:11:39,900
la promessa si risolva o rifiuta.

151
00:11:39,900 --> 00:11:45,766
In tal caso, sarà semplicemente dire promessa con un p.resolve capitale e

152
00:11:45,766 --> 00:11:52,243
promise.Reject e quindi restituire immediatamente il risultato o l'errore.

153
00:11:52,243 --> 00:11:57,079
Nel primo esercizio, ci occuperemo di questo metodo per restituire il valore

154
00:11:57,079 --> 00:11:59,480
dal nostro servizio ai nostri componenti.

155
00:12:00,920 --> 00:12:04,010
Nella seconda parte dell'esercizio, ci occuperemo

156
00:12:04,010 --> 00:12:09,820
della situazione in cui la promessa si risolverà dopo un periodo di tempo.

157
00:12:09,820 --> 00:12:13,400
E anche all'interno del nostro componente, dovremmo essere in grado di affrontare il fatto che

158
00:12:13,400 --> 00:12:20,280
i risultati tornano un po 'più tardi rispetto a quando chiedi il risultato.

159
00:12:22,485 --> 00:12:25,679
Con questa rapida comprensione delle promesse,

160
00:12:25,679 --> 00:12:30,393
passiamo al prossimo esercizio in cui tratteremo le promesse.

161
00:12:30,393 --> 00:12:33,769
[ MUSIC]