﻿1
00:00:01,830 --> 00:00:03,030
‫Kursleiter: Willkommen zurück!

2
00:00:03,030 --> 00:00:06,790
‫In diesem Video werden wir wie zuvor

3
00:00:06,790 --> 00:00:11,063
‫Dateien lesen und zwei Dateien schreiben, jedoch auf asynchrone Weise.

4
00:00:13,160 --> 00:00:14,960
‫Lassen Sie uns hier zuvor einige Kommentare hinzufügen.

5
00:00:19,630 --> 00:00:21,183
‫Dies ist

6
00:00:26,160 --> 00:00:31,160
‫also der blockierende, synchrone Weg, und dann werden wir eine

7
00:00:32,870 --> 00:00:36,480
‫Übung auf nicht blockierende, asynchrone Weise durchführen.

8
00:00:36,480 --> 00:00:38,230
‫Wir werden also nicht

9
00:00:38,230 --> 00:00:40,300
‫das Gleiche tun, wir erfinden

10
00:00:40,300 --> 00:00:43,150
‫hier nur eine andere Art von verrückter Übung.

11
00:00:43,150 --> 00:00:46,350
‫Um eine Datei asynchron zu lesen, funktioniert

12
00:00:46,350 --> 00:00:48,410
‫es also wie folgt.

13
00:00:48,410 --> 00:00:53,380
‫Auch hier brauchen wir das FS-Modul und dann die Datei lesen,

14
00:00:54,890 --> 00:00:57,920
‫aber diesmal natürlich nicht die Dateisynchronisierung.

15
00:00:57,920 --> 00:01:01,930
‫Und wieder übergeben wir den Namen der Datei oder den eigentlichen

16
00:01:01,930 --> 00:01:04,060
‫Pfad zur Datei, und so ist

17
00:01:04,060 --> 00:01:07,360
‫es wieder txt, und die Datei, die ich

18
00:01:07,360 --> 00:01:11,583
‫jetzt möchte, heißt start. txt,

19
00:01:12,460 --> 00:01:14,603
‫also diese hier.

20
00:01:16,040 --> 00:01:17,860
‫Ups, das tut mir leid.

21
00:01:17,860 --> 00:01:21,790
‫Das ist also die Datei, die ich haben möchte, die Aufgabe lautet: Lesen

22
00:01:21,790 --> 00:01:24,660
‫Sie dies, und ich werde Ihnen später erklären, warum.

23
00:01:24,660 --> 00:01:26,860
‫Kümmern Sie sich vorerst nicht um den Inhalt hier.

24
00:01:28,220 --> 00:01:29,360
‫In der

25
00:01:29,360 --> 00:01:34,360
‫gelesenen Datei müssen wir die Dateicodierung also eigentlich nicht angeben, okay.

26
00:01:34,580 --> 00:01:36,090
‫Der nächste Parameter,

27
00:01:36,090 --> 00:01:39,500
‫der zweite, wird also eine Callback-Funktion sein, und das

28
00:01:39,500 --> 00:01:42,270
‫haben wir in der letzten Vorlesung gelernt.

29
00:01:42,270 --> 00:01:45,380
‫Node JS basiert also auf Callbacks, um

30
00:01:45,380 --> 00:01:48,750
‫ein asynchrones Verhalten zu implementieren, und so

31
00:01:48,750 --> 00:01:50,200
‫funktioniert es.

32
00:01:50,200 --> 00:01:53,080
‫Node beginnt also hier im Hintergrund

33
00:01:53,080 --> 00:01:56,470
‫mit dem Lesen dieser Datei und sobald sie

34
00:01:56,470 --> 00:02:00,543
‫fertig ist, startet es die Callback-Funktion, die wir hier angeben.

35
00:02:03,880 --> 00:02:06,730
‫Okay, und es ruft diese Callback-Funktion mit

36
00:02:06,730 --> 00:02:08,450
‫zwei Argumenten auf.

37
00:02:08,450 --> 00:02:11,440
‫Der erste ist der Fehler

38
00:02:11,440 --> 00:02:15,560
‫und der zweite sind die tatsächlichen Daten, okay?

39
00:02:15,560 --> 00:02:19,130
‫Dieser Fehler-First-Callback-Stil ist also in Node

40
00:02:19,130 --> 00:02:22,090
‫JS sehr typisch, okay.

41
00:02:22,090 --> 00:02:24,910
‫Daher ist der erste Parameter

42
00:02:24,910 --> 00:02:28,730
‫in einem Callback oft der Fehler, falls einer aufgetreten

43
00:02:28,730 --> 00:02:33,060
‫ist, und der zweite Parameter sind dann die Daten selbst.

44
00:02:33,060 --> 00:02:34,403
‫Wichtig ist

45
00:02:34,403 --> 00:02:38,610
‫hier, dass der Fehler normalerweise immer der erste ist, okay?

46
00:02:38,610 --> 00:02:41,740
‫Um es jetzt zu testen,

47
00:02:41,740 --> 00:02:46,740
‫loggen wir uns einfach über die Konsole die Daten ein.

48
00:02:47,100 --> 00:02:50,050
‫Lassen Sie uns das nun tatsächlich testen.

49
00:02:50,050 --> 00:02:51,520
‫Aber bevor wir

50
00:02:51,520 --> 00:02:55,793
‫das tun, lassen Sie uns hier eigentlich noch die Ablagecodierung angeben, okay?

51
00:02:57,820 --> 00:03:00,160
‫Also, ich bin mir nicht hundertprozentig sicher, ob

52
00:03:00,160 --> 00:03:01,933
‫es ohne das funktioniert, also

53
00:03:04,190 --> 00:03:09,190
‫bereinigen Sie das jetzt, führen Sie es erneut aus, und hier sehen wir, dass es gelesen wird.

54
00:03:10,400 --> 00:03:13,790
‫Lassen Sie uns also noch einmal analysieren, was hier passiert ist.

55
00:03:13,790 --> 00:03:17,260
‫Sobald diese Funktion hier ausgeführt wird, beginnt

56
00:03:17,260 --> 00:03:20,980
‫sie im Hintergrund mit dem Lesen dieser Datei,

57
00:03:20,980 --> 00:03:24,083
‫ohne die restliche Codeausführung zu blockieren.

58
00:03:24,970 --> 00:03:27,663
‫Lassen Sie mich dies hier tatsächlich demonstrieren.

59
00:03:29,290 --> 00:03:30,690
‫Also eine Konsole. log

60
00:03:33,370 --> 00:03:38,370
‫wird die Datei lesen, und nur um dort ein bisschen weniger Verwirrung

61
00:03:38,530 --> 00:03:43,170
‫zu haben, lassen Sie mich diesen Teil hier auskommentieren, okay.

62
00:03:43,170 --> 00:03:45,970
‫Und was denkst du wird jetzt passieren?

63
00:03:45,970 --> 00:03:48,533
‫Welches Protokoll werden wir zuerst sehen?

64
00:03:51,830 --> 00:03:55,060
‫Und tatsächlich sehen wir zuerst die Datei

65
00:03:55,060 --> 00:03:58,470
‫wird gelesen und erst dann sehen wir dies lesen.

66
00:03:58,470 --> 00:04:00,960
‫Also nochmal, warum ist das passiert?

67
00:04:00,960 --> 00:04:04,400
‫Wie ich bereits erwähnt habe, beginnt Node JS hier

68
00:04:04,400 --> 00:04:07,570
‫im Hintergrund mit dem Lesen der Datei, blockiert

69
00:04:07,570 --> 00:04:11,760
‫den Code nicht und geht dann sofort zur nächsten Codezeile über.

70
00:04:11,760 --> 00:04:15,240
‫Und die nächste Codezeile, nun, es ist dieses Protokoll hier,

71
00:04:15,240 --> 00:04:17,030
‫und das ist das

72
00:04:17,030 --> 00:04:19,520
‫erste, was hier im Terminal protokolliert wird.

73
00:04:19,520 --> 00:04:22,760
‫Erst dann, wenn eine Datei vollständig

74
00:04:22,760 --> 00:04:26,580
‫gelesen ist, wird diese Callback-Funktion hier ausgeführt, okay?

75
00:04:26,580 --> 00:04:30,810
‫Und wieder hat diese Callback-Funktion Zugriff auf den Fehler und die

76
00:04:30,810 --> 00:04:33,070
‫gelesenen Daten, und wir könnten

77
00:04:33,070 --> 00:04:36,260
‫das hier wirklich alles nennen, was wir wollten.

78
00:04:36,260 --> 00:04:39,250
‫Wir könnten es auch Text nennen, es spielt keine

79
00:04:39,250 --> 00:04:42,240
‫Rolle, es zählt nur, dass es das zweite Argument

80
00:04:42,240 --> 00:04:43,713
‫in dieser Callback-Funktion ist.

81
00:04:44,670 --> 00:04:47,070
‫Kommen wir zurück zu den

82
00:04:47,070 --> 00:04:49,740
‫Daten, denn das gefällt mir besser.

83
00:04:49,740 --> 00:04:54,740
‫Und so, nur dann, diese Konsole. log wird mit den Daten ausgeführt, also

84
00:04:54,900 --> 00:04:57,510
‫mit dem Text, der in der Datei enthalten war.

85
00:04:57,510 --> 00:05:01,480
‫Deshalb sehen wir dies hier als zweites Protokoll.

86
00:05:01,480 --> 00:05:04,430
‫Nun gut, um es noch weiter

87
00:05:04,430 --> 00:05:08,860
‫zu treiben, lassen Sie uns tatsächlich eine weitere Lesedatei erstellen, aber

88
00:05:08,860 --> 00:05:11,990
‫stattdessen, damit ich Ihnen zeigen kann, dass

89
00:05:11,990 --> 00:05:16,130
‫wir mit Rückrufen im Grunde mehrere Schritte nacheinander ausführen können.

90
00:05:16,130 --> 00:05:20,810
‫Also Schritte, die vom Ergebnis des vorherigen Schrittes abhängen.

91
00:05:20,810 --> 00:05:25,310
‫Okay, deshalb habe ich das eigentlich in der Startdatei gelesen,

92
00:05:25,310 --> 00:05:26,610
‫denn dann

93
00:05:26,610 --> 00:05:29,930
‫gibt es eine Datei namens read this, die

94
00:05:29,930 --> 00:05:33,103
‫den Inhalt hat, der uns eigentlich interessiert.

95
00:05:34,090 --> 00:05:34,923
‫Okay?

96
00:05:37,060 --> 00:05:39,963
‫Also, was ich hier tun werde, ist diesen Code

97
00:05:40,890 --> 00:05:42,793
‫zu kopieren und hier einzufügen.

98
00:05:44,740 --> 00:05:48,210
‫Ich nenne dies Daten eins und dann Daten

99
00:05:48,210 --> 00:05:52,900
‫zwei, und das Ergebnis des zweiten Schritts, also die zweite gelesene Datei,

100
00:05:52,900 --> 00:05:55,140
‫hängt von der ersten ab.

101
00:05:55,140 --> 00:06:00,140
‫Das liegt daran, dass wir die Daten für den Dateinamen verwenden, erinnern Sie sich?

102
00:06:02,030 --> 00:06:05,340
‫Also, hier machen wir jetzt a (murmelt),

103
00:06:06,290 --> 00:06:10,730
‫weil wir diese Variable eingeben müssen, und sie heißt data

104
00:06:14,490 --> 00:06:15,323
‫one.

105
00:06:16,330 --> 00:06:18,290
‫Okay, sinnvoll?

106
00:06:18,290 --> 00:06:22,900
‫Also, Daten 1 wird gelesen, okay, und dann lesen wir

107
00:06:22,900 --> 00:06:27,900
‫im nächsten Schritt txt/readthis. txt, das ist

108
00:06:30,090 --> 00:06:31,910
‫dann diese.

109
00:06:31,910 --> 00:06:35,110
‫Okay, und deshalb ist dieser Dateiname hier

110
00:06:35,110 --> 00:06:37,053
‫derselbe wie dieser Inhalt.

111
00:06:39,340 --> 00:06:42,283
‫Und das wird durch Konsolendaten dazu protokolliert.

112
00:06:43,310 --> 00:06:45,833
‫Und lassen Sie uns schnell testen, ob dies funktioniert, und

113
00:06:48,370 --> 00:06:53,370
‫das ist tatsächlich der Inhalt von Lesen Sie dies. TXT.

114
00:06:53,860 --> 00:06:57,030
‫Und jetzt gehe ich tatsächlich noch einen Schritt weiter,

115
00:06:57,030 --> 00:07:00,740
‫auch weil es in dieser Append-Datei noch anderen Text gibt,

116
00:07:00,740 --> 00:07:04,080
‫den ich dieser ersten Zeichenfolge hinzufügen möchte, also kommt

117
00:07:04,080 --> 00:07:06,420
‫Text aus der anderen Datei.

118
00:07:06,420 --> 00:07:08,590
‫Und so haben wir noch

119
00:07:08,590 --> 00:07:10,840
‫einen weiteren Schritt, der vom vorherigen

120
00:07:10,840 --> 00:07:14,563
‫Schritt abhängt, also füge ich hier eine weitere Lesedatei hinzu.

121
00:07:15,560 --> 00:07:17,660
‫Also einfach so.

122
00:07:17,660 --> 00:07:19,313
‫Also, dieser hier heißt

123
00:07:21,610 --> 00:07:26,610
‫append, und ich nenne diesen hier die Daten drei, hier die Daten drei,

124
00:07:27,720 --> 00:07:30,133
‫und das ist wieder das Ausführen.

125
00:07:32,760 --> 00:07:37,570
‫Und, okay, jetzt haben wir also diese beiden Ergebnisse hier.

126
00:07:37,570 --> 00:07:40,830
‫Okay, und jetzt endlich, als letzten Schritt,

127
00:07:40,830 --> 00:07:44,030
‫möchte ich diese beiden Strings zusammen in

128
00:07:44,030 --> 00:07:46,360
‫eine Datei schreiben, okay?

129
00:07:46,360 --> 00:07:48,500
‫Bisher haben wir nur Dateien

130
00:07:48,500 --> 00:07:51,160
‫gelesen, aber ich möchte auch eine Datei

131
00:07:51,160 --> 00:07:53,730
‫schreiben, also machen wir das auch hier.

132
00:07:53,730 --> 00:07:54,623
‫Also, fs.

133
00:07:57,480 --> 00:08:01,100
‫writeFile, und natürlich verwenden wir nicht die

134
00:08:01,100 --> 00:08:02,140
‫synchrone Version

135
00:08:02,140 --> 00:08:06,320
‫wie zuvor, sondern wie hier und hier und hier

136
00:08:06,320 --> 00:08:10,113
‫verwenden wir die asynchrone Version, nicht die synchrone.

137
00:08:11,600 --> 00:08:20,143
‫Also, TXT-Schrägstrich, fehlt dieser hier, endgültig.

138
00:08:22,314 --> 00:08:25,933
‫Dann sollten wir auch hier die Textcodierung hinzufügen, und dann

139
00:08:29,650 --> 00:08:33,040
‫akzeptiert diese auch eine Callback-Funktion, aber in diesem Fall

140
00:08:33,040 --> 00:08:36,220
‫gibt es keine Daten, die wir lesen, und daher

141
00:08:36,220 --> 00:08:38,370
‫brauchen wir keine zwei Argumente.

142
00:08:38,370 --> 00:08:41,933
‫Das einzige Argument, das wir haben, ist der Fehler.

143
00:08:44,100 --> 00:08:48,980
‫Okay, hier haben wir den Fehler und die gelesenen Daten, aber

144
00:08:48,980 --> 00:08:52,270
‫hier in writeFile gibt es keine Daten.

145
00:08:52,270 --> 00:08:56,690
‫Alles, was es gibt oder sein kann, ist ein Fehler, okay?

146
00:08:56,690 --> 00:08:58,530
‫Und tatsächlich fehlt uns

147
00:08:58,530 --> 00:09:03,063
‫hier etwas, was wir eigentlich in die Datei schreiben wollen.

148
00:09:03,910 --> 00:09:06,430
‫Okay, und das ist das

149
00:09:06,430 --> 00:09:11,100
‫zweite Argument, und das sind Daten zwei und Daten drei.

150
00:09:11,100 --> 00:09:12,823
‫Also hier wieder

151
00:09:14,340 --> 00:09:16,063
‫eine (murmelnde) Zeichenfolge,

152
00:09:17,620 --> 00:09:21,323
‫Daten zwei, dann ein Zeilenumbruchzeichen, das wiederum Backslash

153
00:09:23,010 --> 00:09:25,523
‫n ist, und dann Daten 3.

154
00:09:27,360 --> 00:09:32,010
‫In Ordnung, und so, genau wie bei den Funktionen zum Lesen von Dateien,

155
00:09:32,010 --> 00:09:35,800
‫wird dieser Callback am Ende ausgeführt. Ich werde hier also einfach

156
00:09:35,800 --> 00:09:38,660
‫über die Konsole protokollieren, dass die Dateien geschrieben

157
00:09:38,660 --> 00:09:40,613
‫wurden oder dass die Datei

158
00:09:41,490 --> 00:09:43,190
‫vorhanden ist geschrieben worden.

159
00:09:44,430 --> 00:09:49,360
‫Ihre Datei wurde geschrieben, und lassen Sie uns hier

160
00:09:49,360 --> 00:09:53,220
‫einfach ein paar lustige Emojis verwenden, um

161
00:09:53,220 --> 00:09:56,883
‫die Konsole für uns etwas heller

162
00:09:58,300 --> 00:10:03,080
‫zu machen, und ich denke, wir sollten so vorgehen.

163
00:10:03,080 --> 00:10:06,023
‫Löschen wir die Konsole noch einmal, führen Sie sie

164
00:10:07,370 --> 00:10:10,560
‫aus, und wir sehen tatsächlich, dass Ihre Datei geschrieben wurde.

165
00:10:10,560 --> 00:10:11,833
‫Also wirklich?

166
00:10:13,460 --> 00:10:14,990
‫Finale.

167
00:10:14,990 --> 00:10:16,433
‫Ach ja, hier ist es.

168
00:10:18,140 --> 00:10:22,040
‫Das ist also der Read this text

169
00:10:22,040 --> 00:10:27,040
‫und der append text, beide zusammen, beide in derselben Datei.

170
00:10:27,490 --> 00:10:32,490
‫Okay, so führen wir also mehrere Schritte in Bestellungen durch,

171
00:10:33,160 --> 00:10:36,270
‫indem wir Rückruffunktionen verwenden, richtig?

172
00:10:36,270 --> 00:10:40,180
‫Denn stellen Sie sich vor, Sie haben einfach dieselbe Datei gelesen

173
00:10:40,180 --> 00:10:42,490
‫und dann die zweite Datei gelesen,

174
00:10:42,490 --> 00:10:44,060
‫also diese, direkt danach.

175
00:10:44,060 --> 00:10:46,770
‫Nun, wie würden Sie dann auf die

176
00:10:46,770 --> 00:10:49,200
‫Daten des ersten zugreifen, oder?

177
00:10:49,200 --> 00:10:52,420
‫Und so entsteht dieses Muster.

178
00:10:52,420 --> 00:10:53,720
‫Es hat tatsächlich

179
00:10:53,720 --> 00:10:55,930
‫einen eigenen Namen, und ich glaube, ich

180
00:10:55,930 --> 00:10:58,240
‫habe im letzten Video erwähnt, dass es

181
00:10:58,240 --> 00:11:01,490
‫die sogenannte Callback-Hölle ist, und es gibt einige Lösungen, um diesen

182
00:11:01,490 --> 00:11:04,080
‫Code hier lesbarer und verständlicher zu machen, aber

183
00:11:04,080 --> 00:11:07,130
‫das tut es im Moment nicht für dich überhaupt wichtig.

184
00:11:07,130 --> 00:11:10,650
‫Wichtig ist, dass Node JS auf

185
00:11:10,650 --> 00:11:13,480
‫dieser Philosophie der Rückrufe basiert.

186
00:11:13,480 --> 00:11:17,530
‫So implementiert Node JS asynchrone Operationen, indem

187
00:11:17,530 --> 00:11:20,330
‫es Callbacks aufruft, sobald

188
00:11:20,330 --> 00:11:23,260
‫die ausgeführte Operation abgeschlossen ist.

189
00:11:23,260 --> 00:11:26,280
‫Und übrigens, diese Schreibweise, die Sie

190
00:11:26,280 --> 00:11:28,110
‫hier sehen, ist, falls

191
00:11:28,110 --> 00:11:29,870
‫Sie damit nicht

192
00:11:29,870 --> 00:11:33,420
‫vertraut sind, auch die neue ES6-Syntax, okay?

193
00:11:33,420 --> 00:11:36,320
‫Ich hoffe also, dass Sie an dieser

194
00:11:36,320 --> 00:11:38,550
‫Stelle mit ES6 vertraut sind

195
00:11:38,550 --> 00:11:41,950
‫und dass dies alles für Sie völlig sinnvoll ist.

196
00:11:41,950 --> 00:11:44,580
‫Wenn Sie diese Funktion hier

197
00:11:45,700 --> 00:11:49,461
‫ohne die Syntax der Fehlerfunktion schreiben würden,

198
00:11:49,461 --> 00:11:54,461
‫würden wir einfach so machen, Funktion, Fehler, Daten eins und

199
00:11:55,950 --> 00:11:57,600
‫dann so.

200
00:11:57,600 --> 00:11:59,470
‫Das ist also

201
00:11:59,470 --> 00:12:02,210
‫eine normale Funktion, sagen wir eine

202
00:12:02,210 --> 00:12:05,470
‫altmodische Funktion, und die neue Version funktioniert so.

203
00:12:05,470 --> 00:12:09,490
‫Der Unterschied zwischen ihnen ist hauptsächlich die Syntax,

204
00:12:09,490 --> 00:12:12,690
‫aber auch die Tatsache, dass eine

205
00:12:12,690 --> 00:12:14,360
‫Fehlerfunktion, also diese

206
00:12:14,360 --> 00:12:17,070
‫Art von Funktion, kein eigenes

207
00:12:17,070 --> 00:12:20,860
‫Disk-Schlüsselwort erhält, sondern das Disk-Schlüsselwort der Elternfunktion verwendet.

208
00:12:20,860 --> 00:12:24,540
‫Und das nennt man das lexikalische Disk-Schlüsselwort,

209
00:12:24,540 --> 00:12:27,500
‫während eine normale Funktion wie

210
00:12:27,500 --> 00:12:30,920
‫diese immer ihr eigenes Disk-Schlüsselwort bekommt, oder?

211
00:12:30,920 --> 00:12:33,610
‫Ich bin sicher, Sie kennen sich mit solchen

212
00:12:33,610 --> 00:12:37,640
‫Dingen aus, aber machen Sie hier eine kleine Rezension, falls Sie es nicht sind.

213
00:12:37,640 --> 00:12:39,673
‫Okay, ich hoffe das hat sich da gemacht.

214
00:12:40,600 --> 00:12:44,150
‫Wir haben diesen Fehler eigentlich nie verwendet, wir haben

215
00:12:44,150 --> 00:12:46,160
‫keine Fehler behandelt, also stellen

216
00:12:46,160 --> 00:12:50,060
‫Sie sich zum Beispiel vor, dass diese Datei hier nicht existiert.

217
00:12:50,060 --> 00:12:52,490
‫Nun, wir hätten diesen Fehler verwenden können,

218
00:12:52,490 --> 00:12:56,300
‫und das machen wir tatsächlich, aber nur für diesen hier, also

219
00:12:56,300 --> 00:13:00,820
‫möchte ich nicht alle diese Fehlerhandler hier erstellen, sondern nur in dieser Situation,

220
00:13:00,820 --> 00:13:04,100
‫sagen wir, es ist ein Fehler aufgetreten, und so

221
00:13:04,100 --> 00:13:06,463
‫Sagen wir, wenn Fehler, die Rückkehr

222
00:13:07,340 --> 00:13:10,373
‫von dieser Funktion, also nichts anderes tun, und

223
00:13:12,290 --> 00:13:13,743
‫sich an der

224
00:13:18,050 --> 00:13:22,260
‫Konsole anmelden, Fehler, und dann können wir hier einige andere Emojis hinzufügen,

225
00:13:22,260 --> 00:13:25,653
‫wie diese Explosion, also etwas, das hier explodiert ist.

226
00:13:28,010 --> 00:13:32,933
‫Also, lass uns das jetzt hier ändern, wie start. txt, führen Sie dies erneut aus,

227
00:13:33,900 --> 00:13:34,973
‫und so

228
00:13:36,090 --> 00:13:39,980
‫haben wir jetzt diesen Fehler, also gibt es uns dieses

229
00:13:39,980 --> 00:13:42,570
‫Protokoll an die Konsole, und da wir

230
00:13:42,570 --> 00:13:46,200
‫zurückgekehrt sind, wird es danach nichts mehr tun, also wird

231
00:13:46,200 --> 00:13:49,990
‫all dies im Grunde ignoriert und wird nicht ausgeführt ,

232
00:13:49,990 --> 00:13:51,823
‫genau das wollen wir.

233
00:13:52,680 --> 00:13:55,863
‫Richtig, aber wenn wir es wieder normalisieren

234
00:13:57,720 --> 00:13:59,090
‫und dann

235
00:13:59,090 --> 00:14:02,010
‫erneut ausführen, dann funktioniert alles wie zuvor.

236
00:14:02,010 --> 00:14:05,270
‫Gewöhnen Sie sich also an dieses Muster von Rückrufen,

237
00:14:05,270 --> 00:14:08,270
‫denn Sie werden es überall in Node JS

238
00:14:08,270 --> 00:14:10,163
‫und in diesem Abschnitt sehen.

