﻿1
00:00:01,500 --> 00:00:03,600
‫Kursleiter: In diesem Video werden wir die

2
00:00:03,600 --> 00:00:06,680
‫Funktionen zum Lesen von Dateien und zum Schreiben von Dateien versprechen.

3
00:00:06,680 --> 00:00:09,440
‫Das bedeutet, dass wir sie so gestalten,

4
00:00:09,440 --> 00:00:11,230
‫dass sie Versprechen

5
00:00:11,230 --> 00:00:14,383
‫zurückgeben, anstatt dass wir ihnen eine Rückruffunktion übergeben.

6
00:00:16,180 --> 00:00:19,156
‫Wenn Sie möchten, ist es im Grunde eine Funktion

7
00:00:19,156 --> 00:00:20,890
‫zum Lesen einer Datei,

8
00:00:20,890 --> 00:00:24,300
‫die ein Versprechen zurückgibt und nur einen Dateinamen empfängt, keinen Rückruf.

9
00:00:24,300 --> 00:00:26,023
‫Machen wir also genau das.

10
00:00:28,530 --> 00:00:33,530
‫Wir werden also eine Funktion zum Lesen von Dateien erstellen.

11
00:00:34,110 --> 00:00:36,380
‫Also Pro für Versprechen, weil es

12
00:00:36,380 --> 00:00:37,970
‫wieder ein Versprechen zurückgibt.

13
00:00:37,970 --> 00:00:40,270
‫Und dann geben wir nur noch

14
00:00:41,590 --> 00:00:44,713
‫den Dateinamen ein und geben, wie gesagt, ein Versprechen zurück.

15
00:00:46,060 --> 00:00:49,570
‫Also, neues Versprechen zurückgeben.

16
00:00:49,570 --> 00:00:52,150
‫Daher verwenden wir hier den Promise-Konstruktor,

17
00:00:52,150 --> 00:00:55,540
‫der mit ES6 in die Sprache eingeführt wurde.

18
00:00:55,540 --> 00:00:58,600
‫Vor ES6 wie ES5, ES4 und allen

19
00:00:58,600 --> 00:01:00,030
‫vorherigen Versionen

20
00:01:00,030 --> 00:01:03,820
‫gab es also keine Unterstützung für Versprechen in JavaScript.

21
00:01:03,820 --> 00:01:05,670
‫Aber sie haben das in ES6

22
00:01:05,670 --> 00:01:08,660
‫geändert und die Sprache in dieser Hinsicht viel besser gemacht.

23
00:01:08,660 --> 00:01:12,010
‫Also in Bezug auf asynchrones JavaScript.

24
00:01:12,010 --> 00:01:14,350
‫Nun nimmt dieser Promise-Konstruktor

25
00:01:14,350 --> 00:01:17,400
‫hier eine sogenannte Executor-Funktion auf, die

26
00:01:17,400 --> 00:01:20,980
‫sofort aufgerufen wird, wenn Promise erstellt wird.

27
00:01:20,980 --> 00:01:24,450
‫Und diese Funktion wird zwei Argumente annehmen, also

28
00:01:24,450 --> 00:01:26,363
‫auflösen und ablehnen.

29
00:01:28,330 --> 00:01:30,370
‫Also entschließe dich und lehne

30
00:01:30,370 --> 00:01:32,770
‫ab, aber mach dir jetzt keine Sorgen um

31
00:01:32,770 --> 00:01:35,020
‫sie, wir werden gleich über sie sprechen.

32
00:01:35,020 --> 00:01:38,550
‫Konzentrieren wir uns vorerst nur auf diese Executor-Funktion

33
00:01:38,550 --> 00:01:41,470
‫selbst, denn hier erledigen wir eigentlich

34
00:01:41,470 --> 00:01:43,450
‫all diese asynchronen Arbeiten.

35
00:01:43,450 --> 00:01:46,430
‫In diesem Fall funktioniert die gelesene Datei.

36
00:01:46,430 --> 00:01:48,890
‫Hier werden wir also fs nennen. readfile

37
00:01:51,040 --> 00:01:53,287
‫mit dem übergebenen Dateinamen

38
00:01:53,287 --> 00:01:57,270
‫und dann die übliche Callback-Funktion, ok.

39
00:01:57,270 --> 00:02:00,660
‫Also der Fehler und die Daten, also genau

40
00:02:00,660 --> 00:02:02,000
‫wie zuvor.

41
00:02:02,000 --> 00:02:03,550
‫Denken Sie also daran,

42
00:02:03,550 --> 00:02:06,200
‫dass wir die Dateilesefunktion nicht wirklich ändern,

43
00:02:06,200 --> 00:02:07,997
‫sondern einfach eine neue Funktion

44
00:02:07,997 --> 00:02:11,140
‫erstellen, die hinter den Kulissen natürlich immer noch

45
00:02:11,140 --> 00:02:13,850
‫die eingebaute Dateilesefunktion ausführt, aber dann ein

46
00:02:13,850 --> 00:02:15,570
‫Versprechen zurückgibt, damit wir

47
00:02:15,570 --> 00:02:17,040
‫stattdessen das

48
00:02:17,040 --> 00:02:19,170
‫Versprechen verwenden können der Callback-Funktion.

49
00:02:19,170 --> 00:02:20,320
‫Okay.

50
00:02:20,320 --> 00:02:22,630
‫Wir haben hier also diese Datei lesen-Funktion,

51
00:02:22,630 --> 00:02:24,270
‫die ihre Arbeit verrichtet

52
00:02:24,270 --> 00:02:27,250
‫und, wenn sie fertig ist, mit den Daten zurückkommt.

53
00:02:27,250 --> 00:02:29,070
‫Und jetzt kommen hier

54
00:02:29,070 --> 00:02:31,510
‫die Auflösungs- und die Ablehnungsfunktion ins Spiel.

55
00:02:31,510 --> 00:02:34,610
‫Da diese beiden Argumente, die

56
00:02:34,610 --> 00:02:38,390
‫in der Executor-Funktion verfügbar sind, beide Funktionen sind.

57
00:02:38,390 --> 00:02:40,410
‫Nun wird das Aufrufen

58
00:02:40,410 --> 00:02:44,250
‫der Auflösungsfunktion das Promise im Grunde als erfolgreich markieren,

59
00:02:44,250 --> 00:02:45,320
‫also als

60
00:02:45,320 --> 00:02:49,010
‫erfüllt, und den erfolgreichen Wert aus dem Promise zurückgeben.

61
00:02:49,010 --> 00:02:50,310
‫Also lass uns das tatsächlich tun.

62
00:02:51,520 --> 00:02:55,270
‫Also nennen wir Auflösung mit Daten.

63
00:02:55,270 --> 00:02:58,690
‫Welche Variable wir also an die Auflösungsfunktion übergeben,

64
00:02:58,690 --> 00:03:00,860
‫wird später als Argument

65
00:03:00,860 --> 00:03:04,370
‫in der Methode then verfügbar sein, in Ordnung?

66
00:03:04,370 --> 00:03:07,310
‫Diese Daten hier werden also der Wert

67
00:03:07,310 --> 00:03:10,550
‫sein, den dieses Versprechen an uns zurückgibt, okay.

68
00:03:10,550 --> 00:03:12,930
‫Das klingt wahrscheinlich etwas verwirrend, oder?

69
00:03:12,930 --> 00:03:17,080
‫Alles, was wir hier an diese Funktion übergeben, an

70
00:03:17,080 --> 00:03:18,840
‫die Auflösungsfunktion, ist

71
00:03:18,840 --> 00:03:20,690
‫also das Ergebnis des

72
00:03:20,690 --> 00:03:23,590
‫Promises, das im then-Handler verfügbar sein wird.

73
00:03:23,590 --> 00:03:24,700
‫Auf der anderen

74
00:03:24,700 --> 00:03:27,800
‫Seite können wir die Zusage jetzt auch als abgelehnt markieren,

75
00:03:27,800 --> 00:03:29,960
‫falls ein Fehler aufgetreten ist, okay.

76
00:03:29,960 --> 00:03:31,230
‫Und das tun wir,

77
00:03:31,230 --> 00:03:32,450
‫indem wir, wie

78
00:03:32,450 --> 00:03:34,710
‫Sie sich wahrscheinlich denken können, die Ablehnungsfunktion aufrufen.

79
00:03:34,710 --> 00:03:36,390
‫Wenn also ein Fehler aufgetreten

80
00:03:38,300 --> 00:03:40,530
‫ist und dies ähnlich ist wie zuvor.

81
00:03:40,530 --> 00:03:42,520
‫Wenn hier also ein Fehler

82
00:03:42,520 --> 00:03:45,170
‫aufgetreten ist, rufen Sie die Ablehnungsfunktion auf.

83
00:03:45,170 --> 00:03:47,770
‫Und was immer wir in dieses

84
00:03:47,770 --> 00:03:50,310
‫eingeben, ist der Fehler, der

85
00:03:50,310 --> 00:03:52,930
‫später in der catch-Methode verfügbar ist.

86
00:03:52,930 --> 00:03:54,810
‫Also in diesem hier.

87
00:03:54,810 --> 00:03:56,110
‫Okay?

88
00:03:56,110 --> 00:03:58,673
‫Also lasst uns hier einfach einen

89
00:04:00,200 --> 00:04:05,060
‫String übergeben, ich konnte diese Datei nicht finden, ein paar Emojis hier

90
00:04:05,060 --> 00:04:08,480
‫vielleicht, damit sie in unserer Konsole ein bisschen

91
00:04:08,480 --> 00:04:11,030
‫mehr auftaucht. Protokolle, in Ordnung?

92
00:04:11,030 --> 00:04:11,993
‫Und, okay.

93
00:04:11,993 --> 00:04:14,070
‫Das ist es eigentlich schon.

94
00:04:14,070 --> 00:04:15,940
‫Lassen Sie uns dies hier noch einmal überprüfen.

95
00:04:15,940 --> 00:04:17,850
‫Also haben wir eine

96
00:04:17,850 --> 00:04:21,080
‫neue Datei erstellt, in der wir einen Dateinamen übergeben.

97
00:04:21,080 --> 00:04:22,200
‫Also dieses Argument.

98
00:04:22,200 --> 00:04:25,580
‫Und alles, was wir hier tun, ist dieses Versprechen zurückzugeben.

99
00:04:25,580 --> 00:04:29,160
‫Dieses Versprechen beinhaltet eine Executor-Funktion, also

100
00:04:29,160 --> 00:04:30,560
‫diese hier,

101
00:04:30,560 --> 00:04:34,040
‫wo wir unsere asynchrone Arbeit erledigen.

102
00:04:34,040 --> 00:04:36,110
‫Dann ist das hier natürlich unser

103
00:04:36,110 --> 00:04:36,943
‫fs. Readfile.

104
00:04:38,500 --> 00:04:41,250
‫Wenn wir unsere Daten dann erfolgreich erhalten,

105
00:04:41,250 --> 00:04:42,810
‫rufen wir die

106
00:04:42,810 --> 00:04:44,950
‫Auflösungsfunktion mit dem Auflösungswert auf.

107
00:04:44,950 --> 00:04:46,290
‫Und wenn ein

108
00:04:46,290 --> 00:04:49,040
‫Fehler auftritt, rufen wir die Ablehnungsfunktion auf, okay?

109
00:04:49,040 --> 00:04:52,560
‫Lassen Sie uns dies nun in der Praxis anwenden.

110
00:04:52,560 --> 00:04:55,030
‫Read file pro übergeben

111
00:04:55,030 --> 00:04:57,490
‫wir unseren Dateinamen.

112
00:04:57,490 --> 00:04:58,890
‫Das ist natürlich dieser

113
00:05:00,020 --> 00:05:01,300
‫und das war's.

114
00:05:01,300 --> 00:05:03,460
‫Dies wird nun also ein Versprechen zurückgeben.

115
00:05:03,460 --> 00:05:04,980
‫Und genau wie

116
00:05:04,980 --> 00:05:08,203
‫zuvor können wir dann unsere Dann-Methode darauf anwenden.

117
00:05:11,670 --> 00:05:14,930
‫Okay, und dieses Datenargument hier wird genau das sein,

118
00:05:14,930 --> 00:05:17,890
‫was wir aus dem Versprechen zurückgegeben haben, falls

119
00:05:17,890 --> 00:05:19,510
‫es erfolgreich war.

120
00:05:19,510 --> 00:05:21,540
‫Also, mit dieser Entschlossenheit.

121
00:05:21,540 --> 00:05:23,740
‫Im Moment enthält unsere

122
00:05:23,740 --> 00:05:25,540
‫Hundedatei hier Labrador

123
00:05:25,540 --> 00:05:29,440
‫und diese Daten hier werden Labrador sein.

124
00:05:29,440 --> 00:05:31,280
‫Und so ist das dann später in

125
00:05:31,280 --> 00:05:32,737
‫unserem damaligen Handler hier verfügbar.

126
00:05:32,737 --> 00:05:36,230
‫Aber natürlich muss es nicht den gleichen Namen haben,

127
00:05:36,230 --> 00:05:38,670
‫ich könnte es auch wie result

128
00:05:38,670 --> 00:05:41,300
‫nennen oder so ist es egal, okay?

129
00:05:41,300 --> 00:05:44,080
‫Okay, also lasst uns das alles jetzt nehmen und

130
00:05:44,920 --> 00:05:46,463
‫es tatsächlich hier platzieren.

131
00:05:48,270 --> 00:05:49,103
‫Okay.

132
00:05:49,103 --> 00:05:52,000
‫Beseitigen Sie all dies, speichern Sie es

133
00:05:52,000 --> 00:05:53,720
‫und das wird ausgeführt.

134
00:05:53,720 --> 00:05:55,520
‫Jetzt bekommen wir diesen Fehler hier unten,

135
00:05:55,520 --> 00:05:57,100
‫also sind die Daten nicht definiert.

136
00:05:57,100 --> 00:05:59,480
‫Das liegt daran, dass ich es hier in ein Ergebnis geändert habe.

137
00:05:59,480 --> 00:06:02,210
‫Gehen wir also zurück und ändern Sie es in

138
00:06:02,210 --> 00:06:03,270
‫Daten, denn hier haben

139
00:06:03,270 --> 00:06:04,300
‫wir Daten

140
00:06:04,300 --> 00:06:06,610
‫und hier haben wir Daten und auf

141
00:06:06,610 --> 00:06:09,210
‫diese Weise muss ich nicht alle diese Variablennamen ändern.

142
00:06:09,210 --> 00:06:10,690
‫Geben Sie es noch einmal

143
00:06:10,690 --> 00:06:12,080
‫speichern und los geht's.

144
00:06:12,080 --> 00:06:13,460
‫Es hat also funktioniert, verstehst du?

145
00:06:13,460 --> 00:06:15,150
‫Wir haben tatsächlich die Rasse

146
00:06:15,150 --> 00:06:16,720
‫bekommen, die immer

147
00:06:16,720 --> 00:06:19,870
‫noch Labrador ist und diesmal von unserem Versprechen, okay.

148
00:06:19,870 --> 00:06:21,150
‫Das hat also wirklich funktioniert.

149
00:06:21,150 --> 00:06:23,290
‫Unsere Funktion read file pro

150
00:06:23,290 --> 00:06:24,890
‫gibt jetzt also

151
00:06:24,890 --> 00:06:29,890
‫ein Promise zurück und diese Daten hier sind dann auf unserem then-Handler verfügbar.

152
00:06:29,910 --> 00:06:31,660
‫Großartig, also funktioniert es bereits und

153
00:06:31,660 --> 00:06:33,110
‫wir können es viel

154
00:06:33,110 --> 00:06:33,943
‫besser machen

155
00:06:33,943 --> 00:06:36,487
‫und das werden wir tun, aber vorerst möchte ich

156
00:06:36,487 --> 00:06:39,170
‫auch diese Funktion zum Schreiben von Dateien hier versprechen.

157
00:06:39,170 --> 00:06:40,580
‫Machen Sie also im Grunde

158
00:06:40,580 --> 00:06:42,520
‫dasselbe wie bei der Funktion Datei lesen.

159
00:06:42,520 --> 00:06:45,110
‫Wenn Sie sich jetzt schon ein

160
00:06:45,110 --> 00:06:49,000
‫wenig mit no js auskennen, denken Sie vielleicht, dass es tatsächlich

161
00:06:49,000 --> 00:06:52,090
‫einen Funktionsknoten gibt, der uns automatisch Funktionen verspricht.

162
00:06:52,090 --> 00:06:54,300
‫Aber natürlich wollte ich euch hier

163
00:06:54,300 --> 00:06:56,130
‫zeigen, wie Versprechen tatsächlich funktionieren

164
00:06:56,130 --> 00:06:57,320
‫und wie

165
00:06:57,320 --> 00:07:01,270
‫wir sie bauen und deshalb mache ich das alles hier, okay.

166
00:07:01,270 --> 00:07:03,860
‫Deshalb möchte ich wirklich, dass Sie etwas über Versprechen lernen, nicht

167
00:07:03,860 --> 00:07:05,410
‫nur, wie wir sie konsumieren, sondern

168
00:07:05,410 --> 00:07:06,710
‫auch, wie man sie baut.

169
00:07:06,710 --> 00:07:08,733
‫Und deshalb mache ich es so.

170
00:07:11,170 --> 00:07:14,913
‫Also, schreiben Sie Datei und als Versprechen.

171
00:07:16,720 --> 00:07:19,460
‫Und dieser braucht tatsächlich nicht nur den Dateinamen,

172
00:07:19,460 --> 00:07:22,993
‫sondern auch die Daten, die in diese Datei geschrieben werden sollen.

173
00:07:25,350 --> 00:07:27,460
‫Aber dann ist die Logik hier ganz ähnlich.

174
00:07:27,460 --> 00:07:30,253
‫Also geben wir wieder ein neues

175
00:07:31,760 --> 00:07:34,230
‫Versprechen zurück, darin haben wir

176
00:07:34,230 --> 00:07:37,823
‫unsere Executor-Funktion, die als Argument auflösen und ablehnen nimmt.

177
00:07:39,090 --> 00:07:40,470
‫Und dies sind eine Art

178
00:07:40,470 --> 00:07:41,860
‫Standardnamen. Also entschließen Sie sich und

179
00:07:41,860 --> 00:07:44,000
‫lehnen Sie ab, Sie könnten sie nennen, wie Sie

180
00:07:44,000 --> 00:07:46,463
‫wirklich wollten, aber das ist so etwas wie der Standard, okay.

181
00:07:47,780 --> 00:07:48,613
‫Also fs,

182
00:07:50,211 --> 00:07:51,044
‫write

183
00:07:52,870 --> 00:07:54,390
‫file, wir übergeben die

184
00:07:54,390 --> 00:07:57,523
‫Datei, die Daten und dann die Callback-Funktion.

185
00:07:58,580 --> 00:08:01,260
‫Und jetzt etwas sehr Ähnliches wie zuvor. Wenn

186
00:08:01,260 --> 00:08:02,800
‫also ein Fehler aufgetreten

187
00:08:02,800 --> 00:08:05,570
‫ist, rufen Sie die Ablehnungsfunktion auf und geben

188
00:08:05,570 --> 00:08:07,473
‫Sie dort eine Nachricht ein.

189
00:08:10,550 --> 00:08:12,340
‫Konnte die Datei

190
00:08:12,340 --> 00:08:16,060
‫nicht schreiben, wieder mit diesem Emoji hier, um es ein

191
00:08:16,060 --> 00:08:18,870
‫bisschen mehr hervorzuheben und falls alles gut

192
00:08:18,870 --> 00:08:20,830
‫funktioniert hat, dann einfach lösen.

193
00:08:20,830 --> 00:08:24,960
‫Jetzt haben wir keine Daten, die wir hier wirklich weitergeben müssen, oder?

194
00:08:24,960 --> 00:08:27,940
‫Also geben wir einfach eine zufällige

195
00:08:27,940 --> 00:08:30,920
‫Zeichenfolge ein, etwa wie "Erfolg", okay.

196
00:08:30,920 --> 00:08:32,770
‫Ein Versprechen muss

197
00:08:32,770 --> 00:08:36,000
‫also nicht immer einen sinnvollen Wert zurückgeben.

198
00:08:36,000 --> 00:08:38,060
‫In diesem Fall versuchen wir hier

199
00:08:38,060 --> 00:08:39,030
‫nur, eine

200
00:08:39,030 --> 00:08:42,340
‫Datei zu schreiben, die keinen wirklich sinnvollen Wert zurückgibt.

201
00:08:42,340 --> 00:08:46,290
‫Wir sind jetzt also bereit, diese versprochene Funktion zu verwenden, aber

202
00:08:46,290 --> 00:08:47,280
‫bevor wir

203
00:08:47,280 --> 00:08:49,640
‫das tun, implementieren wir die Verkettung, über

204
00:08:49,640 --> 00:08:51,750
‫die ich zuvor gesprochen habe.

205
00:08:51,750 --> 00:08:52,780
‫Im Moment

206
00:08:52,780 --> 00:08:56,170
‫haben wir also tatsächlich immer noch Rückrufe innerhalb von

207
00:08:56,170 --> 00:08:58,290
‫Rückrufen innerhalb von Rückrufen, oder?

208
00:08:58,290 --> 00:08:59,550
‫Also haben wir

209
00:08:59,550 --> 00:09:00,930
‫das, was diesen Rückruf hat.

210
00:09:00,930 --> 00:09:03,800
‫Und dann gibt es dort einen weiteren Then-Handler,

211
00:09:03,800 --> 00:09:06,470
‫der noch einen weiteren Callback enthält.

212
00:09:06,470 --> 00:09:09,230
‫Das ändert also nicht wirklich etwas, oder?

213
00:09:09,230 --> 00:09:12,697
‫Stattdessen wollen wir diese Then-Handler hier verketten.

214
00:09:12,697 --> 00:09:14,090
‫Und das Geheimnis

215
00:09:14,090 --> 00:09:17,670
‫dabei ist, dass jeder Handler ein neues Versprechen zurückgibt.

216
00:09:17,670 --> 00:09:19,280
‫Also, wie sollen wir das machen?

217
00:09:19,280 --> 00:09:24,280
‫Denken Sie daran, dass diese Funktion hier ein Versprechen zurückgibt.

218
00:09:24,760 --> 00:09:26,230
‫Alles, was wir tun

219
00:09:26,230 --> 00:09:29,290
‫müssen, ist, dieses Versprechen von diesem Erst- und dann Handler zurückzugeben.

220
00:09:29,290 --> 00:09:30,490
‫Lass mich dir das zeigen.

221
00:09:32,370 --> 00:09:35,260
‫Also sagen wir Return-Superagent. bekommen und dann

222
00:09:35,260 --> 00:09:38,630
‫die Zeichenfolge und das ist jetzt ein Versprechen, okay.

223
00:09:38,630 --> 00:09:41,920
‫Und dann schließen wir tatsächlich diese

224
00:09:41,920 --> 00:09:46,520
‫Callback-Funktion hier und verketten diese Methode dann direkt daran.

225
00:09:46,520 --> 00:09:49,400
‫Speichern Sie es, jetzt haben wir hier einen Fehler

226
00:09:49,400 --> 00:09:51,830
‫und das ist in Zeile 40.

227
00:09:51,830 --> 00:09:53,780
‫Lass uns das hier loswerden

228
00:09:53,780 --> 00:09:54,913
‫und okay.

229
00:09:55,760 --> 00:09:57,730
‫Es hat die Formatierung hier für

230
00:09:57,730 --> 00:09:59,200
‫uns wieder geändert, die

231
00:09:59,200 --> 00:10:02,700
‫schöner war und dann haben wir es hier unten eigentlich schon funktioniert.

232
00:10:02,700 --> 00:10:04,420
‫Warum funktioniert das dann wieder?

233
00:10:04,420 --> 00:10:06,800
‫Nun, natürlich gibt diese Funktion, die wir am

234
00:10:06,800 --> 00:10:09,130
‫Anfang erstellt haben, ein Versprechen zurück.

235
00:10:09,130 --> 00:10:11,840
‫Darauf können wir die Methode then anwenden.

236
00:10:11,840 --> 00:10:14,440
‫Wir lassen dann diese Callback-Funktion, die darin

237
00:10:14,440 --> 00:10:16,690
‫enthalten ist, wieder ein Versprechen zurückgeben.

238
00:10:16,690 --> 00:10:18,530
‫Und so können wir

239
00:10:18,530 --> 00:10:21,150
‫dann den nächsten Handler daran verketten.

240
00:10:21,150 --> 00:10:22,860
‫Diese Ergebnisvariable hier

241
00:10:22,860 --> 00:10:25,760
‫wird also der aufgelöste Wert dieses Versprechens

242
00:10:25,760 --> 00:10:29,170
‫sein, das vom vorherigen Handler zurückgegeben wurde, okay?

243
00:10:29,170 --> 00:10:30,750
‫Macht Sinn?

244
00:10:30,750 --> 00:10:33,020
‫Um noch einen Schritt weiter

245
00:10:33,020 --> 00:10:33,990
‫zu gehen,

246
00:10:33,990 --> 00:10:38,423
‫werden wir jetzt auch hier unsere Funktion write file pro verwenden.

247
00:10:39,350 --> 00:10:41,980
‫Und da wir die Then-Methoden weiterhin verketten wollen,

248
00:10:41,980 --> 00:10:44,190
‫werden wir das tatsächlich wieder zurückgeben.

249
00:10:44,190 --> 00:10:48,163
‫Also zurück, schreibe file pro pass in

250
00:10:50,420 --> 00:10:53,513
‫den Dateinamen, das ist dieser, die

251
00:10:55,840 --> 00:10:57,070
‫Daten...

252
00:11:00,210 --> 00:11:01,360
‫Und das ist es tatsächlich.

253
00:11:03,460 --> 00:11:06,600
‫Okay, das brauchen wir hier nicht mehr, lass es

254
00:11:06,600 --> 00:11:08,250
‫uns erst einmal kommentieren.

255
00:11:09,880 --> 00:11:11,650
‫Entfernen Sie diesen Raum

256
00:11:11,650 --> 00:11:14,973
‫hier und dann können wir den nächsten Handler verketten.

257
00:11:16,010 --> 00:11:18,230
‫Also dann, und denken Sie

258
00:11:18,230 --> 00:11:21,950
‫daran, dass wir hier drinnen keinen wirklich sinnvollen Wert hatten.

259
00:11:21,950 --> 00:11:24,240
‫Wir wollen hier

260
00:11:24,240 --> 00:11:26,580
‫also kein Argument für

261
00:11:26,580 --> 00:11:31,433
‫diese Callback-Funktion, wir wollen nur diesen String protokollieren, oder?

262
00:11:32,640 --> 00:11:34,970
‫Jetzt können wir das also wirklich

263
00:11:36,450 --> 00:11:37,920
‫loswerden und okay.

264
00:11:37,920 --> 00:11:39,490
‫Also, hier unten sehen wir

265
00:11:39,490 --> 00:11:41,090
‫jetzt, dass es tatsächlich schon funktioniert.

266
00:11:41,090 --> 00:11:43,080
‫Und wieder besteht der Trick,

267
00:11:43,080 --> 00:11:46,050
‫um alle diese Methoden hier verketten zu können,

268
00:11:46,050 --> 00:11:49,360
‫darin, ein Versprechen zurückzugeben, bevor jede von ihnen aufgerufen wird.

269
00:11:49,360 --> 00:11:52,360
‫Dieser hier gibt also offensichtlich ein Versprechen zurück, damit

270
00:11:52,360 --> 00:11:55,320
‫wir dann die Methode then verketten können.

271
00:11:55,320 --> 00:11:56,860
‫Dann gibt dieser Code

272
00:11:56,860 --> 00:11:58,110
‫hier ein Versprechen

273
00:11:58,110 --> 00:12:00,630
‫zurück und wir können es dann verwenden.

274
00:12:00,630 --> 00:12:02,920
‫Dann gibt dieses Stück Code

275
00:12:02,920 --> 00:12:07,320
‫ein Versprechen zurück und wir können es dann wieder verwenden, okay?

276
00:12:07,320 --> 00:12:09,010
‫Das ist also das Geheimnis.

277
00:12:09,010 --> 00:12:10,380
‫Sparen Sie noch einmal

278
00:12:10,380 --> 00:12:13,500
‫und hier unten sehen wir, dass die Rasse immer noch Labrador ist.

279
00:12:13,500 --> 00:12:16,640
‫Wir sehen, dass dies hier der Link ist, gehen

280
00:12:16,640 --> 00:12:19,180
‫wir hierher und bestätigen Sie, dass dies hier

281
00:12:19,180 --> 00:12:21,300
‫tatsächlich dasselbe ist wie dieses.

282
00:12:21,300 --> 00:12:26,050
‫Und so hat es den String mit unserer versprochenen Funktion zum

283
00:12:26,050 --> 00:12:30,717
‫Schreiben von Dateien erfolgreich in die Textdatei geschrieben, okay.

284
00:12:30,717 --> 00:12:34,240
‫Und am Ende haben wir dann diesen Fehlerhandler.

285
00:12:34,240 --> 00:12:38,060
‫Und das Schöne daran ist, dass wir am Ende für

286
00:12:38,060 --> 00:12:39,430
‫all diese Ketten-

287
00:12:39,430 --> 00:12:43,020
‫und Handler einfach nur einen einzigen Catch-Handler brauchen.

288
00:12:43,020 --> 00:12:44,980
‫Also eine Funktion, die

289
00:12:44,980 --> 00:12:48,910
‫die Fehler behandelt, die von einem der drei Versprechen stammen, okay.

290
00:12:48,910 --> 00:12:52,090
‫Lassen Sie uns eigentlich nur den Fehler in der

291
00:12:52,090 --> 00:12:53,900
‫Konsole protokollieren und versuchen

292
00:12:53,900 --> 00:12:56,160
‫wir beispielsweise, diese Datei hier zu ändern.

293
00:12:56,160 --> 00:12:57,980
‫Eigentlich nicht die Datei,

294
00:12:57,980 --> 00:13:01,940
‫aber ich werde den Dateinamen hier ändern, speichern und

295
00:13:01,940 --> 00:13:06,150
‫jetzt sehen wir, dass ich diese Datei nicht finden konnte.

296
00:13:06,150 --> 00:13:07,970
‫Also woher kommt das?

297
00:13:07,970 --> 00:13:09,720
‫Es kommt direkt

298
00:13:09,720 --> 00:13:13,410
‫hierher, wenn Sie die Ablehnungsfunktion aufrufen, okay?

299
00:13:13,410 --> 00:13:16,320
‫Wir haben hier also einen Fehler, weil wir die Datei

300
00:13:16,320 --> 00:13:18,890
‫nicht finden konnten und haben die Ablehnungsfunktion aufgerufen.

301
00:13:18,890 --> 00:13:22,600
‫Und diese Zurückweisungsfunktion markiert dann dieses Versprechen hier, also denken Sie daran,

302
00:13:23,850 --> 00:13:25,720
‫dass dies ein Versprechen ist.

303
00:13:25,720 --> 00:13:27,780
‫Es wird als abgelehnt markiert.

304
00:13:27,780 --> 00:13:30,870
‫Und deshalb wird die catch-Funktion aufgerufen.

305
00:13:30,870 --> 00:13:33,260
‫Und dann protokollieren wir diesen Fehler in der Konsole.

306
00:13:33,260 --> 00:13:36,313
‫Und das Ergebnis davon können Sie hier unten sehen.

307
00:13:37,360 --> 00:13:40,830
‫Okay, legen wir es zurück, jetzt funktioniert

308
00:13:40,830 --> 00:13:41,900
‫es.

309
00:13:41,900 --> 00:13:43,920
‫Jetzt gehen wir in die Datei,

310
00:13:43,920 --> 00:13:45,880
‫erstellen einen Hund, der nicht existiert

311
00:13:50,010 --> 00:13:54,320
‫und jetzt, oh, hier haben wir diesen großen seltsamen Fehler und das liegt daran,

312
00:13:54,320 --> 00:13:57,583
‫dass wir einfach den gesamten Fehler protokollieren und nicht die

313
00:13:57,583 --> 00:14:00,700
‫Fehlermeldung, wie wir es zuvor getan haben, aber es tut?

314
00:14:00,700 --> 00:14:01,723
‫ist egal.

315
00:14:03,500 --> 00:14:05,203
‫Jetzt speichern Sie es jetzt hier,

316
00:14:06,170 --> 00:14:07,220
‫legen Sie

317
00:14:07,220 --> 00:14:08,500
‫es zurück und gut.

318
00:14:08,500 --> 00:14:10,210
‫Jetzt funktioniert alles und

319
00:14:10,210 --> 00:14:12,510
‫wir haben diese dreieckige Form, die

320
00:14:12,510 --> 00:14:14,040
‫wir in unserem

321
00:14:14,040 --> 00:14:18,420
‫Code hatten, losgeworden und haben jetzt eine sogenannte flache Struktur von Kettenversprechen.

322
00:14:18,420 --> 00:14:20,600
‫Dies ist also wiederum viel einfacher

323
00:14:20,600 --> 00:14:23,150
‫zu verwalten und ich hoffe, Sie können das

324
00:14:23,150 --> 00:14:25,430
‫zu schätzen wissen und es ist auch

325
00:14:25,430 --> 00:14:28,120
‫logischer, über den Code so nachzudenken und zu argumentieren.

326
00:14:28,120 --> 00:14:29,270
‫Nun, im

327
00:14:29,270 --> 00:14:31,660
‫nächsten Vortrag werden wir tatsächlich noch einen

328
00:14:31,660 --> 00:14:33,570
‫Schritt weiter gehen und es

329
00:14:33,570 --> 00:14:35,210
‫noch lesbarer und benutzerfreundlicher machen.

330
00:14:35,210 --> 00:14:36,783
‫Also bleib dran.

