﻿1
00:00:01,150 --> 00:00:03,310
‫Mann: In diesem Video implementieren wir jetzt

2
00:00:03,310 --> 00:00:06,080
‫die globale Middleware zur Fehlerbehandlung, über die wir

3
00:00:06,080 --> 00:00:07,483
‫gerade gesprochen haben.

4
00:00:09,020 --> 00:00:11,280
‫Denken Sie also daran, dass

5
00:00:11,280 --> 00:00:13,650
‫das Ziel darin besteht, eine Middleware-Funktion zu

6
00:00:13,650 --> 00:00:17,690
‫schreiben, die in der Lage ist, Betriebsfehler wie diesen zu behandeln.

7
00:00:17,690 --> 00:00:22,010
‫Okay, wenn ein Benutzer auf eine URL trifft, die nicht existiert, können

8
00:00:22,010 --> 00:00:24,890
‫wir dies als Betriebsfehler betrachten, und wir behandeln

9
00:00:24,890 --> 00:00:27,590
‫ihn in diesem Fall, indem wir diese

10
00:00:27,590 --> 00:00:29,630
‫Antwort hier zurücksenden, oder?

11
00:00:29,630 --> 00:00:33,320
‫Aber auch hier ist das Ziel, dies an einer zentralen Stelle zu tun.

12
00:00:33,320 --> 00:00:37,200
‫Wir haben zum Beispiel ähnliche Sachen hier oben.

13
00:00:37,200 --> 00:00:39,870
‫Wir haben hier also überall diese Schnipsel,

14
00:00:39,870 --> 00:00:41,950
‫die die Fehler behandeln.

15
00:00:41,950 --> 00:00:45,270
‫Also müssen wir hier den Etch-Block anschlagen, und wenn ein

16
00:00:45,270 --> 00:00:47,460
‫Fehler auftritt, dann behandeln wir ihn,

17
00:00:47,460 --> 00:00:50,083
‫indem wir diesen Fehler an den Client senden.

18
00:00:51,290 --> 00:00:53,520
‫Und so wollen wir das alles

19
00:00:53,520 --> 00:00:56,170
‫am Ende wieder loswerden und den Fehler in

20
00:00:56,170 --> 00:00:57,900
‫einer zentralen Middleware behandeln.

21
00:00:57,900 --> 00:01:00,556
‫Lassen Sie uns nun damit beginnen,

22
00:01:00,556 --> 00:01:02,800
‫diese Middleware-Funktion tatsächlich aufzubauen.

23
00:01:02,800 --> 00:01:05,470
‫Und in Express ist es eigentlich ganz einfach.

24
00:01:05,470 --> 00:01:07,580
‫Denken Sie daran, wie ich Ihnen gesagt

25
00:01:07,580 --> 00:01:09,540
‫habe, dass Express bereits standardmäßig mit

26
00:01:09,540 --> 00:01:10,880
‫Middleware-Handlern ausgestattet ist.

27
00:01:10,880 --> 00:01:15,720
‫Wie immer beginnen wir mit der App. use, okay, und

28
00:01:15,720 --> 00:01:19,210
‫dann definieren wir hier unsere Middleware-Funktion.

29
00:01:19,210 --> 00:01:21,880
‫Um eine Middleware zur Fehlerbehandlung

30
00:01:21,880 --> 00:01:24,870
‫zu definieren, müssen wir der Middleware-Funktion nur

31
00:01:24,870 --> 00:01:27,980
‫vier Argumente geben, und Express erkennt sie

32
00:01:27,980 --> 00:01:30,740
‫dann automatisch als Middleware zur Fehlerbehandlung.

33
00:01:30,740 --> 00:01:33,653
‫Rufen Sie es deshalb nur auf, wenn ein Fehler auftritt.

34
00:01:34,556 --> 00:01:38,220
‫Und genau wie in vielen anderen Fällen ist

35
00:01:38,220 --> 00:01:41,740
‫diese Middleware-Funktion eine Error-First-Funktion, was bedeutet, dass

36
00:01:41,740 --> 00:01:43,330
‫das erste Argument

37
00:01:43,330 --> 00:01:44,483
‫der

38
00:01:45,930 --> 00:01:50,563
‫Fehler ist, und dann haben wir Request, Response und Next.

39
00:01:51,975 --> 00:01:55,280
‫Durch die Angabe von vier Parametern weiß Express also

40
00:01:55,280 --> 00:01:57,750
‫automatisch, dass diese gesamte Funktion hier

41
00:01:57,750 --> 00:02:00,150
‫eine Middleware zur Fehlerbehandlung ist.

42
00:02:00,150 --> 00:02:04,150
‫Lassen Sie uns nun den Code für diese Funktion hier implementieren und

43
00:02:04,150 --> 00:02:06,400
‫danach zeige ich Ihnen, wie wir tatsächlich

44
00:02:06,400 --> 00:02:09,000
‫einen Fehler erzeugen können, damit diese Middleware-Funktion tatsächlich

45
00:02:09,000 --> 00:02:09,930
‫abgefangen wird.

46
00:02:09,930 --> 00:02:13,450
‫Also zwei Schritte, zuerst erstellen wir die Middleware, dann

47
00:02:13,450 --> 00:02:15,130
‫erstellen wir im zweiten

48
00:02:15,130 --> 00:02:18,700
‫Schritt tatsächlich einen Fehler, damit diese Funktion abgefangen wird.

49
00:02:18,700 --> 00:02:20,943
‫Und jetzt halten wir es hier ganz einfach.

50
00:02:20,943 --> 00:02:23,590
‫Um diesen Fehler zu beheben, möchten

51
00:02:23,590 --> 00:02:27,100
‫wir also nur eine Antwort an den Client zurücksenden.

52
00:02:27,100 --> 00:02:29,893
‫Also res. Status, aber jetzt

53
00:02:31,170 --> 00:02:35,100
‫wissen wir nicht wirklich, um welchen Statuscode es sich handelt, oder?

54
00:02:35,100 --> 00:02:38,420
‫In diesem Fall ist es beispielsweise ein 404, aber

55
00:02:38,420 --> 00:02:41,650
‫wir haben hier einige Fehler mit anderen Statuscodes.

56
00:02:41,650 --> 00:02:46,020
‫Wir haben zum Beispiel eine 400 für schlechte Anfragen oder

57
00:02:46,020 --> 00:02:48,823
‫wirklich alle möglichen anderen Codes.

58
00:02:50,903 --> 00:02:53,142
‫Und deshalb wollen wir eigentlich

59
00:02:53,142 --> 00:02:56,113
‫diesen Statuscode aus dem Fehlerobjekt lesen, in Ordnung?

60
00:02:57,480 --> 00:02:59,650
‫Wenn wir diesen Fehler etwas später im

61
00:02:59,650 --> 00:03:01,143
‫zweiten Schritt erstellen, werden

62
00:03:01,143 --> 00:03:04,504
‫wir, wie ich Ihnen bereits sagte, diesen Statuscode für den Fehler definieren.

63
00:03:04,504 --> 00:03:08,943
‫Sagen wir also Statuscode, und jetzt möchte ich hier einen

64
00:03:10,533 --> 00:03:11,962
‫Standard definieren.

65
00:03:11,962 --> 00:03:14,620
‫Weil es Fehler geben wird, die nicht von

66
00:03:14,620 --> 00:03:17,090
‫uns kommen, weil es Fehler ohne Statuscode

67
00:03:17,090 --> 00:03:19,590
‫geben wird, also Fehler, die nicht von

68
00:03:19,590 --> 00:03:22,750
‫uns erstellt werden, sondern zum Beispiel an anderen Stellen

69
00:03:22,750 --> 00:03:24,240
‫in der Notizanwendung.

70
00:03:24,240 --> 00:03:26,640
‫Und ich weiß, das klingt im Moment etwas verwirrend, aber

71
00:03:26,640 --> 00:03:28,770
‫Sie werden es in diesem Abschnitt sehen.

72
00:03:28,770 --> 00:03:31,790
‫Lassen Sie uns diesen Standardstatuscode jetzt wirklich

73
00:03:31,790 --> 00:03:32,623
‫definieren.

74
00:03:33,550 --> 00:03:36,959
‫Also sagen wir, dass der Fehler. statuscode

75
00:03:36,959 --> 00:03:40,446
‫ist gleich err. statuscode im Wesentlichen, wenn

76
00:03:40,446 --> 00:03:45,230
‫er definiert ist oder der Code 500, was wiederum einen internen Serverfehler

77
00:03:45,230 --> 00:03:48,140
‫bedeutet, und das ist normalerweise der Standard,

78
00:03:48,140 --> 00:03:49,763
‫den wir verwenden.

79
00:03:50,660 --> 00:03:54,820
‫Und genauso definieren wir auch den Status, sagen

80
00:03:54,820 --> 00:03:59,820
‫wir also Fehler. Status ist gleich Fehler. Status, wenn es definiert

81
00:04:01,350 --> 00:04:03,713
‫ist, und wenn nicht, ist es

82
00:04:04,670 --> 00:04:05,760
‫ein Fehler.

83
00:04:05,760 --> 00:04:10,120
‫Denken Sie also daran, dass ein Fehler besteht, wenn wir einen 500-Statuscode haben und wenn

84
00:04:10,120 --> 00:04:13,033
‫es ein 400-Statuscode ist, dann ist es ein Fehler.

85
00:04:13,926 --> 00:04:16,723
‫Hier in diesem 404 ist der Status zum Beispiel fehlgeschlagen.

86
00:04:18,597 --> 00:04:20,960
‫Und so können wir

87
00:04:20,960 --> 00:04:25,960
‫das jetzt hier verwenden, also Fehler. statuscode, und senden Sie dann etwas JSON, also sehr

88
00:04:27,100 --> 00:04:29,363
‫ähnlich zu dem, was wir zuvor gemacht haben.

89
00:04:30,320 --> 00:04:34,830
‫Also fangen wir mit dem Status an und lesen den Fehler ab. Status und die

90
00:04:37,010 --> 00:04:40,473
‫Meldung wird auch von dem Fehler kommen.

91
00:04:41,380 --> 00:04:44,970
‫Also irr. Nachricht und ich werde Ihnen in einer

92
00:04:44,970 --> 00:04:48,223
‫Sekunde zeigen, wie das irrt. Message-Eigenschaft wird hier erstellt.

93
00:04:49,750 --> 00:04:52,700
‫In Ordnung, aber im Moment ist dies unsere sehr einfache

94
00:04:52,700 --> 00:04:54,000
‫Middleware zur Fehlerbehandlung.

95
00:04:55,400 --> 00:04:58,190
‫Also ganz einfach, aber im Moment funktioniert es.

96
00:04:58,190 --> 00:05:00,200
‫Und so nun der zweite Schritt, bei dem

97
00:05:00,200 --> 00:05:01,830
‫wir tatsächlich einen Fehler erstellen.

98
00:05:01,830 --> 00:05:03,680
‫Und das machen wir hier.

99
00:05:03,680 --> 00:05:06,270
‫Also genau hier in dieser Funktion, die alle nicht

100
00:05:06,270 --> 00:05:08,820
‫behandelten Routen verarbeitet, also lassen Sie mich

101
00:05:08,820 --> 00:05:11,833
‫diese hier auskommentieren und stattdessen möchten wir einen Fehler erstellen.

102
00:05:12,973 --> 00:05:16,850
‫Sagen wir also const err und

103
00:05:18,080 --> 00:05:21,700
‫es ist ein neuer Fehler.

104
00:05:21,700 --> 00:05:24,840
‫Wir verwenden also grundsätzlich den eingebauten Fehlerkonstruktor, um

105
00:05:24,840 --> 00:05:26,600
‫einen Fehler zu erzeugen.

106
00:05:26,600 --> 00:05:29,320
‫Und jetzt können wir einen String übergeben und

107
00:05:29,320 --> 00:05:31,900
‫dieser String wird dann die Fehlermeldungseigenschaft sein.

108
00:05:31,900 --> 00:05:35,163
‫Also worüber wir gerade hier unten gesprochen haben.

109
00:05:37,350 --> 00:05:40,113
‫Diese Nachricht sollte also diese Nachricht sein.

110
00:05:42,920 --> 00:05:43,753
‫Gut?

111
00:05:45,600 --> 00:05:49,600
‫Und dann sollte es Fehler sagen. Status, der

112
00:05:51,680 --> 00:05:52,693
‫fehlgeschlagen

113
00:05:55,830 --> 00:06:00,450
‫ist, und dann err. statusCode ist gleich 404.

114
00:06:00,450 --> 00:06:03,610
‫Das habe ich bereits erwähnt, dass wir den

115
00:06:03,610 --> 00:06:06,770
‫Statuscode und den Status des Fehlerobjekts definieren können.

116
00:06:06,770 --> 00:06:09,010
‫Und genau das tun wir hier.

117
00:06:09,010 --> 00:06:10,950
‫Wir erstellen einen Fehler und

118
00:06:10,950 --> 00:06:14,220
‫definieren dann die Status- und Statuscode-Eigenschaften, damit unsere

119
00:06:14,220 --> 00:06:15,930
‫Middleware zur Fehlerbehandlung

120
00:06:15,930 --> 00:06:18,150
‫sie im nächsten Schritt verwenden kann.

121
00:06:18,150 --> 00:06:20,840
‫Aber wie lesen wir nun diesen nächsten Schritt eigentlich?

122
00:06:20,840 --> 00:06:23,390
‫Damit die nächste Middleware.

123
00:06:23,390 --> 00:06:26,650
‫Nun, wie immer verwenden wir next.

124
00:06:26,650 --> 00:06:29,430
‫Aber dieses Mal verwenden wir next in besonderer Weise.

125
00:06:29,430 --> 00:06:32,100
‫Denn jetzt müssen wir diesen Fehler tatsächlich

126
00:06:32,100 --> 00:06:35,190
‫an next übergeben. Wenn also die nächste Funktion ein

127
00:06:35,190 --> 00:06:37,460
‫Argument empfängt, egal was es ist,

128
00:06:37,460 --> 00:06:40,680
‫erkennt Express automatisch, dass ein Fehler aufgetreten ist, und

129
00:06:40,680 --> 00:06:43,620
‫nimmt an, dass alles, was wir an next

130
00:06:43,620 --> 00:06:44,950
‫übergeben, ein Error.

131
00:06:44,950 --> 00:06:48,300
‫Und das gilt für jede weitere Funktion in jeder

132
00:06:48,300 --> 00:06:50,803
‫einzelnen Middleware überall in unserer Anwendung.

133
00:06:51,950 --> 00:06:54,800
‫Jedes Mal, wenn wir also etwas an next übergeben,

134
00:06:54,800 --> 00:06:57,250
‫geht es davon aus, dass es sich um

135
00:06:57,250 --> 00:06:59,670
‫einen Fehler handelt, überspringt dann alle anderen

136
00:06:59,670 --> 00:07:02,250
‫Middlewares im Middleware-Stack und sendet den Fehler, den

137
00:07:02,250 --> 00:07:04,680
‫wir übergeben haben, an unsere globale Fehlerbehandlungs-Middleware, die

138
00:07:04,680 --> 00:07:06,680
‫dann , natürlich ausgeführt werden.

139
00:07:08,030 --> 00:07:10,090
‫Und so lassen Sie uns

140
00:07:10,090 --> 00:07:12,350
‫jetzt den Fehler überspringen, der wieder alle

141
00:07:12,350 --> 00:07:15,393
‫anderen Middlewares im Stack überspringt und direkt zu dieser gehen.

142
00:07:16,850 --> 00:07:18,430
‫In diesem Fall gibt

143
00:07:18,430 --> 00:07:21,210
‫es eigentlich keine andere Middleware in der Mitte, okay?

144
00:07:21,210 --> 00:07:23,060
‫Es ist also wirklich nur

145
00:07:23,060 --> 00:07:25,950
‫das nächste hier, aber wenn wir next verwenden und

146
00:07:25,950 --> 00:07:28,603
‫woanders einen Fehler eingeben, dann funktioniert es natürlich genauso.

147
00:07:29,720 --> 00:07:31,940
‫Lassen Sie uns all dies nun einfach

148
00:07:31,940 --> 00:07:35,077
‫testen, indem wir versuchen, auf eine nicht definierte Route zuzugreifen.

149
00:07:35,077 --> 00:07:38,460
‫Damit wird dann der gesamte Code hier ausgelöst,

150
00:07:38,460 --> 00:07:41,190
‫zur Fehlerbehandlungs-Middleware gesprungen und dann die Antwort

151
00:07:41,190 --> 00:07:43,700
‫basierend auf dieser ganzen Logik

152
00:07:43,700 --> 00:07:44,773
‫hier zurückgesendet.

153
00:07:47,420 --> 00:07:52,130
‫Also, hier haben wir immer noch unsere falsche oder nicht vorhandene Route

154
00:07:52,130 --> 00:07:55,220
‫und lasst uns damit beginnen, dass wir tatsächlich

155
00:07:55,220 --> 00:07:57,023
‫diese anrufen, die noch funktionieren

156
00:07:59,850 --> 00:08:01,650
‫sollte, okay, also nur um

157
00:08:01,650 --> 00:08:05,050
‫zu bestätigen, dass alles gut funktioniert und es funktioniert,

158
00:08:05,050 --> 00:08:06,810
‫und jetzt diese.

159
00:08:06,810 --> 00:08:11,250
‫Und tatsächlich bekommen wir auf diesem Server keine API-Slash-Touren, und so

160
00:08:11,250 --> 00:08:13,810
‫erledigt unsere globale Middleware zur Fehlerbehandlung

161
00:08:13,810 --> 00:08:15,560
‫tatsächlich ihre Arbeit.

162
00:08:15,560 --> 00:08:19,560
‫Perfekt, das ist der erste Schritt, um wirklich

163
00:08:19,560 --> 00:08:22,370
‫einen viel besseren Fehlerbehandlungsmechanismus in unserer

164
00:08:22,370 --> 00:08:24,200
‫Anwendung zu implementieren.

165
00:08:24,200 --> 00:08:26,830
‫Wir könnten jetzt also weitermachen und versuchen, diese Art

166
00:08:26,830 --> 00:08:29,460
‫von Sachen hier überall in all unseren Handlern

167
00:08:29,460 --> 00:08:30,310
‫zu implementieren.

168
00:08:30,310 --> 00:08:34,160
‫Zum Beispiel hier drüben in all diesen Funktionen, die wir

169
00:08:34,160 --> 00:08:35,060
‫hier haben.

170
00:08:35,060 --> 00:08:37,410
‫Ersetzen Sie also alles, was wir hier haben, durch

171
00:08:37,410 --> 00:08:38,850
‫diese Art von Fehler.

172
00:08:38,850 --> 00:08:41,460
‫Aber was ich vorerst tun möchte, ist, unsere

173
00:08:41,460 --> 00:08:42,920
‫eigene Fehlerklasse zu erstellen.

174
00:08:42,920 --> 00:08:46,330
‫Damit wir nicht den ganzen Code hier schreiben müssen

175
00:08:46,330 --> 00:08:49,280
‫und stattdessen eine eher schlanke Klasse von uns

176
00:08:49,280 --> 00:08:50,113
‫haben.

177
00:08:50,113 --> 00:08:53,350
‫Das ist also eine gängige Praxis, und das machen wir im

178
00:08:53,350 --> 00:08:54,283
‫nächsten Video.

