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

2
00:00:04,722 --> 00:00:10,212
Lorsque nous parlions de services dans le module précédent, j'avais mentionné

3
00:00:10,212 --> 00:00:16,070
sur les promesses et ensuite j'ai promis que je reviendrais aux promesses dans ce module.

4
00:00:17,360 --> 00:00:20,360
Alors, nous voilà, je vais remplir ma promesse à vous.

5
00:00:22,090 --> 00:00:28,310
Un calcul synchrone est partout dans le monde.

6
00:00:28,310 --> 00:00:31,410
Et comment le web fonctionne.

7
00:00:32,880 --> 00:00:35,810
Si vous venez du monde de la programmation séquentielle,

8
00:00:37,040 --> 00:00:41,640
enrouler votre tête autour d'un calcul synchrone demande un peu d'effort.

9
00:00:42,680 --> 00:00:48,570
Il y a eu de nombreuses tentatives pour rendre le calcul asynchrone aussi indolore que

10
00:00:48,570 --> 00:00:54,680
possible pour les personnes qui y passent à partir du livre de calcul séquentiel.

11
00:00:56,850 --> 00:01:01,470
Une telle tentative est de rendre le calcul asynchrone

12
00:01:01,470 --> 00:01:04,790
plus facile à accomplir est des promesses.

13
00:01:06,040 --> 00:01:10,304
Comme nous le savons, quand nous faisons une demande à n'importe quel service

14
00:01:10,304 --> 00:01:15,220
ou à un serveur backend,

15
00:01:16,530 --> 00:01:21,180
cela va prendre un certain temps pour que les résultats deviennent disponibles pour nous.

16
00:01:22,550 --> 00:01:30,840
Si nous faisons une telle demande pendant que nous procédons à notre travail,

17
00:01:30,840 --> 00:01:35,680
alors il y a une forte probabilité que notre calcul soit bloqué au point,

18
00:01:35,680 --> 00:01:37,890
en attendant les résultats.

19
00:01:37,890 --> 00:01:44,070
C'est un non-non en termes de bonne expérience utilisateur.

20
00:01:46,090 --> 00:01:52,420
Il est donc important que chaque fois que vos résultats prendront du temps

21
00:01:52,420 --> 00:01:57,660
, vous puissiez aller de l'avant sans attendre les règles.

22
00:01:57,660 --> 00:02:01,492
Et c'est là que le calcul asynchrone est à votre avantage.

23
00:02:01,492 --> 00:02:04,640
Dans le calcul asynchrone lorsque vous envoyez une demande

24
00:02:04,640 --> 00:02:07,800
, vous attendez que les résultats reviendront plus tard, et

25
00:02:07,800 --> 00:02:12,720
vous devriez être en mesure de gérer le fait, les résultats de base reviennent à un moment

26
00:02:14,490 --> 00:02:20,410
beaucoup plus tard que l'endroit où vous étiez au moment où vous avez fait la demande.

27
00:02:21,830 --> 00:02:25,710
Les promesses nous fournissent un moyen de traiter cela.

28
00:02:26,790 --> 00:02:32,540
Regardons les promesses un peu plus en détail dans cette conférence.

29
00:02:32,540 --> 00:02:35,910
Et puis nous verrons aussi l'utilisation des promesses

30
00:02:35,910 --> 00:02:39,490
dans notre application Angular un peu plus tard.

31
00:02:39,490 --> 00:02:44,750
Promises, le concept général est un domaine très vaste à lui seul.

32
00:02:44,750 --> 00:02:49,030
Et dans ce cours, je n'ai pas le temps de passer en revue les détails des promesses.

33
00:02:49,030 --> 00:02:51,780
Ça va devenir un cours entier en soi.

34
00:02:51,780 --> 00:02:56,950
Je vais vous donner l'essentiel des promesses qui sont nécessaires pour que

35
00:02:56,950 --> 00:03:02,490
nous comprenne comment utiliser les promesses dans notre application angulaire.

36
00:03:02,490 --> 00:03:07,230
Je vous donne beaucoup de pistes vers des ressources

37
00:03:07,230 --> 00:03:11,380
supplémentaires où vous pouvez aller examiner les promesses plus en détail.

38
00:03:13,110 --> 00:03:17,230
Alors, en ce qui concerne cette question, qu'est-ce qu'une promesse ?

39
00:03:17,230 --> 00:03:21,690
Une promesse est un mécanisme qui prend en charge le calcul asynchrone.

40
00:03:21,690 --> 00:03:26,580
Je viens de donner une longue explication de pourquoi le calcul asynchrone

41
00:03:26,580 --> 00:03:31,340
est essentiel pour le fonctionnement du web.

42
00:03:31,340 --> 00:03:36,720
Maintenant, en utilisant une promesse, la promesse fournit un mécanisme ou

43
00:03:36,720 --> 00:03:42,760
un proxy pour une valeur qui n'est pas disponible au moment où vous la demandez.

44
00:03:42,760 --> 00:03:46,050
Donc une promesse vous rendra une promesse, disant que

45
00:03:46,050 --> 00:03:51,430
lorsque le résultat sera disponible, il reviendra et vous donnera les résultats.

46
00:03:51,430 --> 00:03:56,850
Donc, une promesse vous renvoie un objet proxy, et vous vous tenez à l'objet proxy.

47
00:03:56,850 --> 00:04:02,030
Et cet objet proxy vous donnera accès aux résultats dès qu'ils seront disponibles.

48
00:04:02,030 --> 00:04:07,290
Et il y a une méthode dans la façon dont vous attendez les résultats.

49
00:04:07,290 --> 00:04:11,560
En fait, vous ne suspendez pas votre calcul à ce stade au lieu de cela, vous

50
00:04:13,110 --> 00:04:19,948
configurez un moyen d'accepter les résultats quand il revient de cette promesse.

51
00:04:19,948 --> 00:04:23,780
Pour le dire en un mot,

52
00:04:23,780 --> 00:04:27,960
promesse représente une valeur qui sera disponible à un moment futur.

53
00:04:27,960 --> 00:04:29,680
Il peut également être immédiatement disponible,

54
00:04:29,680 --> 00:04:32,960
dans ce cas la promesse retournera la valeur immédiatement.

55
00:04:32,960 --> 00:04:37,940
Mais au cas où il aurait besoin de retourner une valeur à une date ultérieure, alors cela vous donne

56
00:04:37,940 --> 00:04:42,040
la promesse que cette valeur quand elle sera disponible vous sera retournée.

57
00:04:43,400 --> 00:04:47,820
Il y a toujours la possibilité que la promesse ne puisse pas être respectée,

58
00:04:47,820 --> 00:04:50,730
parce que les résultats ne sont pas disponibles pour quelque raison que ce soit.

59
00:04:51,950 --> 00:04:57,150
Dans ce cas, une erreur vous sera remise, ou un rejet vous sera remis

60
00:04:57,150 --> 00:05:02,430
, et c'est à vous de traiter le fait que la promesse a été rejetée.

61
00:05:03,930 --> 00:05:06,890
Nous examinons la façon dont nous traitons cela dans la diapositive suivante.

62
00:05:07,950 --> 00:05:11,180
Comme nous l'avons appris plus tôt, une promesse est un proxy pour

63
00:05:11,180 --> 00:05:15,080
quelque chose qui allait se produire dans le futur ou qui pourrait ne jamais se produire dans le futur.

64
00:05:15,080 --> 00:05:19,745
Donc une promesse quand elle vous sera donnée, sera dans l'état en attente.

65
00:05:20,860 --> 00:05:25,130
Maintenant, lorsque la promesse est résolue, c'est-à-dire que les résultats deviennent disponibles et

66
00:05:25,130 --> 00:05:30,080
la promesse est en mesure de vous livrer les résultats, alors la promesse sera résolue ou

67
00:05:30,080 --> 00:05:31,490
sera honorée.

68
00:05:31,490 --> 00:05:37,130
Et dans ce cas, la promesse passera de l'état en attente à la résolution ou

69
00:05:37,130 --> 00:05:38,490
l'état de réalisation.

70
00:05:38,490 --> 00:05:41,220
Donc, à ce moment-là, vos résultats sont à votre disposition.

71
00:05:42,540 --> 00:05:48,760
Il y a une légère chance que la promesse soit rejetée à cause d'une erreur,

72
00:05:48,760 --> 00:05:50,590
ou quelle que soit la raison.

73
00:05:50,590 --> 00:05:53,280
Dans cette circonstance éloignée,

74
00:05:53,280 --> 00:05:57,980
vous recevrez un rejet et dans ce cas, la promesse sera

75
00:05:57,980 --> 00:06:02,209
considérée comme étant dans l'état rejeté lorsque le rejet sera livré.

76
00:06:03,380 --> 00:06:06,710
Donc, quand vous générez une promesse, comme je l'ai dit,

77
00:06:06,710 --> 00:06:10,560
une promesse est un objet proxy qui vous est livré.

78
00:06:10,560 --> 00:06:14,580
Donc, lorsque vous faites une promesse à quelqu'un, la promesse en interne aura

79
00:06:14,580 --> 00:06:17,500
une fonction qui traitera à la fois la résolution et

80
00:06:17,500 --> 00:06:20,310
les options de rejet à l'intérieur.

81
00:06:21,480 --> 00:06:22,540
Lorsque vous écrivez du code,

82
00:06:22,540 --> 00:06:28,190
vous verrez que vous allez écrire du code comme nouvelle promesse (fonction (résoudre, rejeter).

83
00:06:28,190 --> 00:06:33,350
Donc, qu'il soit résolu ou rejeté, nous devons être en mesure de renvoyer

84
00:06:33,350 --> 00:06:38,290
l'information à qui nous avons donné la promesse.

85
00:06:39,570 --> 00:06:41,600
Comment faisons-nous cela dans le code ?

86
00:06:41,600 --> 00:06:44,040
Jetons un coup d'oeil à cela dans la diapositive suivante.

87
00:06:45,280 --> 00:06:50,430
Voici un exemple de la façon dont la promesse est configurée dans le code.

88
00:06:50,430 --> 00:06:53,870
En effet, cet exemple est dérivé de l'exercice que vous ferez

89
00:06:53,870 --> 00:06:55,850
un peu plus tard.

90
00:06:55,850 --> 00:07:01,100
Donc ici, lorsque nous configurons notre service, nous pouvons faire en sorte que notre service

91
00:07:01,100 --> 00:07:06,830
renvoie une promesse à un composant qui demande des données du service.

92
00:07:06,830 --> 00:07:08,368
Donc, lorsque la promesse est retournée,

93
00:07:08,368 --> 00:07:13,810
alors la promesse de retour est disponible pour vous en tant qu'objet.

94
00:07:13,810 --> 00:07:18,190
Et cette promesse fournit deux méthodes, la méthode then et la méthode catch.

95
00:07:19,420 --> 00:07:23,416
Maintenant, la promesse est résolue avec succès.

96
00:07:23,416 --> 00:07:28,300
Alors la promesse entraînera

97
00:07:28,300 --> 00:07:32,810
à appeler une résolution.

98
00:07:32,810 --> 00:07:36,960
Comme vous l'avez vu, la promesse est construite, et à l'intérieur de la promesse,

99
00:07:36,960 --> 00:07:42,170
vous avez la fonction, la résolution et le rejet, comme les deux paramètres.

100
00:07:42,170 --> 00:07:46,820
Donc, si la promesse est capable de livrer le résultat avec succès,

101
00:07:46,820 --> 00:07:51,680
alors il appellera la méthode de résolution, puis vous retournera le résultat.

102
00:07:51,680 --> 00:07:53,520
Où le résultat est-il réalité ?

103
00:07:54,820 --> 00:07:58,820
Lorsque vous écrivez du code en attendant

104
00:07:58,820 --> 00:08:04,400
la promesse, alors vous spécifiez ce qu'il faut faire lorsque la promesse renvoie le résultat

105
00:08:04,400 --> 00:08:09,370
dans l'option then pour cette promesse.

106
00:08:09,370 --> 00:08:14,590
Donc, disons par exemple, vous diriez getDishes.Puis et à l'intérieur de puis

107
00:08:14,590 --> 00:08:18,810
, vous fournirez la fonction qui traitera le résultat quand il arrive.

108
00:08:20,370 --> 00:08:25,700
Si la promesse n'est pas en mesure de résoudre correctement, elle rejettera

109
00:08:25,700 --> 00:08:28,570
avec l'erreur qui vous sera renvoyée.

110
00:08:28,570 --> 00:08:31,600
L'erreur étant un objet d'erreur qui vous sera renvoyé.

111
00:08:31,600 --> 00:08:36,560
Donc, quand leur promesse est rejetée, alors vous traitez avec

112
00:08:36,560 --> 00:08:41,020
le rejet en utilisant un catch dans votre code.

113
00:08:41,020 --> 00:08:47,460
Donc, dans le catch, vous fournirez une fonction qui traitera l'erreur.

114
00:08:47,460 --> 00:08:51,470
Par exemple, vous pouvez simplement afficher le message d'erreur,

115
00:08:51,470 --> 00:08:56,770
le journal de la console et traiter l'erreur de cette façon.

116
00:08:56,770 --> 00:09:01,080
Ou vous pourriez avoir une façon plus élaborée de gérer l'erreur.

117
00:09:01,080 --> 00:09:06,670
Cela serait fourni dans l'option de capture que vous donnez pour ce code de promesse

118
00:09:06,670 --> 00:09:12,130
de votre côté lorsque la promesse vous livre un rejet.

119
00:09:12,130 --> 00:09:17,690
C'est ainsi que les deux faces de la médaille font face aux promesses.

120
00:09:17,690 --> 00:09:21,160
D'un côté, vous êtes envoyé un objet promesse, et

121
00:09:21,160 --> 00:09:24,730
lorsque vous recevez l'objet promesse, avec l'objet promesse, vous feriez

122
00:09:24,730 --> 00:09:28,300
le temps et le catch, donc vous êtes censé implémenter à la fois les mesures de capture puis et

123
00:09:28,300 --> 00:09:33,510
changées pour cet objet promesse.

124
00:09:34,780 --> 00:09:39,910
Et puis, à partir de cette promesse mis à part, si la promesse se produit correctement,

125
00:09:39,910 --> 00:09:44,757
alors la résolution sera appelée et ainsi, le résultat sera livré

126
00:09:44,757 --> 00:09:48,770
dans la méthode alors de votre promesse.

127
00:09:48,770 --> 00:09:51,175
Si la promesse est rejetée,

128
00:09:51,175 --> 00:09:55,530
l'appel de rejet livrera l'erreur dans votre capture.

129
00:09:56,760 --> 00:10:01,725
C'est donc ainsi que vous mettiez en œuvre le code en utilisant des promesses.

130
00:10:01,725 --> 00:10:07,375
Nous traiterons de l'exemple dans l'exercice qui suit cette conférence.

131
00:10:07,375 --> 00:10:09,786
Maintenant, évidemment, la question que je pose est pourquoi les promesses ?

132
00:10:11,347 --> 00:10:13,927
Plus tard, quand nous traitons avec Node JS,

133
00:10:13,927 --> 00:10:18,237
nous traiterons de la façon dont nous pouvons construire des rappels.

134
00:10:18,237 --> 00:10:21,677
Et je vais expliquer les détails des rappels et la façon de traiter les rappels

135
00:10:21,677 --> 00:10:29,920
lorsque nous couvrons le Node JS dans le dernier cours de cette spécialisation.

136
00:10:29,920 --> 00:10:37,400
Les rappels ont un problème de création de ce qu'il faut appeler l'enfer de rappel.

137
00:10:37,400 --> 00:10:40,000
Donc, vous avez un code de rappel très imbriqué

138
00:10:40,000 --> 00:10:44,650
qui est très compliqué pour être en mesure de comprendre ce qu'il essaie de faire.

139
00:10:44,650 --> 00:10:50,970
Les promesses fournissent un moyen de résoudre ce problème de rappel de l'enfer.

140
00:10:50,970 --> 00:10:55,270
Mais pour le moment nous nous concentrons sur Angular, je vais simplement mentionner ce point.

141
00:10:55,270 --> 00:10:59,050
Et puis nous reviendrons traiter cette question dans le dernier cours.

142
00:11:00,760 --> 00:11:05,600
L'autre avantage de l'utilisation des promesses est que les promesses peuvent être changées.

143
00:11:05,600 --> 00:11:08,780
Une promesse quand il livre le résultat dans le bac,

144
00:11:08,780 --> 00:11:11,130
vous pouvez générer une autre promesse et retour, et

145
00:11:11,130 --> 00:11:16,280
cette promesse peut être traitée en chaînant une autre méthode then à cela et ainsi de suite.

146
00:11:16,280 --> 00:11:21,720
Donc, vous pouvez enchaîner un ensemble de méthodes puis ensemble pour faire face aux promesses

147
00:11:21,720 --> 00:11:23,470
les unes derrière les autres.

148
00:11:25,610 --> 00:11:31,850
Si le résultat est immédiatement disponible ou si vous allez rejeter immédiatement,

149
00:11:31,850 --> 00:11:37,190
alors promise fournit une méthode de retour immédiat sans attendre

150
00:11:37,190 --> 00:11:39,900
la promesse de résoudre ou de rejeter.

151
00:11:39,900 --> 00:11:45,766
Dans ce cas, vous direz simplement promesse avec un capital p.solve et

152
00:11:45,766 --> 00:11:52,243
promise.Rejeter, puis retourner immédiatement le résultat ou l'erreur.

153
00:11:52,243 --> 00:11:57,079
Dans le premier exercice, nous traiterons de cette méthode de retour de la valeur

154
00:11:57,079 --> 00:11:59,480
de notre service à nos composants.

155
00:12:00,920 --> 00:12:04,010
Dans la deuxième partie de l'exercice, nous traiterons de

156
00:12:04,010 --> 00:12:09,820
la situation où la promesse sera résolue après une durée de temps.

157
00:12:09,820 --> 00:12:13,400
Et aussi dans notre composant, nous devrions être en mesure de traiter le fait que

158
00:12:13,400 --> 00:12:20,280
les résultats reviennent un peu plus tard que lorsque vous demandez le résultat.

159
00:12:22,485 --> 00:12:25,679
Avec cette compréhension rapide des promesses,

160
00:12:25,679 --> 00:12:30,393
passons à l'exercice suivant où nous traiterons les promesses.

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