1
00:00:01,830 --> 00:00:03,030
‫Instructeur : Bon retour !

2
00:00:03,030 --> 00:00:06,790
‫Dans cette vidéo, nous allons lire des fichiers

3
00:00:06,790 --> 00:00:11,063
‫et écrire deux fichiers comme avant, mais de manière asynchrone.

4
00:00:13,160 --> 00:00:14,960
‫Ajoutons quelques commentaires ici avant.

5
00:00:19,630 --> 00:00:21,183
‫Donc, c'est

6
00:00:26,160 --> 00:00:31,160
‫la manière bloquante, synchrone, et ensuite, nous allons faire

7
00:00:32,870 --> 00:00:36,480
‫un exercice de manière non bloquante, asynchrone.

8
00:00:36,480 --> 00:00:38,230
‫Donc, nous n'allons pas

9
00:00:38,230 --> 00:00:40,300
‫faire la même chose, nous allons

10
00:00:40,300 --> 00:00:43,150
‫juste inventer un autre genre d'exercice fou ici.

11
00:00:43,150 --> 00:00:46,350
‫Donc, pour lire un fichier de manière asynchrone,

12
00:00:46,350 --> 00:00:48,410
‫ça marche comme ça.

13
00:00:48,410 --> 00:00:53,380
‫Encore une fois, nous avons besoin du module FS, puis de lire le fichier, mais cette fois,

14
00:00:54,890 --> 00:00:57,920
‫pas de lire la synchronisation de fichier, bien sûr.

15
00:00:57,920 --> 00:01:01,930
‫Et, encore une fois, nous passons le nom du fichier, ou le chemin

16
00:01:01,930 --> 00:01:04,060
‫d'accès au fichier en fait, et encore

17
00:01:04,060 --> 00:01:07,360
‫une fois, c'est txt, et le fichier que je veux

18
00:01:07,360 --> 00:01:11,583
‫en ce moment s'appelle start. txt,

19
00:01:12,460 --> 00:01:14,603
‫donc celui-ci.

20
00:01:16,040 --> 00:01:17,860
‫Oups, désolé pour ça.

21
00:01:17,860 --> 00:01:21,790
‫Donc, c'est le fichier que je veux, sur la tâche est lu ceci, et

22
00:01:21,790 --> 00:01:24,660
‫je vais vous expliquer pourquoi un peu plus tard.

23
00:01:24,660 --> 00:01:26,860
‫Pour l'instant, ne vous inquiétez pas du contenu ici.

24
00:01:28,220 --> 00:01:29,360
‫Donc, dans

25
00:01:29,360 --> 00:01:34,360
‫le fichier lu, nous n'avons pas besoin de spécifier l'encodage du fichier, d'accord.

26
00:01:34,580 --> 00:01:36,090
‫Et donc, le prochain

27
00:01:36,090 --> 00:01:39,500
‫paramètre, le deuxième sera une fonction de rappel, et c'est ce

28
00:01:39,500 --> 00:01:42,270
‫que nous avons appris dans la dernière leçon.

29
00:01:42,270 --> 00:01:45,380
‫Ainsi, Node JS est entièrement construit autour de

30
00:01:45,380 --> 00:01:48,750
‫rappels afin d'implémenter un comportement asynchrone, et c'est ainsi

31
00:01:48,750 --> 00:01:50,200
‫que cela fonctionne.

32
00:01:50,200 --> 00:01:53,080
‫Ainsi, Node commencera à lire ce

33
00:01:53,080 --> 00:01:56,470
‫fichier ici en arrière-plan, et dès qu'il sera prêt,

34
00:01:56,470 --> 00:02:00,543
‫il lancera la fonction de rappel que nous spécifions ici.

35
00:02:03,880 --> 00:02:06,730
‫D'accord, et il appelle cette fonction de

36
00:02:06,730 --> 00:02:08,450
‫rappel avec deux arguments.

37
00:02:08,450 --> 00:02:11,440
‫Le premier est l'erreur, et

38
00:02:11,440 --> 00:02:15,560
‫le second les données réelles, d'accord ?

39
00:02:15,560 --> 00:02:19,130
‫Donc, ce style de premier rappel d'erreur est

40
00:02:19,130 --> 00:02:22,090
‫très typique dans Node JS, d'accord.

41
00:02:22,090 --> 00:02:24,910
‫Ainsi, de très nombreuses fois, le

42
00:02:24,910 --> 00:02:28,730
‫premier paramètre d'un rappel sera l'erreur, au cas où il

43
00:02:28,730 --> 00:02:33,060
‫y en aurait eu, et le second sera alors les données elles-mêmes.

44
00:02:33,060 --> 00:02:34,403
‫Ce qui compte

45
00:02:34,403 --> 00:02:38,610
‫ici, c'est que l'erreur est généralement toujours la première, d'accord ?

46
00:02:38,610 --> 00:02:41,740
‫Et donc juste pour le

47
00:02:41,740 --> 00:02:46,740
‫tester pour l'instant, connectons simplement via la console, les données.

48
00:02:47,100 --> 00:02:50,050
‫Et donc, testons cela maintenant.

49
00:02:50,050 --> 00:02:51,520
‫Mais, avant de

50
00:02:51,520 --> 00:02:55,793
‫faire cela, spécifions encore le codage de classement ici, d'accord ?

51
00:02:57,820 --> 00:03:00,160
‫Donc, je ne suis pas sûr à

52
00:03:00,160 --> 00:03:01,933
‫cent pour cent que cela

53
00:03:04,190 --> 00:03:09,190
‫fonctionne sans cela, alors nettoyez-le maintenant, exécutez-le à nouveau, et nous voyons ici lire ceci.

54
00:03:10,400 --> 00:03:13,790
‫Alors, analysons, encore une fois, ce qui s'est passé ici.

55
00:03:13,790 --> 00:03:17,260
‫Dès que cette fonction ici est exécutée, elle

56
00:03:17,260 --> 00:03:20,980
‫commencera à lire ce fichier en arrière-plan sans bloquer

57
00:03:20,980 --> 00:03:24,083
‫le reste de l'exécution du code.

58
00:03:24,970 --> 00:03:27,663
‫Alors, permettez-moi de le démontrer ici.

59
00:03:29,290 --> 00:03:30,690
‫Donc, une console. log

60
00:03:33,370 --> 00:03:38,370
‫lira le fichier, et juste pour avoir un peu moins

61
00:03:38,530 --> 00:03:43,170
‫de confusion, laissez-moi commenter cette partie ici, d'accord.

62
00:03:43,170 --> 00:03:45,970
‫Et alors, que pensez-vous qu'il va se passer maintenant?

63
00:03:45,970 --> 00:03:48,533
‫Quel journal allons-nous voir en premier ?

64
00:03:51,830 --> 00:03:55,060
‫Et en effet, nous voyons d'abord lire

65
00:03:55,060 --> 00:03:58,470
‫le fichier, et ensuite seulement, nous voyons lire ceci.

66
00:03:58,470 --> 00:04:00,960
‫Alors, encore une fois, pourquoi est-ce arrivé?

67
00:04:00,960 --> 00:04:04,400
‫Ainsi, comme je l'ai mentionné, Node JS commencera à lire

68
00:04:04,400 --> 00:04:07,570
‫le fichier en arrière-plan ici et ne bloquera

69
00:04:07,570 --> 00:04:11,760
‫pas le code, puis passera immédiatement à la ligne de code suivante.

70
00:04:11,760 --> 00:04:15,240
‫Et, la prochaine ligne de code, eh bien, c'est ce journal ici,

71
00:04:15,240 --> 00:04:17,030
‫et c'est donc la première

72
00:04:17,030 --> 00:04:19,520
‫chose qui sera enregistrée ici dans le terminal.

73
00:04:19,520 --> 00:04:22,760
‫Alors seulement, lorsqu'un fichier est complètement

74
00:04:22,760 --> 00:04:26,580
‫lu, cette fonction de rappel ici s'exécutera, d'accord ?

75
00:04:26,580 --> 00:04:30,810
‫Et encore une fois, cette fonction de rappel a accès à l'erreur et aux

76
00:04:30,810 --> 00:04:33,070
‫données qui ont été lues, et nous

77
00:04:33,070 --> 00:04:36,260
‫pourrions vraiment appeler cela ici tout ce que nous voulions.

78
00:04:36,260 --> 00:04:39,250
‫Nous pourrions aussi l'appeler texte, cela n'a pas vraiment d'importance, tout

79
00:04:39,250 --> 00:04:42,240
‫ce qui compte, c'est que c'est le deuxième argument de

80
00:04:42,240 --> 00:04:43,713
‫cette fonction de rappel.

81
00:04:44,670 --> 00:04:47,070
‫Revenons en fait aux données

82
00:04:47,070 --> 00:04:49,740
‫parce que j'aime mieux cette façon.

83
00:04:49,740 --> 00:04:54,740
‫Et donc, alors seulement, cette console. log fonctionnera avec les données, donc

84
00:04:54,900 --> 00:04:57,510
‫avec le texte qui était dans le fichier.

85
00:04:57,510 --> 00:05:01,480
‫Et donc, c'est pourquoi nous voyons cela ici comme le deuxième journal.

86
00:05:01,480 --> 00:05:04,430
‫Très bien, maintenant pour aller encore plus

87
00:05:04,430 --> 00:05:08,860
‫loin, faisons en fait un autre fichier de lecture, mais au lieu de

88
00:05:08,860 --> 00:05:11,990
‫cela, afin que je puisse vous montrer que nous

89
00:05:11,990 --> 00:05:16,130
‫pouvons essentiellement effectuer plusieurs étapes, l'une après l'autre, avec des rappels.

90
00:05:16,130 --> 00:05:20,810
‫Donc, des étapes qui dépendent du résultat de l'étape précédente.

91
00:05:20,810 --> 00:05:25,310
‫D'accord, c'est pourquoi en fait, dans le fichier de démarrage, j'ai

92
00:05:25,310 --> 00:05:26,610
‫lu ceci

93
00:05:26,610 --> 00:05:29,930
‫car il existe alors un fichier appelé read this,

94
00:05:29,930 --> 00:05:33,103
‫qui contient le contenu qui nous intéresse réellement.

95
00:05:34,090 --> 00:05:34,923
‫D'accord?

96
00:05:37,060 --> 00:05:39,963
‫Donc, ce que je vais faire ici, c'est copier ce

97
00:05:40,890 --> 00:05:42,793
‫code et le mettre ici.

98
00:05:44,740 --> 00:05:48,210
‫Je vais appeler celui-ci les données un, puis les

99
00:05:48,210 --> 00:05:52,900
‫données deux, et le résultat de la deuxième étape, donc le deuxième

100
00:05:52,900 --> 00:05:55,140
‫fichier lu, dépendra du premier.

101
00:05:55,140 --> 00:06:00,140
‫C'est parce que nous utiliserons les données pour le nom du fichier, vous vous souvenez ?

102
00:06:02,030 --> 00:06:05,340
‫Donc, ici, nous faisons un (marmonne) maintenant parce

103
00:06:06,290 --> 00:06:10,730
‫que nous devons mettre cette variable, et elle s'appelle data

104
00:06:14,490 --> 00:06:15,323
‫one.

105
00:06:16,330 --> 00:06:18,290
‫D'accord, ça a du sens ?

106
00:06:18,290 --> 00:06:22,900
‫Donc, les données un seront lues ceci, d'accord, et ainsi, à

107
00:06:22,900 --> 00:06:27,900
‫l'étape suivante, nous lirons txt/readthis. txt, qui est

108
00:06:30,090 --> 00:06:31,910
‫alors ceci.

109
00:06:31,910 --> 00:06:35,110
‫D'accord, et c'est pourquoi ce nom de fichier ici est

110
00:06:35,110 --> 00:06:37,053
‫le même que ce contenu.

111
00:06:39,340 --> 00:06:42,283
‫Et donc, cela est connecté via les données de la console à cela.

112
00:06:43,310 --> 00:06:45,833
‫Et, testons rapidement si cela fonctionne, et en

113
00:06:48,370 --> 00:06:53,370
‫effet, c'est le contenu de lire ceci. SMS.

114
00:06:53,860 --> 00:06:57,030
‫Et maintenant, je vais aller encore plus loin, même parce

115
00:06:57,030 --> 00:07:00,740
‫qu'il y a un autre texte dans ce fichier d'ajout que je

116
00:07:00,740 --> 00:07:04,080
‫veux ajouter à cette première chaîne, donc il y a

117
00:07:04,080 --> 00:07:06,420
‫du texte provenant de l'autre fichier.

118
00:07:06,420 --> 00:07:08,590
‫Et donc, nous avons encore une

119
00:07:08,590 --> 00:07:10,840
‫autre étape qui dépend de l'étape précédente, donc

120
00:07:10,840 --> 00:07:14,563
‫ce que je vais faire est d'ajouter un autre fichier de lecture ici.

121
00:07:15,560 --> 00:07:17,660
‫Alors, juste comme ça.

122
00:07:17,660 --> 00:07:19,313
‫Donc, celui-ci s'appelle append,

123
00:07:21,610 --> 00:07:26,610
‫et je vais appeler celui-ci les données trois, les données trois ici, et c'est

124
00:07:27,720 --> 00:07:30,133
‫donc, encore une fois, exécuter cela.

125
00:07:32,760 --> 00:07:37,570
‫Et, d'accord, nous avons maintenant ces deux résultats ici.

126
00:07:37,570 --> 00:07:40,830
‫Très bien, et maintenant enfin, comme dernière étape,

127
00:07:40,830 --> 00:07:44,030
‫je veux écrire ces deux chaînes ensemble

128
00:07:44,030 --> 00:07:46,360
‫dans un fichier, d'accord ?

129
00:07:46,360 --> 00:07:48,500
‫Jusqu'à présent, nous n'avons lu

130
00:07:48,500 --> 00:07:51,160
‫que des fichiers, mais je veux également

131
00:07:51,160 --> 00:07:53,730
‫écrire un fichier, alors faisons-le ici aussi.

132
00:07:53,730 --> 00:07:54,623
‫Donc, fs.

133
00:07:57,480 --> 00:08:01,100
‫writeFile, et bien sûr, nous n'utilisons pas la version synchrone

134
00:08:01,100 --> 00:08:02,140
‫comme nous le

135
00:08:02,140 --> 00:08:06,320
‫faisions auparavant, mais encore une fois, nous utilisons, comme ici et ici

136
00:08:06,320 --> 00:08:10,113
‫et ici, nous utilisons la version asynchrone, pas la version synchrone.

137
00:08:11,600 --> 00:08:16,600
‫Donc, txt slash, manquant celui-ci ici,

138
00:08:19,240 --> 00:08:20,143
‫final.

139
00:08:22,314 --> 00:08:25,933
‫Ensuite, nous devons également ajouter le codage textuel ici, puis celui-ci

140
00:08:29,650 --> 00:08:33,040
‫accepte également une fonction de rappel, mais dans ce cas,

141
00:08:33,040 --> 00:08:36,220
‫nous ne lisons aucune donnée et nous n'avons donc

142
00:08:36,220 --> 00:08:38,370
‫pas besoin de deux arguments.

143
00:08:38,370 --> 00:08:41,933
‫Donc, le seul argument que nous ayons est l'erreur, en fait.

144
00:08:44,100 --> 00:08:48,980
‫D'accord, nous avons donc ici l'erreur et les données qui ont été lues, mais

145
00:08:48,980 --> 00:08:52,270
‫ici, dans writeFile, il n'y a pas de données.

146
00:08:52,270 --> 00:08:56,690
‫Tout ce qu'il y a, ou peut être, c'est une erreur, d'accord ?

147
00:08:56,690 --> 00:08:58,530
‫Et en fait, il nous

148
00:08:58,530 --> 00:09:03,063
‫manque quelque chose ici, c'est ce que nous voulons réellement écrire dans le fichier.

149
00:09:03,910 --> 00:09:06,430
‫D'accord, et c'est donc le deuxième argument,

150
00:09:06,430 --> 00:09:11,100
‫et ce que c'est, ce sont les données deux et les données trois.

151
00:09:11,100 --> 00:09:12,823
‫Donc, encore une fois une

152
00:09:14,340 --> 00:09:16,063
‫chaîne (marmonne) ici, les données

153
00:09:17,620 --> 00:09:21,323
‫deux, puis un nouveau caractère de ligne, qui est encore une fois

154
00:09:23,010 --> 00:09:25,523
‫la barre oblique inverse n, puis les données 3.

155
00:09:27,360 --> 00:09:32,010
‫Très bien, et ainsi, tout comme avec les fonctions de lecture de fichier, ce rappel est

156
00:09:32,010 --> 00:09:35,800
‫ce qui est exécuté à la fin, donc ce que je vais faire

157
00:09:35,800 --> 00:09:38,660
‫ici est de simplement connecter via la console que les

158
00:09:38,660 --> 00:09:40,613
‫fichiers ont été écrits, ou que

159
00:09:41,490 --> 00:09:43,190
‫le fichier a été écrit.

160
00:09:44,430 --> 00:09:49,360
‫Votre fichier a été écrit, et utilisons simplement des emoji

161
00:09:49,360 --> 00:09:53,220
‫amusants ici, juste pour rendre la console

162
00:09:53,220 --> 00:09:56,883
‫un peu plus lumineuse pour nous,

163
00:09:58,300 --> 00:10:03,080
‫et je pense que nous devrions faire comme ça.

164
00:10:03,080 --> 00:10:06,023
‫Alors, effaçons la console une fois de plus, exécutons-la

165
00:10:07,370 --> 00:10:10,560
‫et nous voyons en effet que votre fichier a été écrit.

166
00:10:10,560 --> 00:10:11,833
‫Alors, vraiment ?

167
00:10:13,460 --> 00:10:14,990
‫Final.

168
00:10:14,990 --> 00:10:16,433
‫Oh, ouais, c'est ici.

169
00:10:18,140 --> 00:10:22,040
‫Il s'agit donc de lire ce texte

170
00:10:22,040 --> 00:10:27,040
‫et d'ajouter du texte, tous deux ensemble, dans le même fichier.

171
00:10:27,490 --> 00:10:32,490
‫D'accord, c'est ainsi que nous effectuons plusieurs étapes dans les commandes, en utilisant

172
00:10:33,160 --> 00:10:36,270
‫des fonctions de rappel, n'est-ce pas ?

173
00:10:36,270 --> 00:10:40,180
‫Car imaginez que vous ayez simplement lu le même fichier,

174
00:10:40,180 --> 00:10:42,490
‫puis le deuxième fichier lu, donc

175
00:10:42,490 --> 00:10:44,060
‫celui-ci, juste après.

176
00:10:44,060 --> 00:10:46,770
‫Eh bien, comment auriez-vous alors accès aux

177
00:10:46,770 --> 00:10:49,200
‫données du premier, n'est-ce pas ?

178
00:10:49,200 --> 00:10:52,420
‫Et c'est ainsi que ce modèle émerge.

179
00:10:52,420 --> 00:10:53,720
‫Il a en

180
00:10:53,720 --> 00:10:55,930
‫fait son propre nom, et je pense

181
00:10:55,930 --> 00:10:58,240
‫avoir mentionné que dans la dernière vidéo, c'est

182
00:10:58,240 --> 00:11:01,490
‫l'enfer appelé callback, et il existe quelques solutions pour rendre ce code

183
00:11:01,490 --> 00:11:04,080
‫ici plus lisible et mieux à comprendre, mais pour

184
00:11:04,080 --> 00:11:07,130
‫l'instant, ce n'est pas le cas. importe du tout pour vous.

185
00:11:07,130 --> 00:11:10,650
‫Ce qui compte, c'est que Node JS est

186
00:11:10,650 --> 00:11:13,480
‫construit autour de cette philosophie de

187
00:11:13,480 --> 00:11:17,530
‫rappels, c'est donc ainsi que Node JS implémente les opérations

188
00:11:17,530 --> 00:11:20,330
‫asynchrones, en appelant des rappels

189
00:11:20,330 --> 00:11:23,260
‫dès que l'opération qu'il effectue est terminée.

190
00:11:23,260 --> 00:11:26,280
‫Et, au fait, cette façon d'écrire la fonction que vous

191
00:11:26,280 --> 00:11:28,110
‫voyez ici, encore une fois, au

192
00:11:28,110 --> 00:11:29,870
‫cas où vous ne

193
00:11:29,870 --> 00:11:33,420
‫la connaîtriez pas, c'est aussi la nouvelle syntaxe ES6, d'accord ?

194
00:11:33,420 --> 00:11:36,320
‫Donc, encore une fois, j'espère que vous êtes

195
00:11:36,320 --> 00:11:38,550
‫familiarisé avec ES6 à ce stade,

196
00:11:38,550 --> 00:11:41,950
‫et pour que tout cela ait un sens pour vous.

197
00:11:41,950 --> 00:11:44,580
‫Si vous deviez écrire cette

198
00:11:45,700 --> 00:11:49,461
‫fonction ici sans la syntaxe de la fonction

199
00:11:49,461 --> 00:11:54,461
‫d'erreur, nous ferions simplement comme ceci, fonction, erreur, donnée un,

200
00:11:55,950 --> 00:11:57,600
‫puis comme ceci.

201
00:11:57,600 --> 00:11:59,470
‫Donc, c'est une

202
00:11:59,470 --> 00:12:02,210
‫fonction normale, disons une fonction à

203
00:12:02,210 --> 00:12:05,470
‫l'ancienne, et la nouvelle version fonctionne comme ça.

204
00:12:05,470 --> 00:12:09,490
‫La différence entre eux est principalement la syntaxe, mais aussi

205
00:12:09,490 --> 00:12:12,690
‫le fait qu'une fonction d'erreur, donc ce type

206
00:12:12,690 --> 00:12:14,360
‫de fonction, n'obtient

207
00:12:14,360 --> 00:12:17,070
‫pas son propre mot-clé disk, elle

208
00:12:17,070 --> 00:12:20,860
‫utilise donc le mot-clé disk de la fonction parent.

209
00:12:20,860 --> 00:12:24,540
‫Et cela s'appelle le mot-clé lexical disk, alors qu'une

210
00:12:24,540 --> 00:12:27,500
‫fonction normale comme celle-ci obtient toujours

211
00:12:27,500 --> 00:12:30,920
‫son propre mot-clé disk, n'est-ce pas ?

212
00:12:30,920 --> 00:12:33,610
‫Je suis sûr que vous êtes familier avec ce genre

213
00:12:33,610 --> 00:12:37,640
‫de choses, mais faites juste une petite critique ici au cas où vous ne le sauriez pas.

214
00:12:37,640 --> 00:12:39,673
‫Bon, j'espère que c'est fait depuis.

215
00:12:40,600 --> 00:12:44,150
‫Nous n'avons en fait jamais utilisé cette erreur, nous

216
00:12:44,150 --> 00:12:46,160
‫n'avons traité aucune erreur,

217
00:12:46,160 --> 00:12:50,060
‫alors, par exemple, imaginez que ce fichier ici n'existait pas.

218
00:12:50,060 --> 00:12:52,490
‫Eh bien, nous aurions pu utiliser

219
00:12:52,490 --> 00:12:56,300
‫cette erreur, et faisons-le, mais juste pour celle-ci ici, donc je

220
00:12:56,300 --> 00:13:00,820
‫ne veux pas créer tous ces gestionnaires d'erreurs ici, mais juste dans cette

221
00:13:00,820 --> 00:13:04,100
‫situation, disons qu'il y a eu une erreur, et

222
00:13:04,100 --> 00:13:06,463
‫ainsi disons si erreur, le retour

223
00:13:07,340 --> 00:13:10,373
‫de cette fonction, alors ne faites rien d'autre,

224
00:13:12,290 --> 00:13:13,743
‫et connectez-vous à

225
00:13:18,050 --> 00:13:22,260
‫la console, erreur, puis nous pouvons ajouter d'autres emoji ici, comme cette

226
00:13:22,260 --> 00:13:25,653
‫explosion, donc comme quelque chose qui a explosé ici.

227
00:13:28,010 --> 00:13:32,933
‫Alors, changeons maintenant cela ici, comme start. txt, exécutez-le à nouveau, et nous

228
00:13:33,900 --> 00:13:34,973
‫avons donc

229
00:13:36,090 --> 00:13:39,980
‫cette erreur maintenant, donc cela nous donne ce journal à la

230
00:13:39,980 --> 00:13:42,570
‫console, et puisque nous sommes revenus, il

231
00:13:42,570 --> 00:13:46,200
‫ne fera rien après cela, donc tout cela est fondamentalement

232
00:13:46,200 --> 00:13:49,990
‫ignoré et ne fonctionnera pas , ce qui est exactement

233
00:13:49,990 --> 00:13:51,823
‫ce que nous voulons.

234
00:13:52,680 --> 00:13:55,863
‫D'accord, mais si nous le remettons à la

235
00:13:57,720 --> 00:13:59,090
‫normale, puis le

236
00:13:59,090 --> 00:14:02,010
‫réexécutons, eh bien, tout fonctionne comme avant.

237
00:14:02,010 --> 00:14:05,270
‫Alors, habituez-vous à ce modèle de rappels car vous

238
00:14:05,270 --> 00:14:08,270
‫le verrez partout dans Node JS et tout

239
00:14:08,270 --> 00:14:10,163
‫au long de cette section.