1
00:00:01,210 --> 00:00:02,370
‫Kursleiter: Sie

2
00:00:02,370 --> 00:00:03,980
‫haben also bereits gelernt, wie

3
00:00:03,980 --> 00:00:05,970
‫man Async/Await verwendet, aber es gibt

4
00:00:05,970 --> 00:00:09,240
‫noch ein bisschen mehr darüber, wie Async-Funktionen tatsächlich funktionieren.

5
00:00:09,240 --> 00:00:10,613
‫Also machen wir das jetzt.

6
00:00:12,140 --> 00:00:15,080
‫Um etwas besser zu verstehen, was hier passiert, versuchen wir

7
00:00:15,080 --> 00:00:18,330
‫einfach, eine Konsole hinzuzufügen. Protokolle nach und

8
00:00:18,330 --> 00:00:21,333
‫vor dem Aufrufen von Async-Funktionen hier.

9
00:00:22,640 --> 00:00:24,520
‫Okay, also tröste.

10
00:00:26,310 --> 00:00:27,940
‫log Also Schritt

11
00:00:29,686 --> 00:00:31,383
‫eins wird Hundebilder

12
00:00:32,340 --> 00:00:33,360
‫bekommen, okay.

13
00:00:33,360 --> 00:00:34,763
‫Und dann Nummer zwei.

14
00:00:36,690 --> 00:00:37,730
‫Sagen

15
00:00:37,730 --> 00:00:42,410
‫wir mal, fertig mit den Hundebildern.

16
00:00:42,410 --> 00:00:44,433
‫Okay. Also lassen Sie es uns sparen.

17
00:00:45,460 --> 00:00:47,570
‫Und was ist hier passiert?

18
00:00:47,570 --> 00:00:50,160
‫Wir haben diese beiden Konsolen. logs vor

19
00:00:50,160 --> 00:00:54,120
‫allen Protokollen, die von der Async-Funktion stammen.

20
00:00:54,120 --> 00:00:56,346
‫Wir haben also die eins, zwei für

21
00:00:56,346 --> 00:00:57,900
‫diese und diese und

22
00:00:57,900 --> 00:00:59,610
‫erst danach haben wir die

23
00:00:59,610 --> 00:01:01,530
‫Protokolle, die aus dem Hundebild stammen.

24
00:01:01,530 --> 00:01:03,290
‫Das haben Sie erwartet?

25
00:01:03,290 --> 00:01:06,320
‫Wenn nicht, analysieren wir, was hier passiert ist.

26
00:01:06,320 --> 00:01:09,650
‫Nun, wie ich Ihnen bereits sagte, wird diese

27
00:01:09,650 --> 00:01:11,940
‫Async-Funktion tatsächlich im Hintergrund ausgeführt.

28
00:01:11,940 --> 00:01:15,160
‫Denn so sollen sich Async-Funktionen

29
00:01:15,160 --> 00:01:17,150
‫einfach verhalten.

30
00:01:17,150 --> 00:01:18,960
‫Stimmt, das macht total Sinn?

31
00:01:18,960 --> 00:01:21,623
‫Wir können den Code hier also nicht einfach stoppen.

32
00:01:22,470 --> 00:01:24,920
‫Sobald wir diese Funktion treffen,

33
00:01:24,920 --> 00:01:29,440
‫können wir die Ausführung unseres Hauptthreads hier nicht einfach stoppen.

34
00:01:29,440 --> 00:01:30,273
‫Richtig?

35
00:01:30,273 --> 00:01:32,750
‫Und das ist die ganze Philosophie, das Ereignisprotokoll

36
00:01:32,750 --> 00:01:34,120
‫nicht zu blockieren.

37
00:01:34,120 --> 00:01:37,270
‫Wir müssen also einige Hundebilder von der API abrufen,

38
00:01:37,270 --> 00:01:40,550
‫aber das ist keine Entschuldigung, die Ausführung über Code zu stoppen.

39
00:01:40,550 --> 00:01:42,840
‫Also um das Ereignisprotokoll zu blockieren.

40
00:01:42,840 --> 00:01:45,770
‫Als Ergebnis, wenn die Java-Skript-Engine eingestellt wurde, wird

41
00:01:45,770 --> 00:01:48,480
‫diese Codezeile hier einfach die Funktion zum

42
00:01:48,480 --> 00:01:51,220
‫Abrufen von Hunden in den Hintergrund verlagern und

43
00:01:51,220 --> 00:01:53,230
‫direkt zur nächsten Zeile gehen.

44
00:01:53,230 --> 00:01:55,850
‫Also diese zweite Konsole. hier einloggen.

45
00:01:55,850 --> 00:01:59,890
‫Es ist also sinnvoll, dass zuerst dieser String hier protokolliert wird,

46
00:01:59,890 --> 00:02:01,990
‫dann diese Funktion ausgeführt wird,

47
00:02:01,990 --> 00:02:05,270
‫dann sofort diese Codezeile protokolliert wird und in der

48
00:02:05,270 --> 00:02:08,470
‫Zwischenzeit diese Datei im Hintergrund gelesen wird, und sobald

49
00:02:08,470 --> 00:02:10,390
‫das ist bereit, beginnt es

50
00:02:10,390 --> 00:02:13,370
‫mit dem Drucken dieses Protokolls, dieses Protokolls und

51
00:02:13,370 --> 00:02:14,920
‫auch dieses Protokolls.

52
00:02:14,920 --> 00:02:16,340
‫Genau das passiert hier also.

53
00:02:16,340 --> 00:02:19,760
‫Eins zwei und dann noch drei Einsen.

54
00:02:19,760 --> 00:02:21,550
‫Sinn ergeben? Okay.

55
00:02:21,550 --> 00:02:24,210
‫Dann gehen wir noch einen

56
00:02:24,210 --> 00:02:28,500
‫Schritt weiter und geben tatsächlich etwas von unserer Async-Funktion zurück.

57
00:02:28,500 --> 00:02:31,673
‫Also ändere ich dies hier auf drei, damit

58
00:02:31,673 --> 00:02:34,740
‫wir von dieser Funktion einen String zurückgeben

59
00:02:35,590 --> 00:02:40,570
‫können, der zwei sagt, sagen wir fertig und dann fügen wir hier

60
00:02:40,570 --> 00:02:43,410
‫wieder ein Emoji hinzu, damit es

61
00:02:43,410 --> 00:02:46,430
‫in unserer Konsole ein bisschen mehr auftaucht.

62
00:02:46,430 --> 00:02:47,853
‫Also fertig hier.

63
00:02:48,770 --> 00:02:51,063
‫Und dann speichern wir das.

64
00:02:53,100 --> 00:02:55,883
‫Einfach eine Variable, egal was es ist.

65
00:02:59,040 --> 00:03:01,520
‫Und loggen Sie dann x in die Konsole ein.

66
00:03:01,520 --> 00:03:03,260
‫Schauen wir also, was passiert.

67
00:03:03,260 --> 00:03:06,050
‫Und jetzt bekommen wir hier dieses

68
00:03:06,050 --> 00:03:10,800
‫seltsame Versprechen statt der Schnur hier, die wir vielleicht erwartet hatten.

69
00:03:10,800 --> 00:03:14,180
‫Warum ist also x hier und nicht dieser

70
00:03:14,180 --> 00:03:16,330
‫String, sondern dieses Versprechen hier?

71
00:03:16,330 --> 00:03:19,310
‫Erinnern Sie sich, wie ich am Anfang des

72
00:03:19,310 --> 00:03:21,860
‫letzten Videos gesagt habe, dass

73
00:03:21,860 --> 00:03:24,630
‫eine Async-Funktion tatsächlich automatisch ein Versprechen zurückgibt?

74
00:03:24,630 --> 00:03:27,490
‫Nun, das hier ist also der Beweis dafür.

75
00:03:27,490 --> 00:03:30,830
‫Anstatt sich zu diesem Zeitpunkt an der Konsole anzumelden, sagt es

76
00:03:30,830 --> 00:03:33,670
‫uns nur, dass x ein Versprechen ist, das zu

77
00:03:33,670 --> 00:03:35,730
‫diesem Zeitpunkt noch ausgeführt wird und

78
00:03:35,730 --> 00:03:36,950
‫daher noch aussteht.

79
00:03:36,950 --> 00:03:39,140
‫Deshalb heißt es hier ausstehend.

80
00:03:39,140 --> 00:03:42,460
‫Java-Skript kann also natürlich nicht wissen, dass x

81
00:03:42,460 --> 00:03:45,390
‫hier irgendwann dieser fertige String sein wird.

82
00:03:45,390 --> 00:03:48,350
‫Und so geht es einfach weiter zur nächsten Konsole. log, wie

83
00:03:48,350 --> 00:03:50,870
‫wir es zuvor besprochen hatten.

84
00:03:50,870 --> 00:03:53,380
‫Und zu der Zeit, als JavaScript tatsächlich weiß,

85
00:03:53,380 --> 00:03:57,176
‫dass dieses x hier die Belastung sein sollte, die wir zu diesem

86
00:03:57,176 --> 00:03:59,480
‫Zeitpunkt gut zurückgegeben haben, ist die Ausführung

87
00:03:59,480 --> 00:04:01,570
‫dieses Codes hier schon lange abgeschlossen.

88
00:04:01,570 --> 00:04:04,160
‫Aber was sollten wir tun, wenn

89
00:04:04,160 --> 00:04:06,860
‫wir diesen Rückgabewert hier tatsächlich erhalten wollten?

90
00:04:06,860 --> 00:04:09,930
‫Was also, wenn wir diese Zeichenfolge wirklich zurückgeben und

91
00:04:09,930 --> 00:04:11,950
‫über die Konsole protokollieren wollten?

92
00:04:11,950 --> 00:04:14,670
‫Nun, wir müssten diese Async-Funktion als

93
00:04:14,670 --> 00:04:15,980
‫Versprechen behandeln.

94
00:04:15,980 --> 00:04:18,310
‫Also würden wir die

95
00:04:18,310 --> 00:04:21,080
‫DEN-Methode verwenden oder wieder Async/Await verwenden.

96
00:04:21,080 --> 00:04:23,510
‫Lassen Sie mich Ihnen zeigen, wie das geht.

97
00:04:23,510 --> 00:04:27,840
‫Anstatt also zu versuchen, den zurückgegebenen Wert in

98
00:04:27,840 --> 00:04:32,513
‫einer Variablen zu speichern, können wir die DEN-Methode darauf verwenden.

99
00:04:34,400 --> 00:04:37,113
‫Hier können wir es also x nennen.

100
00:04:38,750 --> 00:04:43,157
‫Also trösten. log x also genau wie das, was

101
00:04:43,157 --> 00:04:45,850
‫wir hier hatten, und dann würden wir auch dieses

102
00:04:45,850 --> 00:04:47,513
‫innerhalb des DEN-Griffs machen, okay?

103
00:04:48,511 --> 00:04:49,920
‫Sehen wir uns also an, was wir hier gemacht haben.

104
00:04:49,920 --> 00:04:53,550
‫Holen Sie sich Hundebild also ein Versprechen, erinnern Sie sich daran?

105
00:04:53,550 --> 00:04:57,760
‫Und damit wir ein Versprechen haben, verwenden wir die DEN-Methode, um

106
00:04:57,760 --> 00:05:00,690
‫Zugang zu ihrem zukünftigen Wert zu erhalten.

107
00:05:00,690 --> 00:05:04,120
‫Also der Wert, der schließlich zurückgegeben wird.

108
00:05:04,120 --> 00:05:08,050
‫In diesem Fall sind dies die beiden bereiten Zeichenfolgen.

109
00:05:08,050 --> 00:05:08,883
‫Okay?

110
00:05:08,883 --> 00:05:10,540
‫Wenn Sie also x dazu

111
00:05:10,540 --> 00:05:14,520
‫bringen möchten, müssen wir die DEN-Methode verwenden, wie wir es gerade hier gemacht haben.

112
00:05:14,520 --> 00:05:17,370
‫Und erst danach können wir dann gleich hier

113
00:05:17,370 --> 00:05:19,218
‫den dritten String loggen.

114
00:05:19,218 --> 00:05:21,010
‫Wenn wir es jetzt

115
00:05:21,010 --> 00:05:23,760
‫so speichern, sollte es wie erwartet funktionieren.

116
00:05:23,760 --> 00:05:24,890
‫Und ja, das tut es.

117
00:05:24,890 --> 00:05:28,420
‫Wir haben also unser erstes Protokoll, dann alle

118
00:05:28,420 --> 00:05:32,120
‫Protokolle, die von unserer Async-Funktion kommen, und dann das

119
00:05:32,120 --> 00:05:34,795
‫fertige von Zeile 42 hier.

120
00:05:34,795 --> 00:05:36,530
‫Und schließlich die Nummer 3. Perfekt.

121
00:05:36,530 --> 00:05:39,083
‫Und ich hoffe, es macht für Sie vollkommen Sinn.

122
00:05:40,416 --> 00:05:43,530
‫Was passiert nun, wenn tatsächlich ein Fehler aufgetreten ist?

123
00:05:43,530 --> 00:05:45,853
‫Nun, das ist etwas schwieriger zu handhaben.

124
00:05:47,149 --> 00:05:50,410
‫Also lassen Sie uns noch einmal einen Fehler verursachen, wie wir es zuvor getan haben.

125
00:05:50,410 --> 00:05:54,020
‫Aber Sie sehen, dass wir hier eigentlich immer noch

126
00:05:54,020 --> 00:05:55,630
‫die DEN-Methode eingeben.

127
00:05:55,630 --> 00:05:58,640
‫Also dieser Block hier, okay.

128
00:05:58,640 --> 00:06:03,230
‫Selbst wenn hier in diesem Versprechen ein Fehler aufgetreten ist, wird es

129
00:06:03,230 --> 00:06:06,980
‫im Grunde immer noch als erfolgreiches Versprechen aufgelöst.

130
00:06:06,980 --> 00:06:09,720
‫Es gibt diesen Wert also immer noch hier zurück.

131
00:06:09,720 --> 00:06:12,560
‫Und selbst wenn wir unseren Catch-Handler hier unten hinzufügen, ändert

132
00:06:12,560 --> 00:06:14,373
‫das nichts an dieser Tatsache.

133
00:06:16,040 --> 00:06:18,317
‫Okay, also verwenden wir hier

134
00:06:22,760 --> 00:06:26,620
‫catch und dann console. log und protokolliere den Fehler

135
00:06:26,620 --> 00:06:30,300
‫hier, damit du siehst, dass immer noch kein Fehler protokolliert wurde.

136
00:06:30,300 --> 00:06:33,620
‫Und das wieder, weil dieses Versprechen, das hier

137
00:06:33,620 --> 00:06:36,270
‫von dieser Async-Funktion kommt, immer noch

138
00:06:36,270 --> 00:06:38,410
‫als erfolgreich markiert wird.

139
00:06:38,410 --> 00:06:41,170
‫Aber wenn Sie es wirklich als

140
00:06:41,170 --> 00:06:44,450
‫abgelehnt markieren wollten, müssen wir einen Fehler ausgeben.

141
00:06:44,450 --> 00:06:46,660
‫Lassen Sie uns das hier in diesem Catch-Block tun.

142
00:06:46,660 --> 00:06:50,250
‫Wenn also ein Fehler aufgetreten ist, möchten wir ihn nicht

143
00:06:50,250 --> 00:06:53,183
‫nur in der Konsole protokollieren, sondern auch auswerfen.

144
00:06:54,830 --> 00:06:59,123
‫Daher verwenden wir eine eingebaute JavaScript-Funktion namens throw.

145
00:07:00,080 --> 00:07:02,460
‫Und damit können wir einen Fehler auslösen.

146
00:07:02,460 --> 00:07:06,680
‫Damit wird nun diese gesamte Funktion dieses Versprechens als

147
00:07:06,680 --> 00:07:07,693
‫abgelehnt gekennzeichnet.

148
00:07:08,600 --> 00:07:09,540
‫Okay.

149
00:07:09,540 --> 00:07:12,570
‫Eigentlich sollten wir diesen Fehler nicht nur protokollieren,

150
00:07:12,570 --> 00:07:17,210
‫sondern einfach Fehler machen, um ihn ein bisschen sichtbarer zu machen, und

151
00:07:17,210 --> 00:07:19,932
‫vielleicht so etwas wie eine Explosion.

152
00:07:19,932 --> 00:07:20,843
‫Ja, so ähnlich.

153
00:07:22,250 --> 00:07:26,130
‫Okay, also speichern wir es und sehen, was passiert.

154
00:07:26,130 --> 00:07:29,380
‫Und bam, jetzt haben wir also tatsächlich unseren Fehler hier.

155
00:07:29,380 --> 00:07:31,840
‫Es heißt also, dass ich diese

156
00:07:31,840 --> 00:07:34,480
‫Datei nicht finden konnte, also stammt dieses

157
00:07:34,480 --> 00:07:38,250
‫Protokoll von diesem Fangprotokoll hier, aber gleichzeitig wird ein Fehler ausgegeben.

158
00:07:38,250 --> 00:07:40,800
‫Und wenn es einen Fehler wirft, wird

159
00:07:40,800 --> 00:07:43,330
‫das gesamte Versprechen als abgelehnt markiert.

160
00:07:43,330 --> 00:07:47,410
‫Und deshalb tragen wir dann das Fangprotokoll hier unten ein.

161
00:07:47,410 --> 00:07:50,290
‫Was dann natürlich wiederum diese Konsole

162
00:07:50,290 --> 00:07:52,690
‫auslösen wird. Protokoll dieses Fehlers.

163
00:07:52,690 --> 00:07:53,523
‫Okay?

164
00:07:53,523 --> 00:07:56,850
‫Und das ist natürlich eine ganz neue Ebene der Komplexität.

165
00:07:56,850 --> 00:07:58,240
‫Okay.

166
00:07:58,240 --> 00:08:00,900
‫Aber es ist immer noch sehr wichtig zu verstehen, wie das funktioniert,

167
00:08:00,900 --> 00:08:03,250
‫da es im wirklichen Leben die ganze Zeit passiert.

168
00:08:03,250 --> 00:08:06,160
‫Wir müssen also ständig Werte von Async-Funktionen

169
00:08:06,160 --> 00:08:08,800
‫zurückgeben, und daher ist es wichtig,

170
00:08:08,800 --> 00:08:11,880
‫wie Sie mit diesen zurückgegebenen Werten tatsächlich umgehen.

171
00:08:11,880 --> 00:08:15,100
‫Verwenden Sie in diesem Fall DEN und catch.

172
00:08:15,100 --> 00:08:17,550
‫Das Problem dabei ist, dass Versprechen

173
00:08:17,550 --> 00:08:19,610
‫mit Async/Await vermischt werden.

174
00:08:19,610 --> 00:08:21,780
‫Also haben wir hier oben Async/Await,

175
00:08:21,780 --> 00:08:24,400
‫dann verwenden wir plötzlich wieder DEN und

176
00:08:24,400 --> 00:08:26,440
‫fangen hier unten an.

177
00:08:26,440 --> 00:08:30,020
‫Lassen Sie mich Ihnen also tatsächlich ein anderes Muster zeigen.

178
00:08:30,020 --> 00:08:32,830
‫Okay, also kommen wir in unseren Teil

179
00:08:32,830 --> 00:08:35,630
‫hier nicht so herum, eher so.

180
00:08:35,630 --> 00:08:39,460
‫Lassen Sie uns also Async/Await verwenden, um diese Logik zu implementieren.

181
00:08:39,460 --> 00:08:42,380
‫Nun wollen wir dafür keine ganz neue Namensfunktion

182
00:08:42,380 --> 00:08:45,200
‫erstellen und verwenden daher ein bekanntes Muster, das

183
00:08:45,200 --> 00:08:47,140
‫Sie hoffentlich kennen, nämlich

184
00:08:47,140 --> 00:08:49,730
‫ein IIFE, also einen sofort aufgerufenen Funktionsausdruck.

185
00:08:49,730 --> 00:08:53,363
‫Okay, in Klammern definieren wir unsere Funktion.

186
00:08:55,880 --> 00:08:58,610
‫So, und dann rufen wir gleich an.

187
00:08:58,610 --> 00:08:59,870
‫Erinnere dich daran?

188
00:08:59,870 --> 00:09:03,320
‫Da wir in diesem Fall Async/Await verwenden möchten, sagen wir

189
00:09:03,320 --> 00:09:06,660
‫auch, dass es sich um eine Async-Funktion handelt.

190
00:09:06,660 --> 00:09:09,070
‫Okay, und das sieht hier etwas seltsam aus,

191
00:09:09,070 --> 00:09:11,940
‫aber wenn Sie zum Beispiel meinen JavaScript-Kurs besucht haben,

192
00:09:11,940 --> 00:09:14,210
‫wird Ihnen das tatsächlich bekannt vorkommen.

193
00:09:14,210 --> 00:09:16,700
‫Okay, also wieder deklarieren Sie eine Funktion

194
00:09:16,700 --> 00:09:19,860
‫in Klammern und rufen sie dann sofort als Funktion auf.

195
00:09:19,860 --> 00:09:22,470
‫Auf diese Weise müssen Sie nicht

196
00:09:22,470 --> 00:09:26,190
‫noch einmal eine ganze Namensfunktion deklarieren, die Sie später

197
00:09:26,190 --> 00:09:27,650
‫wieder aufrufen.

198
00:09:27,650 --> 00:09:29,087
‫Okay.

199
00:09:29,087 --> 00:09:31,070
‫Da wir jetzt Async/Await verwenden,

200
00:09:31,070 --> 00:09:34,623
‫verwenden wir das Fangmuster try it wieder wie zuvor.

201
00:09:36,346 --> 00:09:39,660
‫Fangen Sie also an, haben Sie hier Zugriff auf den Fehler,

202
00:09:39,660 --> 00:09:42,261
‫und wir können ihn hier eigentlich nicht auslassen.

203
00:09:42,261 --> 00:09:43,720
‫Auch wenn wir diesen Fehler nicht

204
00:09:43,720 --> 00:09:45,330
‫verwenden möchten, müssen wir ihn dennoch hier ausschreiben.

205
00:09:45,330 --> 00:09:46,163
‫Okay.

206
00:09:47,004 --> 00:09:48,420
‫In zukünftigen Versionen von JavaScript

207
00:09:48,420 --> 00:09:51,310
‫wird dies weg sein, aber im Moment müssen wir es so machen.

208
00:09:51,310 --> 00:09:53,503
‫Hier wird also dieser Fehler sein.

209
00:09:56,290 --> 00:09:59,213
‫Und hier oben werden wir all diese Konsolen haben. Protokolle.

210
00:10:00,660 --> 00:10:01,593
‫Dieser

211
00:10:03,870 --> 00:10:05,003
‫und dieser.

212
00:10:06,749 --> 00:10:09,790
‫Und jetzt hoffe ich, dass Sie wissen, wie Sie

213
00:10:09,790 --> 00:10:12,770
‫den Wert tatsächlich aus der Async-Funktion erhalten.

214
00:10:12,770 --> 00:10:14,340
‫Sie wissen also, wie das geht.

215
00:10:14,340 --> 00:10:17,230
‫Eigentlich werde ich das Video pausieren und dir erlauben, selbst

216
00:10:17,230 --> 00:10:19,720
‫herauszufinden, wie du es machen kannst, okay?

217
00:10:19,720 --> 00:10:21,750
‫Nehmen Sie diese kleine Herausforderung an und ich bin in

218
00:10:21,750 --> 00:10:22,583
‫einer Sekunde zurück.

219
00:10:26,810 --> 00:10:30,270
‫Haben Sie es also geschafft, diesen String hierher zu bringen, also

220
00:10:30,270 --> 00:10:32,900
‫diese beiden in die x-Variable einzufügen, genau wie wir

221
00:10:32,900 --> 00:10:34,510
‫es zuvor getan haben?

222
00:10:34,510 --> 00:10:35,973
‫Also einfach so hier?

223
00:10:37,030 --> 00:10:40,110
‫Es ist also wie bei uns zuvor.

224
00:10:40,110 --> 00:10:44,380
‫Sie deklarieren eine Variable und warten dann auf das Versprechen.

225
00:10:44,380 --> 00:10:48,090
‫Und das Versprechen ist in diesem Fall, ein Hundebild zu bekommen.

226
00:10:48,090 --> 00:10:48,923
‫Okay?

227
00:10:48,923 --> 00:10:51,260
‫Diese Funktion hier ist also eine Async-Funktion

228
00:10:51,260 --> 00:10:53,550
‫und gibt daher ein Versprechen zurück.

229
00:10:53,550 --> 00:10:55,850
‫Und der Ergebniswert dieses Versprechens ist

230
00:10:55,850 --> 00:10:58,100
‫dieser Wert hier, der zurückgegeben

231
00:10:58,100 --> 00:11:01,400
‫wird. Wenn Sie also auf diesen Wert warten,

232
00:11:01,400 --> 00:11:03,880
‫wird das Ergebnis dieser String sein.

233
00:11:03,880 --> 00:11:06,710
‫Also speichern wir das in x und können es dann

234
00:11:06,710 --> 00:11:08,420
‫natürlich in die Konsole einloggen.

235
00:11:08,420 --> 00:11:12,260
‫Also trösten. log x.

236
00:11:12,260 --> 00:11:14,980
‫Falls dann ein Fehler auftritt, wird er abgefangen und

237
00:11:14,980 --> 00:11:16,890
‫auch hier in der Konsole protokolliert.

238
00:11:16,890 --> 00:11:19,230
‫Wenn wir es jetzt speichern,

239
00:11:19,230 --> 00:11:22,555
‫dann bekommen wir den Fehler immer noch, weil wir

240
00:11:22,555 --> 00:11:26,180
‫ihn hier hatten, damit dieser Teil immer noch funktioniert.

241
00:11:26,180 --> 00:11:30,490
‫Reparieren, speichern und los gehts.

242
00:11:30,490 --> 00:11:32,790
‫Also funktioniert es jetzt wie gewünscht.

243
00:11:32,790 --> 00:11:35,470
‫Aber auch hier ist es mit Async/Await viel sauberer,

244
00:11:35,470 --> 00:11:38,433
‫sieht viel besser aus und ist auch leichter zu verstehen.

245
00:11:39,315 --> 00:11:42,577
‫Also mischen wir Async/Await hier nicht an einer Stelle und

246
00:11:42,577 --> 00:11:45,430
‫verwenden dann DEN und Catch down hier, wie wir

247
00:11:45,430 --> 00:11:47,543
‫es zuvor mit diesem Codestück hatten.

248
00:11:47,543 --> 00:11:48,570
‫Okay?

249
00:11:48,570 --> 00:11:51,820
‫Im wirklichen Leben passieren solche Dinge die ganze Zeit.

250
00:11:51,820 --> 00:11:54,450
‫Wir haben also eine Async-Funktion und wir haben

251
00:11:54,450 --> 00:11:57,500
‫sie von einer anderen Async-Funktion aufgerufen, und vielleicht haben

252
00:11:57,500 --> 00:11:59,660
‫wir sogar eine andere Async-Funktion

253
00:11:59,660 --> 00:12:02,270
‫von dieser ersten Async-Funktion aufgerufen, und so

254
00:12:02,270 --> 00:12:05,420
‫haben wir eine Reihe dieser Async-Funktionen, die miteinander interagieren.

255
00:12:05,420 --> 00:12:07,710
‫Deshalb ist es sehr wichtig, dass Sie wissen,

256
00:12:07,710 --> 00:12:08,900
‫wie das alles funktioniert.

257
00:12:08,900 --> 00:12:11,070
‫Und noch einmal zur Zusammenfassung:

258
00:12:11,070 --> 00:12:14,160
‫Das Wichtigste ist, dass eine Async-Funktion automatisch

259
00:12:14,160 --> 00:12:17,430
‫ein Promise zurückgibt und dass der Wert, den

260
00:12:17,430 --> 00:12:20,800
‫wir von einer Async-Funktion zurückgeben, der Ergebniswert dieses

261
00:12:20,800 --> 00:12:21,890
‫Promises ist.

262
00:12:21,890 --> 00:12:24,426
‫Von da an können wir es also einfach

263
00:12:24,426 --> 00:12:25,810
‫als weiteres Versprechen behandeln.

264
00:12:25,810 --> 00:12:29,070
‫Und genau das haben wir hier getan, indem wir auf das erste

265
00:12:29,070 --> 00:12:31,300
‫Versprechen gewartet haben, das wir geschaffen haben.

266
00:12:31,300 --> 00:12:32,133
‫Okay?

267
00:12:32,133 --> 00:12:35,000
‫Versuchen Sie also, sich damit auseinanderzusetzen und stellen Sie

268
00:12:35,000 --> 00:12:37,010
‫sicher, dass Sie es wirklich verstehen.

269
00:12:37,010 --> 00:12:39,320
‫Denn für den Rest des Kurses gehe ich

270
00:12:39,320 --> 00:12:42,270
‫davon aus, dass Sie wissen, wie man mit diesem Zeug arbeitet.

271
00:12:42,270 --> 00:12:44,730
‫Und genau deshalb habe ich diesen Abschnitt

272
00:12:44,730 --> 00:12:48,160
‫erstellt, um ihn aus dem Weg zu räumen, bevor wir

273
00:12:48,160 --> 00:12:52,330
‫wirklich anfangen, ohne JS und Express und all diese guten Sachen zu arbeiten.

274
00:12:52,330 --> 00:12:53,250
‫Okay?

275
00:12:53,250 --> 00:12:56,178
‫Wir sind also fast fertig mit diesem Abschnitt, es gibt nur eine

276
00:12:56,178 --> 00:12:57,720
‫Kleinigkeit, die ich Ihnen im nächsten

277
00:12:57,720 --> 00:12:58,653
‫Video zeigen möchte.