﻿1
00:00:01,210 --> 00:00:04,370
‫Kursleiter: In dieser Vorlesung implementieren wir eine bessere

2
00:00:04,370 --> 00:00:07,853
‫Methode zum Abfangen von Fehlern in all unseren asynchronen Funktionen.

3
00:00:09,310 --> 00:00:12,180
‫Im Moment haben wir also

4
00:00:12,180 --> 00:00:15,750
‫in all unseren asynchronen Funktionen diese try-Catch-Blöcke, oder?

5
00:00:15,750 --> 00:00:20,430
‫Denken Sie also daran, wie wir all diesen Handle-Funktionen diesen try-

6
00:00:20,430 --> 00:00:23,930
‫und dann diesen catch-Block hinzugefügt haben, okay?

7
00:00:23,930 --> 00:00:26,430
‫Und das haben sie alle, weil es

8
00:00:26,430 --> 00:00:28,900
‫sich bei allen um asynchrone Funktionen handelt,

9
00:00:28,900 --> 00:00:31,930
‫und so fangen wir normalerweise die Fehler innerhalb

10
00:00:31,930 --> 00:00:33,863
‫einer asynchronen Funktion ab.

11
00:00:34,800 --> 00:00:37,100
‫Verwenden Sie also einen try-catch-Block.

12
00:00:37,100 --> 00:00:41,170
‫Das lässt unseren Code nun wirklich unordentlich und unkonzentriert aussehen, so

13
00:00:41,170 --> 00:00:44,740
‫dass das Ziel dieser createTour-Methode hier beispielsweise darin besteht,

14
00:00:44,740 --> 00:00:46,560
‫diesen Code einfach auszuführen.

15
00:00:46,560 --> 00:00:48,500
‫Wir wollen hier eigentlich nicht

16
00:00:48,500 --> 00:00:49,934
‫mit der Fehlerbehandlung

17
00:00:49,934 --> 00:00:53,450
‫herumspielen, also haben wir im Moment diese zwei zusätzlichen

18
00:00:53,450 --> 00:00:55,690
‫Blöcke, try and catch, und damit

19
00:00:55,690 --> 00:00:57,900
‫kommt diese zusätzliche Einrückung hier und

20
00:00:57,900 --> 00:01:01,730
‫so wieder, dies lässt unseren Code wirklich nicht sauber aussehen.

21
00:01:01,730 --> 00:01:03,550
‫Es ist wirklich nicht fokussiert.

22
00:01:03,550 --> 00:01:05,940
‫Außerdem haben wir hier viel doppelten Code,

23
00:01:05,940 --> 00:01:07,830
‫da wir in jedem

24
00:01:07,830 --> 00:01:10,310
‫dieser Handler einen ziemlich ähnlichen catch-Block haben.

25
00:01:10,310 --> 00:01:12,250
‫Alles, was wir bei all

26
00:01:12,250 --> 00:01:14,690
‫dem tun, ist, diese Antwort zu senden.

27
00:01:14,690 --> 00:01:17,490
‫Und diese Antwort würde tatsächlich nicht einmal hierher gesendet,

28
00:01:17,490 --> 00:01:20,900
‫sondern stattdessen in unserer globalen Middleware zur Fehlerbehandlung, denken Sie daran,

29
00:01:20,900 --> 00:01:23,010
‫aber das ist ein anderes Thema.

30
00:01:23,010 --> 00:01:24,910
‫Im Moment versuche ich

31
00:01:24,910 --> 00:01:27,170
‫mich hier darauf zu konzentrieren, dass

32
00:01:27,170 --> 00:01:30,840
‫diese Try-Catch-Blöcke in jeder unserer asynchronen Funktionen nicht ideal sind,

33
00:01:30,840 --> 00:01:34,010
‫und lassen Sie uns nun versuchen, das zu beheben.

34
00:01:34,010 --> 00:01:37,100
‫Und die Lösung besteht darin, den try-catch-Block im Grunde hier

35
00:01:37,100 --> 00:01:39,890
‫herauszunehmen und in einer anderen Funktion auf eine

36
00:01:39,890 --> 00:01:41,450
‫höhere Ebene zu stellen.

37
00:01:41,450 --> 00:01:43,000
‫Im Grunde werden wir

38
00:01:43,000 --> 00:01:44,470
‫also eine

39
00:01:44,470 --> 00:01:49,326
‫Funktion erstellen und diese asynchrone Funktion dann in diese Funktion einschließen.

40
00:01:49,326 --> 00:01:50,630
‫Gut?

41
00:01:50,630 --> 00:01:53,333
‫Lassen Sie mich das also catchAsync nennen.

42
00:01:56,960 --> 00:02:00,290
‫Also catchAsync, und ich nenne es so, weil

43
00:02:00,290 --> 00:02:02,380
‫das Ziel dieser Funktion

44
00:02:02,380 --> 00:02:05,410
‫darin besteht, einfach unsere asynchronen Fehler abzufangen.

45
00:02:05,410 --> 00:02:06,613
‫So einfach, oder?

46
00:02:07,500 --> 00:02:09,840
‫In diese catchAsync-Funktion

47
00:02:09,840 --> 00:02:13,660
‫werden wir also eine Funktion übergeben, okay?

48
00:02:13,660 --> 00:02:16,820
‫Und denken Sie daran, die Funktion, die wir übergeben

49
00:02:16,820 --> 00:02:19,030
‫werden, ist im Grunde diese.

50
00:02:19,030 --> 00:02:21,678
‫Nun, da wir mit diesem Beispiel

51
00:02:21,678 --> 00:02:25,420
‫arbeiten, ist die Funktion, die wir an catchAsync übergeben,

52
00:02:25,420 --> 00:02:27,840
‫diese Funktion, da wir hier die

53
00:02:27,840 --> 00:02:30,033
‫asynchronen Fehler abfangen möchten.

54
00:02:31,030 --> 00:02:32,563
‫Also lass uns das tatsächlich tun.

55
00:02:34,090 --> 00:02:39,090
‫Also fn, und packen Sie dann die gesamte Funktion dort ein.

56
00:02:40,950 --> 00:02:43,340
‫Als nächstes müssen wir diese

57
00:02:43,340 --> 00:02:45,440
‫Funktion hier tatsächlich aufrufen.

58
00:02:46,670 --> 00:02:49,640
‫Rufen Sie es also auf, und diese

59
00:02:49,640 --> 00:02:53,810
‫Funktion sollte eine Anfrage, eine Antwort und tatsächlich auch als nächstes erhalten.

60
00:02:53,810 --> 00:02:57,440
‫Dieser hier sollte also eigentlich auch next haben und

61
00:02:57,440 --> 00:02:58,860
‫alle anderen

62
00:02:58,860 --> 00:03:01,260
‫auch, denn denken Sie daran, wir

63
00:03:01,260 --> 00:03:03,540
‫brauchen die next-Funktion, um den Fehler

64
00:03:03,540 --> 00:03:05,660
‫hineinzureichen, damit dieser Fehler dann

65
00:03:05,660 --> 00:03:08,470
‫in der globalen Fehlerbehandlungs-Middleware behandelt werden kann.

66
00:03:08,470 --> 00:03:10,360
‫Alle diese Funktionen benötigen also eine Anfrage,

67
00:03:10,360 --> 00:03:12,063
‫eine Antwort und so weiter.

68
00:03:12,950 --> 00:03:14,540
‫Aber lassen wir das für später.

69
00:03:14,540 --> 00:03:17,090
‫Konzentrieren wir uns hier vorerst wirklich auf unser catchAsync.

70
00:03:19,180 --> 00:03:22,120
‫Diese Funktion hier, die wir an async übergeben haben,

71
00:03:22,120 --> 00:03:24,290
‫die jetzt hier oben fn heißt, ist

72
00:03:24,290 --> 00:03:26,040
‫also eine asynchrone Funktion.

73
00:03:26,040 --> 00:03:28,080
‫Und denken Sie daran,

74
00:03:28,080 --> 00:03:30,490
‫dass asynchrone Funktionen Versprechen zurückgeben, oder?

75
00:03:30,490 --> 00:03:33,500
‫Und wenn innerhalb einer asynchronen Funktion ein

76
00:03:33,500 --> 00:03:37,310
‫Fehler auftritt, bedeutet dies im Grunde, dass die Zusage abgelehnt wird.

77
00:03:37,310 --> 00:03:40,160
‫Und hier oben, wo wir diese Funktion tatsächlich aufrufen, können

78
00:03:40,160 --> 00:03:41,893
‫wir dann diesen Fehler abfangen.

79
00:03:43,790 --> 00:03:46,040
‫Also fangen wir es hier

80
00:03:46,040 --> 00:03:48,590
‫ab, anstatt es im try-catch-Block zu fangen.

81
00:03:48,590 --> 00:03:53,590
‫Also catch und error und dann weiter und übergeben Sie den Fehler.

82
00:03:57,040 --> 00:03:58,160
‫Und wir

83
00:03:58,160 --> 00:04:01,810
‫können dies vereinfachen, aber jetzt entfernen wir den try-catch-Block

84
00:04:01,810 --> 00:04:05,103
‫hier und konzentrieren uns einfach auf dieses Stück.

85
00:04:07,580 --> 00:04:08,920
‫Das ist also

86
00:04:08,920 --> 00:04:12,110
‫alles, was wir wollen, und wir brauchen den try-catch-Block

87
00:04:12,110 --> 00:04:15,660
‫nicht mehr, weil dieser Catch jetzt im Grunde hierher übertragen

88
00:04:15,660 --> 00:04:17,113
‫wird, in diese Zeile.

89
00:04:18,500 --> 00:04:20,350
‫Es ist kein Catch-Block

90
00:04:20,350 --> 00:04:22,560
‫mehr, weil es hier einfach einfacher

91
00:04:22,560 --> 00:04:26,060
‫ist, das Versprechen zu verwenden, dass die fn-Funktion zurückgibt.

92
00:04:26,060 --> 00:04:29,640
‫Diese fn-Funktion ist also wieder diese Funktion, also diejenige,

93
00:04:29,640 --> 00:04:32,270
‫die wir an catchAsync übergeben haben, und

94
00:04:32,270 --> 00:04:34,650
‫die wird ein Versprechen zurückgeben.

95
00:04:34,650 --> 00:04:37,100
‫Und tatsächlich ist mir hier aufgefallen,

96
00:04:37,100 --> 00:04:40,110
‫dass das natürlich catchAsync heißen sollte, in Ordnung?

97
00:04:40,110 --> 00:04:41,800
‫Und dann ist diese

98
00:04:41,800 --> 00:04:45,447
‫Funktion, die wir an catchAsync übergeben haben, natürlich fn.

99
00:04:45,447 --> 00:04:46,280
‫Gut?

100
00:04:46,280 --> 00:04:48,980
‫Also das Argument, das wir da reingereicht haben.

101
00:04:48,980 --> 00:04:51,590
‫Nun, es gibt tatsächlich zwei große Probleme mit

102
00:04:51,590 --> 00:04:54,180
‫der Art und Weise, wie dies derzeit

103
00:04:54,180 --> 00:04:57,240
‫implementiert wird, und so würde es überhaupt nicht funktionieren.

104
00:04:57,240 --> 00:04:59,340
‫Der erste Funktionsaufruf hier

105
00:04:59,340 --> 00:05:03,213
‫hat also keine Möglichkeit, Anforderung, Antwort und Nächstes zu kennen.

106
00:05:04,300 --> 00:05:07,460
‫Wir haben sie hier nicht an catchAsync übergeben,

107
00:05:07,460 --> 00:05:09,300
‫und daher hat die

108
00:05:09,300 --> 00:05:12,693
‫Funktion keine Möglichkeit, die Werte dieser Parameter zu kennen.

109
00:05:13,658 --> 00:05:15,610
‫Und zweitens rufen wir

110
00:05:15,610 --> 00:05:18,473
‫hier tatsächlich die asynchrone Funktion auf.

111
00:05:20,290 --> 00:05:22,290
‫Und um dies ein bisschen besser zu sehen, lassen

112
00:05:23,200 --> 00:05:24,873
‫Sie uns diesen Code einfach vollständig loswerden.

113
00:05:26,370 --> 00:05:29,520
‫Hier haben wir also catchAsync und rufen es dann natürlich

114
00:05:29,520 --> 00:05:31,153
‫mit den Klammern auf.

115
00:05:32,350 --> 00:05:34,900
‫Und dann rufen wir innerhalb von catchAsync

116
00:05:34,900 --> 00:05:37,760
‫dann auch gleich die fn-Funktion auf, und

117
00:05:37,760 --> 00:05:40,130
‫so soll das nicht funktionieren.

118
00:05:40,130 --> 00:05:43,060
‫CreateTour sollte hier also eigentlich eine Funktion sein,

119
00:05:43,060 --> 00:05:45,840
‫aber nicht das Ergebnis eines Funktionsaufrufs.

120
00:05:45,840 --> 00:05:47,810
‫Aber genau das passiert gerade.

121
00:05:47,810 --> 00:05:49,940
‫Im Moment wird also

122
00:05:49,940 --> 00:05:54,310
‫catchAsync aufgerufen, das dann diese Funktion hier aufruft, okay?

123
00:05:54,310 --> 00:05:56,890
‫Diese Funktion sollte also nicht aufgerufen

124
00:05:56,890 --> 00:05:59,360
‫werden, sondern hier sitzen und warten,

125
00:05:59,360 --> 00:06:01,460
‫bis Express sie aufruft.

126
00:06:01,460 --> 00:06:03,310
‫Und Express ruft

127
00:06:03,310 --> 00:06:05,400
‫es natürlich an, sobald jemand

128
00:06:05,400 --> 00:06:08,390
‫den Weg einschlägt, der diese Kontrollfunktion benötigt.

129
00:06:08,390 --> 00:06:11,980
‫Die Lösung dafür besteht also darin, die catchAsync-Funktion im

130
00:06:11,980 --> 00:06:15,030
‫Grunde eine andere Funktion zurückgeben zu lassen, die

131
00:06:15,030 --> 00:06:18,060
‫dann createTour zugewiesen wird und diese Funktion

132
00:06:18,060 --> 00:06:19,640
‫dann später bei

133
00:06:19,640 --> 00:06:21,483
‫Bedarf aufgerufen werden kann.

134
00:06:23,294 --> 00:06:24,394
‫Also machen wir das hier.

135
00:06:25,590 --> 00:06:28,480
‫Geben wir also eine anonyme Funktion zurück und

136
00:06:28,480 --> 00:06:30,890
‫denken Sie daran, dass dies die Funktion

137
00:06:30,890 --> 00:06:32,900
‫ist, die Express dann aufruft.

138
00:06:32,900 --> 00:06:35,380
‫Hier spezifizieren wir

139
00:06:35,380 --> 00:06:38,423
‫dann Anfrage, Antwort und Weiter.

140
00:06:41,120 --> 00:06:43,763
‫Hier fehlt tatsächlich der Pfeil.

141
00:06:47,230 --> 00:06:48,480
‫Und alles klar.

142
00:06:48,480 --> 00:06:49,890
‫Und das ist es tatsächlich.

143
00:06:49,890 --> 00:06:52,420
‫Das ist unsere catchAsync-Funktion.

144
00:06:52,420 --> 00:06:54,610
‫Denken Sie daran, wie ich

145
00:06:54,610 --> 00:06:56,840
‫gesagt habe, dass wir es vereinfachen können,

146
00:06:56,840 --> 00:06:59,110
‫und das nur, weil wir es in

147
00:06:59,110 --> 00:07:01,777
‫JavaScript so vereinfachen können, dass wir hier nur die

148
00:07:01,777 --> 00:07:04,020
‫Funktion übergeben müssen, und sie wird dann

149
00:07:04,020 --> 00:07:06,810
‫automatisch mit dem Parameter aufgerufen, den dieser Callback empfängt.

150
00:07:06,810 --> 00:07:09,263
‫Es ist also dasselbe wie beim nächsten Schreiben.

151
00:07:11,500 --> 00:07:13,290
‫Fassen wir also hier zusammen.

152
00:07:13,290 --> 00:07:16,490
‫Um unsere try-catch-Blöcke loszuwerden, haben

153
00:07:16,490 --> 00:07:19,230
‫wir unsere asynchrone Funktion

154
00:07:19,230 --> 00:07:23,010
‫einfach in die soeben erstellte catchAsync-Funktion eingebettet.

155
00:07:23,010 --> 00:07:26,160
‫Diese Funktion gibt dann eine neue anonyme

156
00:07:26,160 --> 00:07:27,690
‫Funktion zurück,

157
00:07:27,690 --> 00:07:31,660
‫nämlich diese hier, die dann createTour zugewiesen wird.

158
00:07:31,660 --> 00:07:34,200
‫Im Grunde ist es diese

159
00:07:34,200 --> 00:07:36,940
‫Funktion hier, die aufgerufen wird, sobald eine

160
00:07:36,940 --> 00:07:40,010
‫neue Tour mit dem createTour-Handler erstellt werden soll.

161
00:07:40,010 --> 00:07:42,960
‫Aus diesem Grund hat es hier genau

162
00:07:42,960 --> 00:07:47,520
‫dieselbe Signatur wie diese asynchrone Funktion, mit Anfrage, Antwort und Weiter.

163
00:07:47,520 --> 00:07:49,740
‫Diese Funktion hier wird nun

164
00:07:49,740 --> 00:07:51,320
‫die Funktion aufrufen, die

165
00:07:51,320 --> 00:07:53,440
‫wir ursprünglich übergeben haben, also

166
00:07:53,440 --> 00:07:54,990
‫diese hier,

167
00:07:54,990 --> 00:07:58,270
‫und dann den gesamten darin enthaltenen Code ausführen.

168
00:07:58,270 --> 00:08:00,670
‫Da es sich hier um eine

169
00:08:00,670 --> 00:08:02,380
‫asynchrone Funktion handelt,

170
00:08:02,380 --> 00:08:05,610
‫gibt sie ein Promise zurück. Wenn also in diesem

171
00:08:05,610 --> 00:08:08,400
‫Promise ein Fehler auftritt oder mit anderen

172
00:08:08,400 --> 00:08:11,090
‫Worten, falls es abgelehnt wird, können wir

173
00:08:11,090 --> 00:08:15,193
‫den aufgetretenen Fehler mit der catch-Methode abfangen auf alle Versprechen verfügbar.

174
00:08:16,560 --> 00:08:19,510
‫Und am Ende ist es diese Catch-Methode

175
00:08:19,510 --> 00:08:22,670
‫hier, die den Fehler an die nächste Funktion

176
00:08:22,670 --> 00:08:24,780
‫weiterleitet, die es dann so

177
00:08:24,780 --> 00:08:27,943
‫macht, dass unser Fehler in unserer globalen Fehlerbehandlungs-Middleware landet.

178
00:08:28,890 --> 00:08:31,020
‫Hier, in dieser Codezeile, passiert also

179
00:08:31,020 --> 00:08:33,510
‫wirklich die ganze Magie, und das ist

180
00:08:33,510 --> 00:08:35,440
‫es tatsächlich, was es

181
00:08:35,440 --> 00:08:38,893
‫uns ermöglicht, den Catch-Block loszuwerden, den wir zuvor hatten.

182
00:08:39,770 --> 00:08:40,603
‫Und eine

183
00:08:40,603 --> 00:08:43,710
‫Anmerkung: Es ist ziemlich kompliziert, den Kopf zu drehen,

184
00:08:43,710 --> 00:08:46,460
‫und falls es nicht 100% klar ist, keine

185
00:08:46,460 --> 00:08:48,943
‫Sorge, es ist nicht so wichtig.

186
00:08:49,792 --> 00:08:53,010
‫Hier geht es wirklich nur darum herauszufinden, wie

187
00:08:53,010 --> 00:08:56,460
‫genau asynchroner Code hinter den Kulissen in JavaScript funktioniert.

188
00:08:56,460 --> 00:09:00,100
‫Es geht also nicht so sehr um Express oder Node. js, hier geht

189
00:09:00,100 --> 00:09:04,060
‫es mehr um die Funktionsweise von asynchronem Code.

190
00:09:04,060 --> 00:09:06,560
‫Wie auch immer, wenn wir jetzt

191
00:09:06,560 --> 00:09:08,040
‫eine neue

192
00:09:08,040 --> 00:09:10,440
‫Tour erstellen und ein Fehler

193
00:09:10,440 --> 00:09:13,450
‫auftritt, zum Beispiel durch eine ungültige Eingabe,

194
00:09:13,450 --> 00:09:15,120
‫dann sollte dieser Fehler

195
00:09:15,120 --> 00:09:18,270
‫natürlich hier in dieser Fangfunktion abgefangen werden und

196
00:09:18,270 --> 00:09:21,870
‫wird dann an unsere Fehlerbehandlungs-Middleware weitergegeben und damit one

197
00:09:21,870 --> 00:09:24,570
‫sendet dann die erwartete Fehlerantwort zurück.

198
00:09:24,570 --> 00:09:26,973
‫Und das probieren wir jetzt mal aus.

199
00:09:28,080 --> 00:09:30,500
‫Erstellen Sie also eine neue Tour.

200
00:09:30,500 --> 00:09:32,030
‫Hier haben wir den

201
00:09:32,030 --> 00:09:35,223
‫Körper, und lassen Sie uns nun eines dieser erforderlichen Felder loswerden.

202
00:09:36,440 --> 00:09:37,273
‫Gut.

203
00:09:37,273 --> 00:09:40,223
‫Das sollte also einen Fehler auslösen, also mal sehen.

204
00:09:41,220 --> 00:09:44,920
‫Und tatsächlich ist unsere Tourvalidierung fehlgeschlagen, was genau

205
00:09:44,920 --> 00:09:46,910
‫die Fehlermeldung ist,

206
00:09:46,910 --> 00:09:49,090
‫die wir erhalten sollten.

207
00:09:49,090 --> 00:09:53,220
‫Hier sehen Sie nun diesen 500 Internal Server Error, der

208
00:09:53,220 --> 00:09:55,710
‫einfach darauf zurückzuführen ist, dass für

209
00:09:55,710 --> 00:09:57,500
‫den Fehler, der an

210
00:09:57,500 --> 00:09:59,280
‫die Fehlerbehandlungs-Middleware weitergegeben

211
00:09:59,280 --> 00:10:02,110
‫wurde, kein Statuscode angegeben wurde. Denken Sie

212
00:10:02,110 --> 00:10:05,190
‫also daran, dass unser Standardwert 500 ist,

213
00:10:05,190 --> 00:10:08,310
‫und das ist es das wurde dann zurückgeschickt.

214
00:10:08,310 --> 00:10:10,060
‫Und das müssen wir natürlich korrigieren,

215
00:10:10,060 --> 00:10:13,173
‫und das werden wir in einer späteren Vorlesung in diesem Kurs tun.

216
00:10:14,730 --> 00:10:17,030
‫Im Moment ist es wichtig,

217
00:10:17,030 --> 00:10:20,420
‫dass unsere Funktion catchAsync wie beabsichtigt funktioniert und zweitens

218
00:10:20,420 --> 00:10:23,700
‫der Fehler tatsächlich weitergegeben wurde, sodass er von

219
00:10:23,700 --> 00:10:26,900
‫unserer globalen Middleware zur Fehlerbehandlung abgefangen wurde,

220
00:10:26,900 --> 00:10:30,223
‫die diese Antwort dann an den Client zurücksendete.

221
00:10:32,520 --> 00:10:35,360
‫Lassen Sie uns nun diese Fangfunktion

222
00:10:35,360 --> 00:10:38,010
‫in eine eigene Datei exportieren.

223
00:10:38,010 --> 00:10:39,950
‫Also greife ich es von

224
00:10:39,950 --> 00:10:42,200
‫hier und erstelle nur eine weitere

225
00:10:42,200 --> 00:10:43,843
‫Datei in unserem Dienstprogrammordner.

226
00:10:47,060 --> 00:10:51,123
‫Also catchAsync. js.

227
00:10:55,470 --> 00:11:00,470
‫Und hier, Modul. Exporte sollten genau das sein.

228
00:11:04,650 --> 00:11:09,450
‫Und damit sollte das problemlos funktionieren.

229
00:11:09,450 --> 00:11:11,340
‫Zurück in unserem Tourcontroller müssen

230
00:11:11,340 --> 00:11:13,373
‫wir diese Funktion nun natürlich importieren.

231
00:11:18,970 --> 00:11:21,840
‫Und wie üblich müssen wir einen Ordner

232
00:11:22,840 --> 00:11:25,690
‫nach oben gehen und dann in unseren

233
00:11:25,690 --> 00:11:27,733
‫Dienstprogramme-Ordner und dann catchAsync.

234
00:11:30,810 --> 00:11:32,840
‫Alles klar, und

235
00:11:32,840 --> 00:11:36,080
‫jetzt müssen wir nur noch all

236
00:11:36,080 --> 00:11:40,593
‫diese catch-Blöcke loswerden und alle Handler in catchAsync einschließen.

237
00:11:42,210 --> 00:11:43,793
‫Also machen wir das.

238
00:11:47,610 --> 00:11:52,610
‫Führen Sie zuerst die Verpackung durch und entfernen Sie dann diese Blöcke.

239
00:11:57,030 --> 00:12:00,220
‫Speichern Sie es, um es neu zu formatieren, und los geht's.

240
00:12:00,220 --> 00:12:03,310
‫Und jetzt ist es einfach ein Prozess,

241
00:12:03,310 --> 00:12:06,821
‫dies zu wiederholen, bis alle Touren oder, sorry,

242
00:12:06,821 --> 00:12:09,633
‫bis alle Handler fertig sind.

243
00:12:13,070 --> 00:12:14,760
‫Okay, schnell speichern.

244
00:12:14,760 --> 00:12:16,740
‫Dieser ist bereits fertig.

245
00:12:16,740 --> 00:12:18,763
‫Als nächstes steht ein Update an.

246
00:12:26,920 --> 00:12:28,483
‫Und nur noch einer fehlt.

247
00:12:36,380 --> 00:12:37,870
‫Oder eigentlich stimmt das nicht.

248
00:12:37,870 --> 00:12:40,403
‫Da unten haben wir noch mehr Async-Funktionen.

249
00:12:52,530 --> 00:12:57,203
‫Also werden wir den Fang und den Versuch hier los.

250
00:12:59,150 --> 00:13:01,100
‫Und ich glaube, dieser ist der letzte.

251
00:13:04,020 --> 00:13:05,483
‫Und ja, das ist es tatsächlich.

252
00:13:12,390 --> 00:13:15,000
‫In Ordnung, jetzt müssen

253
00:13:15,000 --> 00:13:19,040
‫wir auch noch neben allen hier hinzufügen.

254
00:13:19,040 --> 00:13:20,793
‫Aber natürlich nicht in Großbuchstaben.

255
00:13:21,690 --> 00:13:22,960
‫Okay.

256
00:13:22,960 --> 00:13:25,480
‫Und lassen Sie mich hier eigentlich alle auswählen,

257
00:13:28,170 --> 00:13:30,683
‫damit ich es nur einmal schreiben muss.

258
00:13:33,140 --> 00:13:35,943
‫Und das fügte es allen hinzu.

259
00:13:38,390 --> 00:13:42,063
‫Und jetzt denke ich, dass wir mit diesem Teil fertig sind.

260
00:13:43,270 --> 00:13:46,310
‫Lass es uns noch einmal ganz schnell testen, nicht

261
00:13:46,310 --> 00:13:48,733
‫mit diesem, aber hier mit, auch nicht mit

262
00:13:49,950 --> 00:13:52,000
‫diesem, also sind wir fertig.

263
00:13:55,330 --> 00:13:57,140
‫Und ich werde versuchen, eine

264
00:13:57,140 --> 00:14:01,870
‫Tour zu bekommen, aber mit einem ungültigen Ausweis, also mal sehen, was hier passiert.

265
00:14:01,870 --> 00:14:04,250
‫Und tatsächlich bekommen wir unsere Fehlermeldung und

266
00:14:04,250 --> 00:14:06,950
‫wieder den 500er Statuscode, was nicht korrekt

267
00:14:06,950 --> 00:14:08,640
‫ist, denk dran, aber

268
00:14:08,640 --> 00:14:10,050
‫darum kümmern wir

269
00:14:10,050 --> 00:14:11,930
‫uns zu einem späteren Zeitpunkt.

270
00:14:11,930 --> 00:14:15,130
‫Lassen Sie mich Ihnen jetzt zeigen, dass

271
00:14:15,130 --> 00:14:19,920
‫hier die 500 herkommen, denn im Moment gibt es keinen Statuscode

272
00:14:19,920 --> 00:14:22,200
‫in dem Fehler, den wir

273
00:14:22,200 --> 00:14:24,310
‫erhalten, weil diese Fehler

274
00:14:24,310 --> 00:14:27,940
‫tatsächlich von Mungo kommen und wir daher keine

275
00:14:27,940 --> 00:14:29,730
‫Möglichkeit haben, einen

276
00:14:29,730 --> 00:14:32,390
‫Status hinzuzufügen Code für diese Fehler.

277
00:14:32,390 --> 00:14:35,370
‫Oder wir könnten es natürlich auch tun, aber das

278
00:14:35,370 --> 00:14:37,950
‫wäre nur noch verwirrender und deshalb werden

279
00:14:37,950 --> 00:14:40,330
‫wir später in diesem Abschnitt einen anderen

280
00:14:40,330 --> 00:14:41,443
‫Weg finden.

281
00:14:42,510 --> 00:14:45,840
‫Im Moment bin ich sehr zufrieden mit dem Ergebnis, das wir

282
00:14:45,840 --> 00:14:48,773
‫hier haben, und das war's für diesen Vortrag.

