﻿1
00:00:01,190 --> 00:00:02,840
‫Jonas : Écrivons maintenant

2
00:00:02,840 --> 00:00:05,520
‫du code afin de mieux comprendre ce qui

3
00:00:05,520 --> 00:00:07,893
‫se passe dans la boucle d'événements.

4
00:00:09,200 --> 00:00:11,370
‫Donc, comme avant, pour commencer

5
00:00:11,370 --> 00:00:13,670
‫la partie codage de cette section,

6
00:00:13,670 --> 00:00:15,970
‫allez-y et récupérez les fichiers de

7
00:00:15,970 --> 00:00:18,550
‫démarrage pour cette section, copiez-les quelque part,

8
00:00:18,550 --> 00:00:22,050
‫puis ouvrez le projet dans votre éditeur de code.

9
00:00:22,050 --> 00:00:24,310
‫Je l'ai donc ici sur le bureau et

10
00:00:24,310 --> 00:00:27,550
‫dans mon VSCode, et tout ce que nous avons ici pour

11
00:00:27,550 --> 00:00:31,420
‫commencer est ce fichier de test. txt, et donc je vais créer un nouveau fichier

12
00:00:31,420 --> 00:00:35,033
‫ici, et je vais l'appeler la boucle d'événement. js.

13
00:00:38,040 --> 00:00:41,530
‫Bon, maintenant il est en fait extrêmement difficile de simuler correctement la

14
00:00:41,530 --> 00:00:44,000
‫boucle d'événement, car nous ne pouvons pas vraiment

15
00:00:44,000 --> 00:00:46,400
‫mettre beaucoup de rappels dans toutes les files

16
00:00:46,400 --> 00:00:48,080
‫d'attente de rappel dont

17
00:00:48,080 --> 00:00:51,260
‫nous avons parlé tout à l'heure en même temps, n'est-ce pas.

18
00:00:51,260 --> 00:00:53,710
‫Cette situation se produit lorsque,

19
00:00:53,710 --> 00:00:56,360
‫par exemple, de nombreuses demandes arrivent dans

20
00:00:56,360 --> 00:01:00,240
‫votre application, mais ici localement, c'est très difficile à reproduire.

21
00:01:00,240 --> 00:01:03,150
‫Mais de toute façon, nous allons quand même faire des expériences

22
00:01:03,150 --> 00:01:05,390
‫très intéressantes en utilisant certaines des choses que

23
00:01:05,390 --> 00:01:07,540
‫nous avons apprises dans la dernière vidéo.

24
00:01:07,540 --> 00:01:09,830
‫Et ce que nous allons faire,

25
00:01:09,830 --> 00:01:12,190
‫c'est écrire un tas de lignes de code,

26
00:01:12,190 --> 00:01:15,130
‫puis essayer de déterminer dans quel ordre elles doivent être

27
00:01:15,130 --> 00:01:17,950
‫exécutées dans la boucle d'événements, et analyser si les

28
00:01:17,950 --> 00:01:20,360
‫résultats que nous obtenons ont vraiment du sens.

29
00:01:20,360 --> 00:01:22,710
‫Commençons donc par écrire un setTimeout, donc

30
00:01:24,290 --> 00:01:26,513
‫essentiellement pour définir une minuterie, et j'utilise

31
00:01:27,980 --> 00:01:29,890
‫une fonction de flèche ici, et

32
00:01:29,890 --> 00:01:31,270
‫la seule chose

33
00:01:31,270 --> 00:01:33,773
‫que je vais faire est de me connecter

34
00:01:34,930 --> 00:01:39,930
‫à la console pour une chaîne, donc console. log, la minuterie 1 est terminée

35
00:01:41,800 --> 00:01:45,390
‫et je veux que cela expire juste après zéro seconde.

36
00:01:45,390 --> 00:01:47,740
‫D'accord, enregistrez-le, puis vous voyez qu'il a

37
00:01:47,740 --> 00:01:50,030
‫en fait corrigé cette chaîne ici, il

38
00:01:50,030 --> 00:01:53,120
‫a donc modifié ces guillemets et ajouté le point-virgule, et

39
00:01:53,120 --> 00:01:54,810
‫c'est à cause de

40
00:01:54,810 --> 00:01:56,940
‫l'extension Prettier que nous avons installée auparavant.

41
00:01:56,940 --> 00:01:58,510
‫Maintenant, je ne vais pas le

42
00:01:58,510 --> 00:01:59,850
‫configurer ici, car pour

43
00:01:59,850 --> 00:02:02,050
‫ce petit exemple, ce n'est pas vraiment nécessaire, d'accord.

44
00:02:02,050 --> 00:02:05,150
‫Donc, c'est régler une minuterie, alors

45
00:02:05,150 --> 00:02:09,320
‫utilisons également setImmediate, alors rappelez-vous cela de la dernière vidéo.

46
00:02:09,320 --> 00:02:11,620
‫Bon, maintenant je ne vais pas expliquer grand-chose

47
00:02:11,620 --> 00:02:13,350
‫ici, pour l'instant écrivons ce

48
00:02:13,350 --> 00:02:15,510
‫code, puis analysons ce qui se passe, d'accord.

49
00:02:15,510 --> 00:02:20,320
‫Donc setImmediate, et tout comme l'autre minuteur, il reçoit

50
00:02:20,320 --> 00:02:22,500
‫une fonction de rappel.

51
00:02:22,500 --> 00:02:25,130
‫Et tout ce qu'on va faire c'est

52
00:02:27,720 --> 00:02:31,440
‫en écrire un immédiat terminé, et celui-ci n'a pas le

53
00:02:31,440 --> 00:02:33,520
‫temps, car ce n'est

54
00:02:33,520 --> 00:02:36,930
‫pas nécessaire car comme son nom l'indique, c'est immédiat.

55
00:02:36,930 --> 00:02:38,540
‫Ensuite, une autre chose que

56
00:02:38,540 --> 00:02:41,620
‫nous voulons faire est de lire ce fichier ici,

57
00:02:41,620 --> 00:02:44,930
‫puis de passer une fonction de rappel, d'accord, donc la

58
00:02:44,930 --> 00:02:48,963
‫première chose est que nous devons exiger le bon module, donc FS, et

59
00:02:52,600 --> 00:02:54,987
‫maintenant fs. readFile, et nous voulons un fichier texte. txt,

60
00:03:05,586 --> 00:03:08,003
‫puis quelque chose se passe.

61
00:03:09,270 --> 00:03:12,153
‫Et comme avant, disons simplement ici,

62
00:03:13,740 --> 00:03:17,263
‫dans ce cas, les E/S sont terminées, d'accord.

63
00:03:18,830 --> 00:03:21,170
‫Donc I/O parce que ce rappel

64
00:03:21,170 --> 00:03:24,830
‫ici est en fait lié à une tâche d'E/S, qui obtient

65
00:03:24,830 --> 00:03:28,440
‫en fait sa propre phase dans la boucle d'événement, n'est-ce pas.

66
00:03:28,440 --> 00:03:31,930
‫Et puis enfin, ajoutons simplement une console. connectez-vous ici, en

67
00:03:31,930 --> 00:03:35,473
‫disant bien, bonjour du code de niveau supérieur.

68
00:03:37,517 --> 00:03:40,440
‫D'accord, et donc du code de niveau supérieur, car c'est en

69
00:03:40,440 --> 00:03:43,130
‫fait le seul qui n'est à l'intérieur d'aucun rappel.

70
00:03:43,130 --> 00:03:46,000
‫Donc, dans ce très petit exemple que nous avons pour l'instant, essayons

71
00:03:46,000 --> 00:03:48,400
‫de comprendre ce qui devrait se passer en premier.

72
00:03:48,400 --> 00:03:50,510
‫Eh bien, rappelez-vous que la première étape

73
00:03:50,510 --> 00:03:53,310
‫lorsque nous chargeons un module est que son code de

74
00:03:53,310 --> 00:03:56,000
‫niveau supérieur soit exécuté, nous devrions donc tout de

75
00:03:56,000 --> 00:03:59,360
‫suite voir cette console. log ici, à droite,

76
00:03:59,360 --> 00:04:02,110
‫seulement plus tard, nous devrions voir les autres journaux

77
00:04:02,110 --> 00:04:04,280
‫provenant de ces autres rappels, car ces

78
00:04:04,280 --> 00:04:06,820
‫rappels s'exécuteront en fait dans la boucle d'événements.

79
00:04:06,820 --> 00:04:09,190
‫Essayons donc de voir si c'est

80
00:04:09,190 --> 00:04:12,000
‫réellement le cas, puis analysons-le encore un peu mieux.

81
00:04:12,000 --> 00:04:15,150
‫Donc, en ouvrant la console ici, et encore une

82
00:04:15,150 --> 00:04:17,250
‫fois, je le fais en

83
00:04:17,250 --> 00:04:22,023
‫utilisant le terminal, ou en fait dans la vue, donc ce terminal ici, d'accord.

84
00:04:23,100 --> 00:04:27,020
‫Alors notez, la boucle d'événement. js, ou avant de le

85
00:04:27,020 --> 00:04:30,960
‫faire, je dois corriger cette faute de frappe ici, il s'agit donc

86
00:04:30,960 --> 00:04:33,580
‫d'un fichier de test, pas d'un fichier texte.

87
00:04:33,580 --> 00:04:36,093
‫D'accord, mais maintenant nous sommes prêts à

88
00:04:36,960 --> 00:04:40,320
‫exécuter cette commande, et les résultats sont arrivés, donc le

89
00:04:40,320 --> 00:04:43,810
‫premier journal que nous avons ici est le bonjour du code

90
00:04:43,810 --> 00:04:46,100
‫de niveau supérieur, et c'était prévu,

91
00:04:46,100 --> 00:04:49,390
‫n'est-ce pas, car c'est un code qui est exécuté immédiatement.

92
00:04:49,390 --> 00:04:52,940
‫Ensuite, nous avons ces trois sorties, mais elles ne sont en

93
00:04:52,940 --> 00:04:55,460
‫fait pas dans un ordre particulier, et

94
00:04:55,460 --> 00:04:57,640
‫c'est parce que ce code ici,

95
00:04:57,640 --> 00:05:00,970
‫donc ce code, n'est en fait pas dans un cycle d'E/S,

96
00:05:00,970 --> 00:05:03,780
‫donc il ne s'exécute pas à l'intérieur de la

97
00:05:03,780 --> 00:05:07,170
‫boucle d'événement, car il ne s'exécute dans aucune fonction de rappel.

98
00:05:07,170 --> 00:05:10,370
‫D'accord, donc sur votre ordinateur, vous pourriez en fait voir

99
00:05:11,470 --> 00:05:13,160
‫ce journal ici avant

100
00:05:13,160 --> 00:05:15,360
‫celui-ci, et celui-ci n'est que le

101
00:05:15,360 --> 00:05:18,550
‫dernier parce que ce genre de gros fichier ici prend

102
00:05:18,550 --> 00:05:20,840
‫un certain temps à lire, et donc

103
00:05:20,840 --> 00:05:23,060
‫ce sera probablement toujours le dernier une.

104
00:05:23,060 --> 00:05:27,140
‫Encore une fois, à ce stade, l'ordre de ces trois éléments n'a

105
00:05:27,140 --> 00:05:29,640
‫rien à voir avec la boucle d'événement,

106
00:05:29,640 --> 00:05:31,320
‫car ils ne s'exécutent

107
00:05:31,320 --> 00:05:33,420
‫pas encore dans la boucle d'événement.

108
00:05:33,420 --> 00:05:36,490
‫Pour cela, il va falloir les déplacer, ou

109
00:05:36,490 --> 00:05:40,490
‫du moins déplacer ces deux ici, à l'intérieur d'une fonction de rappel.

110
00:05:40,490 --> 00:05:43,713
‫Et donc, pour cela, nous allons utiliser celui-ci ici en fait.

111
00:05:45,270 --> 00:05:50,190
‫Alors laissez-moi le mettre ici, et dites minuterie deux et minuterie deux ici,

112
00:05:50,190 --> 00:05:55,190
‫ou deux immédiatement, et je vais également ajouter une autre minuterie ici, donc

113
00:05:55,270 --> 00:05:57,740
‫la minuterie trois, et celle-ci

114
00:05:57,740 --> 00:06:01,140
‫va fonctionner pendant trois secondes, soit 3000 millisecondes .

115
00:06:01,140 --> 00:06:03,840
‫Essayons donc maintenant le résultat de celui-ci.

116
00:06:03,840 --> 00:06:06,230
‫Mais avant de faire cela, réfléchissons en

117
00:06:06,230 --> 00:06:09,660
‫fait à la raison pour laquelle, juste après l'exécution de tout

118
00:06:09,660 --> 00:06:13,730
‫le code précédent, le programme s'est ensuite arrêté et est revenu à l'invite ici.

119
00:06:13,730 --> 00:06:16,500
‫Alors rappelez-vous comment Node. js décide s'il doit

120
00:06:16,500 --> 00:06:19,000
‫continuer à exécuter la boucle d'événement, eh bien, il le

121
00:06:19,000 --> 00:06:21,620
‫fait en demandant s'il reste encore du temps en arrière-plan,

122
00:06:21,620 --> 00:06:24,580
‫et si c'est le cas, il ne se terminera pas, et s'il

123
00:06:24,580 --> 00:06:26,800
‫y a toujours une minuterie en attente, alors

124
00:06:26,800 --> 00:06:29,140
‫ce n'est pas le cas va quitter le programme.

125
00:06:29,140 --> 00:06:30,920
‫Mais s'il n'y en a pas,

126
00:06:30,920 --> 00:06:33,920
‫ce qui était le cas dans le premier exemple ici, alors

127
00:06:33,920 --> 00:06:36,660
‫il quitte immédiatement le programme, d'accord, mais maintenant nous avons

128
00:06:36,660 --> 00:06:38,980
‫en fait une minuterie ici, donc celle-ci fonctionnera

129
00:06:38,980 --> 00:06:41,620
‫pendant trois secondes, et essayons donc de comprendre ce

130
00:06:41,620 --> 00:06:43,220
‫que se passe ici.

131
00:06:45,260 --> 00:06:47,450
‫D'accord, vous voyez donc qu'il ne

132
00:06:47,450 --> 00:06:50,640
‫se ferme pas, et seulement maintenant, une fois la minuterie

133
00:06:50,640 --> 00:06:53,170
‫trois terminée, il a alors quitté l'application.

134
00:06:53,170 --> 00:06:56,100
‫D'accord, voyons cela à nouveau, donc toutes ces

135
00:06:56,100 --> 00:06:59,480
‫minuteries de journaux sont en cours d'exécution, la minuterie est

136
00:06:59,480 --> 00:07:02,070
‫terminée, et donc elle a quitté l'application.

137
00:07:02,070 --> 00:07:04,490
‫Maintenant à propos de ces résultats ici,

138
00:07:04,490 --> 00:07:06,820
‫rendons cela un peu plus facile

139
00:07:06,820 --> 00:07:10,113
‫à voir ici, et ajoutons juste un petit séparateur ici.

140
00:07:11,360 --> 00:07:14,683
‫OK, nettoie ça, OK.

141
00:07:16,510 --> 00:07:19,600
‫Donc, ces quatre sorties ici ne s'exécutaient pas

142
00:07:19,600 --> 00:07:22,110
‫vraiment dans la boucle d'événement, mais

143
00:07:22,110 --> 00:07:24,380
‫ces trois ici sortaient en

144
00:07:24,380 --> 00:07:28,150
‫fait de la boucle d'événement, alors analysons maintenant ces résultats.

145
00:07:28,150 --> 00:07:29,980
‫Maintenant, si vous vous

146
00:07:29,980 --> 00:07:32,690
‫souvenez du diagramme de la conférence précédente, vous

147
00:07:32,690 --> 00:07:36,960
‫aurez probablement pensé que la minuterie, donc la minuterie deux ici, devrait en

148
00:07:36,960 --> 00:07:39,640
‫fait se terminer avant le setImmediate, car dans

149
00:07:39,640 --> 00:07:42,640
‫le diagramme, elle est en fait apparue en premier

150
00:07:42,640 --> 00:07:45,100
‫tout en haut de la boucle événementielle.

151
00:07:45,100 --> 00:07:48,090
‫Nous devons donc définir ici le délai d'expiration avec

152
00:07:48,090 --> 00:07:52,500
‫zéro, ce qui devrait être en quelque sorte le même que setImmediate, n'est-ce pas.

153
00:07:52,500 --> 00:07:54,610
‫Alors pourquoi setImmediate

154
00:07:54,610 --> 00:07:57,630
‫apparaît-il avant le setTimeout ?

155
00:07:57,630 --> 00:08:00,020
‫Eh bien, il y a quelque chose que je

156
00:08:00,020 --> 00:08:02,470
‫n'ai pas vraiment expliqué dans la dernière vidéo, parce que

157
00:08:02,470 --> 00:08:05,750
‫je ne voulais pas rendre les choses encore plus confuses, et c'est que la

158
00:08:05,750 --> 00:08:09,320
‫boucle d'événement attend en fait que des choses se produisent dans la phase de sondage.

159
00:08:09,320 --> 00:08:12,270
‫Donc, dans cette phase où les rappels d'E/S sont gérés.

160
00:08:12,270 --> 00:08:15,400
‫Ainsi, lorsque cette file d'attente de rappels est vide, ce qui

161
00:08:15,400 --> 00:08:17,940
‫est le cas dans notre exemple fictif ici,

162
00:08:17,940 --> 00:08:20,270
‫nous n'avons donc pas de rappels d'E/S,

163
00:08:20,270 --> 00:08:23,500
‫tout ce que nous avons, ce sont ces minuteries, alors la

164
00:08:23,500 --> 00:08:27,490
‫boucle d'événement attendra dans cette phase jusqu'à ce qu'il y ait un expiration minuteur.

165
00:08:27,490 --> 00:08:31,430
‫Mais, si nous avons programmé un rappel à l'aide de setImmediate,

166
00:08:31,430 --> 00:08:34,320
‫ce rappel sera en fait exécuté immédiatement

167
00:08:34,320 --> 00:08:36,920
‫après la phase d'interrogation, et même

168
00:08:36,920 --> 00:08:40,240
‫avant l'expiration des minuteries, s'il y en a une.

169
00:08:40,240 --> 00:08:43,270
‫Et dans ce cas, le temporisateur expire immédiatement, donc

170
00:08:43,270 --> 00:08:46,080
‫après zéro seconde, mais encore une fois, la

171
00:08:46,080 --> 00:08:49,710
‫boucle d'événement attend en fait, elle s'arrête donc dans la phase d'interrogation.

172
00:08:49,710 --> 00:08:52,100
‫Et donc ce rappel setImmediate

173
00:08:52,100 --> 00:08:55,580
‫est en fait exécuté en premier, c'est donc toute

174
00:08:55,580 --> 00:08:59,730
‫la raison pour laquelle nous avons ceci immédiatement après les minuteries.

175
00:08:59,730 --> 00:09:02,770
‫D'accord, et je sais que cela semble très déroutant, et

176
00:09:02,770 --> 00:09:04,810
‫je suis tout à fait d'accord, mais

177
00:09:04,810 --> 00:09:08,090
‫c'est vraiment ainsi que Node. js fonctionne.

178
00:09:08,090 --> 00:09:11,380
‫Et maintenant, rendons cela encore un peu plus confus et

179
00:09:11,380 --> 00:09:14,250
‫ajoutons le processus. nextCochez dont nous

180
00:09:14,250 --> 00:09:16,950
‫avons également parlé dans la dernière conférence.

181
00:09:16,950 --> 00:09:21,950
‫Alors on dit processus. nextTick, puis comme avant, nous lui passons

182
00:09:22,170 --> 00:09:24,323
‫simplement une fonction de rappel.

183
00:09:25,540 --> 00:09:27,640
‫Et encore une fois, je veux juste me connecter

184
00:09:27,640 --> 00:09:31,663
‫à la console, et je vais dire processus. suivantTick.

185
00:09:32,550 --> 00:09:36,150
‫Alors que pensez-vous qu'il se passera dans ce cas?

186
00:09:36,150 --> 00:09:40,170
‫Allez-y et faites une supposition, et une fois que vous êtes prêt,

187
00:09:40,170 --> 00:09:42,883
‫vous pouvez alors exécuter ceci, alors faisons-le.

188
00:09:44,120 --> 00:09:48,280
‫Enregistrez-le ici d'abord, exécutez-le, et c'est parti.

189
00:09:48,280 --> 00:09:51,760
‫Les résultats sont donc à nouveau disponibles, et maintenant le

190
00:09:51,760 --> 00:09:55,640
‫premier rappel qui a été exécuté était en fait cette fonction ici.

191
00:09:55,640 --> 00:09:58,220
‫C'est pourquoi nous avons un processus. nextCochez à

192
00:09:58,220 --> 00:09:59,710
‫droite dans le premier.

193
00:09:59,710 --> 00:10:03,500
‫Alors pourquoi cette fonction de rappel du processus. suivantCocher le premier

194
00:10:03,500 --> 00:10:06,570
‫de tous à être exécuté ?

195
00:10:06,570 --> 00:10:09,070
‫Eh bien, rappelez-vous que nextTick fait

196
00:10:09,070 --> 00:10:12,410
‫partie de la file d'attente des microtâches, qui sont

197
00:10:12,410 --> 00:10:16,530
‫exécutées après chaque phase, donc pas seulement après un tick entier.

198
00:10:16,530 --> 00:10:19,120
‫Et donc ce qui s'est passé ici, c'est

199
00:10:19,120 --> 00:10:23,660
‫que cette fonction de rappel s'est en fait exécutée avant la phase où cette fonction

200
00:10:23,660 --> 00:10:26,970
‫de rappel s'est exécutée ici, et la phase avant celle-ci, d'accord.

201
00:10:26,970 --> 00:10:30,850
‫Maintenant, nextTick est en fait un nom trompeur, car un tick

202
00:10:30,850 --> 00:10:33,990
‫est en fait une boucle entière, mais nextTick

203
00:10:33,990 --> 00:10:37,860
‫se produit en fait avant la phase de boucle suivante,

204
00:10:37,860 --> 00:10:41,990
‫et non le tick entier, c'est donc ce que je disais auparavant.

205
00:10:41,990 --> 00:10:45,830
‫De l'autre côté, setImmediate vous ferait penser que

206
00:10:45,830 --> 00:10:49,690
‫son rappel serait exécuté immédiatement, mais ce n'est

207
00:10:49,690 --> 00:10:52,780
‫pas le cas, donc setImmediate est

208
00:10:52,780 --> 00:10:55,570
‫exécuté une fois par

209
00:10:55,570 --> 00:10:58,800
‫tick, tandis que nextTick est exécuté immédiatement.

210
00:10:58,800 --> 00:11:01,820
‫Et donc leurs deux noms devraient en fait être intervertis.

211
00:11:01,820 --> 00:11:03,700
‫Ils devraient être l'inverse, et cela

212
00:11:03,700 --> 00:11:05,390
‫peut causer beaucoup de confusion,

213
00:11:05,390 --> 00:11:08,440
‫il est donc préférable de toujours s'en tenir à l'un d'eux,

214
00:11:08,440 --> 00:11:12,470
‫et c'est généralement setImmediate et non process. suivantTick.

215
00:11:12,470 --> 00:11:15,070
‫Maintenant de toute façon, comme je l'ai mentionné dans

216
00:11:15,070 --> 00:11:18,530
‫une dernière vidéo, ces mécanismes sont en fait plus pour des cas

217
00:11:18,530 --> 00:11:20,320
‫d'utilisation assez avancés, c'est pourquoi

218
00:11:20,320 --> 00:11:22,760
‫nous ne les utiliserons probablement pas dans notre projet.

219
00:11:22,760 --> 00:11:24,970
‫Mais si vous voulez en savoir plus

220
00:11:24,970 --> 00:11:28,060
‫sur eux, vous pouvez toujours lire la documentation officielle de Node.

221
00:11:28,060 --> 00:11:30,660
‫D'accord, donc avec cela, nous avons simulé certains aspects

222
00:11:30,660 --> 00:11:33,250
‫de la boucle d'événement, mais pour finir, je veux

223
00:11:33,250 --> 00:11:35,500
‫juste introduire rapidement quelque chose sur le

224
00:11:35,500 --> 00:11:38,290
‫pool de threads, et pour cela nous allons faire

225
00:11:38,290 --> 00:11:40,950
‫une opération plus complexe qui sera en fait déchargée

226
00:11:40,950 --> 00:11:43,490
‫sur le pool de threads, et regardez combien

227
00:11:43,490 --> 00:11:47,040
‫de temps ces opérations prennent pour s'exécuter, et comment nous pouvons changer

228
00:11:47,040 --> 00:11:48,510
‫la taille du pool

229
00:11:48,510 --> 00:11:50,870
‫de threads dont nous avons parlé précédemment.

230
00:11:50,870 --> 00:11:52,840
‫Nous allons donc utiliser un peu de

231
00:11:52,840 --> 00:11:55,203
‫cryptographie ici pour crypter essentiellement un mot de passe.

232
00:11:58,620 --> 00:12:00,820
‫C'est donc un nouveau package que nous

233
00:12:00,820 --> 00:12:04,130
‫n'avions pas utilisé auparavant, et il s'appelle Crypto, mais j'ai mentionné

234
00:12:04,130 --> 00:12:07,063
‫plus tôt qu'en fait, toutes les fonctions de ce package

235
00:12:07,960 --> 00:12:11,260
‫seront automatiquement déchargées par la boucle d'événements vers le pool de

236
00:12:11,260 --> 00:12:13,280
‫threads, et c'est ce que nous

237
00:12:13,280 --> 00:12:14,780
‫je vais tester maintenant.

238
00:12:18,380 --> 00:12:22,070
‫Et utilisons ceci maintenant, donc crypto. pb, nous allons donc utiliser une

239
00:12:22,070 --> 00:12:25,303
‫fonction de cryptage appelée pbkdf2, donc un nom un peu bizarre,

240
00:12:27,610 --> 00:12:31,050
‫et maintenant nous passons la chaîne secrète, qui disons simplement mot

241
00:12:31,050 --> 00:12:34,640
‫de passe, puis nous avons besoin d'une chaîne pour résoudre les mots

242
00:12:34,640 --> 00:12:37,520
‫de passe, et les implémentations ici n'a pas vraiment d'importance,

243
00:12:37,520 --> 00:12:40,820
‫donc pour l'instant je ne vais pas entrer dans les détails

244
00:12:40,820 --> 00:12:42,970
‫de la façon dont cela fonctionne, nous

245
00:12:42,970 --> 00:12:46,150
‫allons le faire plus tard, d'accord, donc ici nous avons

246
00:12:46,150 --> 00:12:48,320
‫juste besoin de la longueur de la

247
00:12:48,320 --> 00:12:50,070
‫clé, donc ce nombre

248
00:12:50,070 --> 00:12:53,870
‫ici est juste pour le nombre d'itérations, puis c'est la longueur de la

249
00:12:53,870 --> 00:12:56,020
‫clé, et enfin l'algorithme, qui va

250
00:12:56,020 --> 00:12:58,430
‫être utilisé pour crypter le mot de passe.

251
00:12:58,430 --> 00:13:00,380
‫Ainsi, ces chiffres augmenteront

252
00:13:00,380 --> 00:13:02,483
‫simplement le temps nécessaire au cryptage.

253
00:13:04,970 --> 00:13:08,610
‫D'accord et enfin, il faut aussi une fonction de rappel, et tout ce que je vais faire

254
00:13:08,610 --> 00:13:11,483
‫ici, c'est faire une autre console. log, et

255
00:13:12,730 --> 00:13:16,453
‫dites simplement le mot de passe crypté.

256
00:13:17,950 --> 00:13:20,740
‫Maintenant, pour les besoins de cette

257
00:13:20,740 --> 00:13:24,220
‫démonstration, je veux en fait vous montrer combien de

258
00:13:24,220 --> 00:13:27,400
‫temps chacune de ces opérations prend, donc ce

259
00:13:27,400 --> 00:13:32,010
‫que nous allons faire est de définir une variable au début,

260
00:13:32,010 --> 00:13:37,010
‫de la mettre à jour. maintenant, c'est donc la date actuelle en millisecondes,

261
00:13:37,120 --> 00:13:41,310
‫et puis ici, tout ce que nous avons à faire est d'enregistrer non

262
00:13:41,310 --> 00:13:46,310
‫seulement la chaîne, mais aussi la date. maintenant, qui sera la date à

263
00:13:46,310 --> 00:13:49,700
‫ce stade en millisecondes, moins le début, et

264
00:13:49,700 --> 00:13:53,010
‫cela nous donnera alors le nombre de millisecondes

265
00:13:53,010 --> 00:13:55,380
‫qui se sont écoulées pour

266
00:13:55,380 --> 00:13:57,380
‫faire ce calcul.

267
00:13:57,380 --> 00:13:59,693
‫Bon, alors essayons-le, sauvegardons-le

268
00:14:00,890 --> 00:14:05,360
‫et exécutons-le à nouveau, et vous voyez ici qu'il

269
00:14:05,360 --> 00:14:08,530
‫a fallu 1855 millisecondes, donc presque

270
00:14:08,530 --> 00:14:12,250
‫deux secondes pour crypter ce mot de passe.

271
00:14:12,250 --> 00:14:15,110
‫D'accord, mais maintenant dupliquons ce code, ou en

272
00:14:15,110 --> 00:14:17,360
‫fait je veux que quatre

273
00:14:17,360 --> 00:14:19,660
‫instances de ceci vous montrent quelque chose.

274
00:14:19,660 --> 00:14:23,400
‫Donc, si nous l'exécutons maintenant, cela devrait probablement prendre à peu près

275
00:14:23,400 --> 00:14:25,710
‫le même temps, et oui c'est le cas,

276
00:14:25,710 --> 00:14:27,980
‫donc c'était 1. 8 secondes,

277
00:14:27,980 --> 00:14:31,620
‫maintenant il est 2. 2 secondes, ce qui est assez similaire.

278
00:14:31,620 --> 00:14:34,530
‫D'accord, et rappelez-vous que je vous ai dit dans l'une

279
00:14:34,530 --> 00:14:36,630
‫des conférences précédentes, que par défaut

280
00:14:36,630 --> 00:14:39,360
‫la taille du pool de threads est de quatre,

281
00:14:39,360 --> 00:14:41,720
‫donc il y a quatre threads qui font

282
00:14:41,720 --> 00:14:44,010
‫le travail en même temps, et c'est

283
00:14:44,010 --> 00:14:46,160
‫pourquoi ces quatre cryptages de mot de

284
00:14:46,160 --> 00:14:48,000
‫passe prennent environ en même

285
00:14:48,000 --> 00:14:50,740
‫temps et se produisent essentiellement tous en même temps.

286
00:14:50,740 --> 00:14:53,990
‫Mais nous pouvons réellement changer cette taille de pool de threads.

287
00:14:53,990 --> 00:14:57,100
‫Alors, laissez-moi vous montrer comment nous procédons, et nous le

288
00:14:57,100 --> 00:14:59,867
‫faisons en disant processus. env, et c'est

289
00:15:01,290 --> 00:15:03,230
‫une variable d'environnement, et encore une

290
00:15:03,230 --> 00:15:05,680
‫fois nous en reparlerons plus tard, et

291
00:15:06,684 --> 00:15:08,613
‫UV, qui signifie LibUV, la

292
00:15:11,232 --> 00:15:15,500
‫taille du pool de threads, donc si nous la définissons sur un, nous

293
00:15:15,500 --> 00:15:18,783
‫n'aurons qu'un seul thread dans notre pool de threads.

294
00:15:21,110 --> 00:15:26,110
‫Alors essayons à nouveau, et voyons ce qui se passe maintenant.

295
00:15:28,650 --> 00:15:32,840
‫Vous voyez donc qu'ils prennent tous beaucoup plus de temps à calculer.

296
00:15:32,840 --> 00:15:35,490
‫En gros, ils sont calculés les uns après les autres.

297
00:15:35,490 --> 00:15:38,470
‫Donc celui-ci le premier, puis celui-ci ici prend le double du

298
00:15:38,470 --> 00:15:40,610
‫temps, et encore une fois c'est parce

299
00:15:40,610 --> 00:15:42,980
‫que celui-ci ne peut commencer que dès que

300
00:15:42,980 --> 00:15:45,160
‫le premier est terminé, et de même avec

301
00:15:45,160 --> 00:15:46,893
‫le troisième et le quatrième.

302
00:15:47,920 --> 00:15:49,620
‫Disons maintenant que nous

303
00:15:52,170 --> 00:15:54,300
‫le changeons en deux, alors nous devrions

304
00:15:54,300 --> 00:15:56,990
‫voir les deux premiers avec le même temps, et

305
00:15:56,990 --> 00:15:59,710
‫exactement, les deux seconds également avec un temps similaire.

306
00:15:59,710 --> 00:16:01,363
‫Donc ça a du sens, hein.

307
00:16:02,650 --> 00:16:04,500
‫Juste pour terminer ici,

308
00:16:05,610 --> 00:16:08,950
‫maintenant le même avec trois, donc ces trois ont

309
00:16:08,950 --> 00:16:11,340
‫un temps similaire, puis le dernier.

310
00:16:11,340 --> 00:16:15,440
‫D'accord, c'est donc ainsi que fonctionne le pool de threads, j'ai donc décidé non

311
00:16:15,440 --> 00:16:18,660
‫seulement de me concentrer sur la boucle d'événements, mais aussi de

312
00:16:18,660 --> 00:16:22,630
‫vous donner un aperçu, très rapide, du pool de threads et de la

313
00:16:22,630 --> 00:16:25,010
‫façon dont nous pouvons modifier la taille du

314
00:16:25,010 --> 00:16:27,620
‫pool de threads , d'accord, gardez à l'esprit

315
00:16:27,620 --> 00:16:29,560
‫que ce code ici est

316
00:16:29,560 --> 00:16:33,230
‫en fait toujours asynchrone, car nous avons transmis une fonction de rappel.

317
00:16:33,230 --> 00:16:36,490
‫D'accord, et nous pourrions en fait utiliser la version synchrone,

318
00:16:36,490 --> 00:16:38,920
‫mais cela bloquerait alors la boucle d'événements.

319
00:16:38,920 --> 00:16:40,650
‫Tu veux voir ça ?

320
00:16:40,650 --> 00:16:43,183
‫Alors permettez-moi de vous montrer ça aussi très rapidement,

321
00:16:44,120 --> 00:16:46,130
‫donc celui-là n'était pas vraiment prévu, mais

322
00:16:46,130 --> 00:16:48,240
‫faisons-le quand même, car c'est très intéressant

323
00:16:48,240 --> 00:16:50,090
‫de voir ça je pense.

324
00:16:51,580 --> 00:16:53,830
‫Bon, ça va fonctionner comme ça.

325
00:16:53,830 --> 00:16:57,570
‫Nous utilisons à nouveau la version sync de la même fonction,

326
00:16:57,570 --> 00:16:59,950
‫qui une note, est plusieurs fois disponible.

327
00:16:59,950 --> 00:17:02,760
‫N'oubliez pas que nous avons la même chose pour le fichier

328
00:17:02,760 --> 00:17:05,190
‫de lecture, nous avons donc le fichier de lecture,

329
00:17:05,190 --> 00:17:08,290
‫qui accepte un rappel, et nous avons la synchronisation de fichier de

330
00:17:08,290 --> 00:17:11,440
‫lecture, qui est la version synchrone qui n'accepte aucun rappel, donc comme ça.

331
00:17:11,440 --> 00:17:13,520
‫Donc celui-ci chiffrera ensuite le mot

332
00:17:13,520 --> 00:17:16,890
‫de passe, bloquera l'exécution du code, puis passera à la ligne

333
00:17:16,890 --> 00:17:19,700
‫suivante, qui enregistrera alors ceci ici dans la console.

334
00:17:19,700 --> 00:17:21,823
‫Alors dupliquons maintenant ceci ici.

335
00:17:23,570 --> 00:17:26,553
‫C'était trop, débarrassez-vous de celui-ci ici, et maintenant

336
00:17:27,500 --> 00:17:31,310
‫ces quatre cryptages de mot de passe ne fonctionneront plus

337
00:17:31,310 --> 00:17:33,350
‫dans la boucle d'événement.

338
00:17:33,350 --> 00:17:37,070
‫Et ainsi, ils ne seront plus déchargés dans le pool de threads.

339
00:17:37,070 --> 00:17:39,980
‫D'accord, et maintenant, même si nous avons une taille de pool

340
00:17:39,980 --> 00:17:42,583
‫de threads de quatre, voyons ce qui se passe.

341
00:17:46,010 --> 00:17:50,080
‫Donc, vous voyez, ils se produisent complètement de manière synchrone.

342
00:17:50,080 --> 00:17:53,290
‫Donc, l'un après l'autre, et ce qui est

343
00:17:53,290 --> 00:17:55,350
‫encore pire, c'est que

344
00:17:55,350 --> 00:17:57,960
‫toutes ces minuteries ici, même nextTick et

345
00:17:57,960 --> 00:18:01,850
‫celle immédiate, n'apparaissent qu'après le cryptage des mots de passe.

346
00:18:01,850 --> 00:18:04,990
‫Donc, cela bloquait vraiment toute l'exécution, même si ce minuteur

347
00:18:04,990 --> 00:18:07,460
‫ici, par exemple celui-ci ici, était terminé après

348
00:18:07,460 --> 00:18:09,580
‫zéro seconde, et celui-ci après trois

349
00:18:09,580 --> 00:18:11,440
‫secondes, mais ils doivent tous

350
00:18:11,440 --> 00:18:13,830
‫attendre sept secondes jusqu'à ce que tous

351
00:18:13,830 --> 00:18:16,010
‫ces cryptages de mot de passe ici

352
00:18:16,010 --> 00:18:19,670
‫soient enfin prêt, encore une fois parce qu'ils ne fonctionnaient pas à

353
00:18:19,670 --> 00:18:22,120
‫l'intérieur de la boucle d'événement, mais ceux-ci l'étaient.

354
00:18:22,120 --> 00:18:24,960
‫Et donc, ils travaillaient essentiellement en arrière-plan et ne

355
00:18:24,960 --> 00:18:26,890
‫pouvaient être détectés par la

356
00:18:26,890 --> 00:18:29,470
‫boucle d'événement que lorsqu'ils étaient prêts, juste après

357
00:18:29,470 --> 00:18:32,110
‫ces quatre cryptages de mot de passe, donc

358
00:18:32,110 --> 00:18:34,760
‫celui-ci était un autre excellent exemple de voir

359
00:18:34,760 --> 00:18:38,240
‫le blocage de code et la boucle d'événement tout en action.

360
00:18:38,240 --> 00:18:41,600
‫D'accord, donc c'était suffisant pour une conférence, j'espère que vous

361
00:18:41,600 --> 00:18:43,270
‫l'avez trouvée intéressante, et

362
00:18:43,270 --> 00:18:45,220
‫à bientôt pour la suivante.

