1
00:00:03,650 --> 00:00:06,180
In der vorherigen Übung

2
00:00:06,180 --> 00:00:09,414
haben wir zwei neue Aspekte von JavaScript gelernt,

3
00:00:09,414 --> 00:00:13,155
ihre Unterstützung für erstklassige Funktionen und Schließungen.

4
00:00:13,155 --> 00:00:20,250
Wir haben auch gesehen, wie Node den asynchronen Programmieraspekt behandelt und wie Node

5
00:00:20,250 --> 00:00:24,015
asynchrone Ausführung von Code mit

6
00:00:24,015 --> 00:00:28,365
der Verwendung von Callbacks und auch Fehlerbehandlung unterstützt.

7
00:00:28,365 --> 00:00:31,815
Sehen wir uns ein Beispiel an, wie wir dies

8
00:00:31,815 --> 00:00:36,650
innerhalb unserer Node-Anwendung in dieser Übung nutzen.

9
00:00:36,650 --> 00:00:42,315
Fortsetzung, wo wir in der vorherigen Übung aufgehört haben,

10
00:00:42,315 --> 00:00:48,025
jetzt werde ich gehen und das Rechteck-Knoten-Modul ändern,

11
00:00:48,025 --> 00:00:51,670
so dass es die Hilfe von Callbacks nehmen kann.

12
00:00:51,670 --> 00:00:55,375
Also werde ich diese Exporte hier entfernen,

13
00:00:55,375 --> 00:00:59,800
und stattdessen werden sie diese Funktion ändern.

14
00:00:59,800 --> 00:01:03,190
Ich werde diese beiden Funktionen ein wenig später nutzen,

15
00:01:03,190 --> 00:01:05,925
also speichere ich sie unten.

16
00:01:05,925 --> 00:01:07,515
Also lassen Sie mich sie beiseite halten.

17
00:01:07,515 --> 00:01:11,530
Und dann werde ich dieses Rechteck-Modul wie folgt ändern.

18
00:01:11,530 --> 00:01:15,270
Also sagen wir module.exports.

19
00:01:15,270 --> 00:01:20,025
Wir verwenden also die Standardweise, wie das Modul gehandhabt wird.

20
00:01:20,025 --> 00:01:26,185
Und dies wird diese Funktion exportieren, die diese drei Parameter,

21
00:01:26,185 --> 00:01:30,565
x und y und Callback nimmt.

22
00:01:30,565 --> 00:01:37,300
Der Callback ist eine Funktion, die geliefert wird, wenn dieses Modul aufgerufen wird.

23
00:01:37,300 --> 00:01:43,825
Dies ist also die Verwendung der erstklassigen Funktionen, über die wir früher gesprochen haben.

24
00:01:43,825 --> 00:01:46,775
In diesem Callback

25
00:01:46,775 --> 00:01:49,940
können Sie also sehen, dass Sie zwei Parameter erhalten, x und y.

26
00:01:49,940 --> 00:01:51,965
In diesem Fall

27
00:01:51,965 --> 00:01:55,520
entsprechen die x und y für das Rechteck der Länge und Breite

28
00:01:55,520 --> 00:02:01,550
des Rechtecks, das als die beiden Werte übergeben wird.

29
00:02:01,550 --> 00:02:05,090
Also hier drinnen werden wir überprüfen,

30
00:02:05,090 --> 00:02:10,300
ob x kleiner oder gleich Null ist oder y kleiner oder gleich Null ist oder gleich Null ist.

31
00:02:10,300 --> 00:02:13,255
Wir haben Code wie diesen hier geschrieben.

32
00:02:13,255 --> 00:02:17,630
Also werde ich diesen Code von hier kopieren

33
00:02:17,630 --> 00:02:23,330
und ihn dann hierher bringen und dann bearbeiten wir es.

34
00:02:23,330 --> 00:02:26,090
In diesem Fall ist dies, wenn x

35
00:02:26,090 --> 00:02:30,135
kleiner oder gleich Null ist oder y kleiner oder gleich Null ist.

36
00:02:30,135 --> 00:02:32,810
In diesem Fall, was tun wir?

37
00:02:32,810 --> 00:02:35,435
In diesem Fall stellen wir fest, dass

38
00:02:35,435 --> 00:02:39,750
die Abmessungen des Rechtecks kleiner oder gleich Null sind.

39
00:02:39,750 --> 00:02:43,775
Also müssen wir es anders handhaben,

40
00:02:43,775 --> 00:02:46,330
und wir werden den anderen Teil davon machen.

41
00:02:46,330 --> 00:02:52,790
Der andere Teil, in dem wir die Situation behandeln, in der das Rechteck ein gültiges Rechteck ist.

42
00:02:52,790 --> 00:02:54,245
Also in diesem Fall,

43
00:02:54,245 --> 00:03:04,580
was wir tun werden, ist, dann ein setTimeout zu verwenden.

44
00:03:04,580 --> 00:03:08,090
Also hier simuliere ich die Tatsache, dass alles, was

45
00:03:08,090 --> 00:03:11,860
in diesem Rechteck getan wird, einige Zeit in Anspruch nehmen wird.

46
00:03:11,860 --> 00:03:14,375
Dies ist also die asynchrone Verarbeitung.

47
00:03:14,375 --> 00:03:18,710
Jetzt, da ich im Hintergrund nicht viel zu tun habe,

48
00:03:18,710 --> 00:03:22,530
werde ich dies simulieren, indem ich einfach

49
00:03:22,530 --> 00:03:24,830
die setTimeout-Funktion von JavaScript verwende und dann

50
00:03:24,830 --> 00:03:28,825
verzögere, bevor die Callback-Funktion aufgerufen wird.

51
00:03:28,825 --> 00:03:32,210
Die Art und Weise, wie ich das arrangiere, ist wie folgt.

52
00:03:32,210 --> 00:03:34,270
Also innerhalb des setTimeout

53
00:03:34,270 --> 00:03:40,445
werde ich diese Funktion dort aufrufen

54
00:03:40,445 --> 00:03:44,855
und eine Verzögerung von

55
00:03:44,855 --> 00:03:50,570
2.000 Millisekunden oder zwei Sekunden anordnen, nach denen diese Funktion aufgerufen wird.

56
00:03:50,570 --> 00:03:52,003
Wenn Sie sich also erinnern,

57
00:03:52,003 --> 00:03:54,890
das SetTimeout, das in JavaScript unterstützt wird,

58
00:03:54,890 --> 00:03:58,070
nimmt es als erster Parameter eine Funktion und

59
00:03:58,070 --> 00:04:03,450
der zweite Parameter wäre der Zeitraum, für den dies verzögert wird.

60
00:04:03,450 --> 00:04:07,120
Also lassen Sie mich das einrücken.

61
00:04:07,120 --> 00:04:09,255
Jetzt muss ich diese Funktion hier ausfüllen.

62
00:04:09,255 --> 00:04:11,915
Also habe ich hier mit der Pfeilfunktion begonnen

63
00:04:11,915 --> 00:04:15,575
, die keine Parameter annimmt und dann, wenn es aufgerufen wird,

64
00:04:15,575 --> 00:04:20,745
werde ich einen Aufruf an den Callback ausgeben.

65
00:04:20,745 --> 00:04:22,880
Dieser Callback ist eine Callback-Funktion,

66
00:04:22,880 --> 00:04:25,760
die hier als dritter Parameter übergeben wird.

67
00:04:25,760 --> 00:04:33,440
Diese Callback-Funktion, wie Sie bemerkt haben, nimmt zwei Parameter.

68
00:04:33,440 --> 00:04:38,245
Der erste ist der Fehler und der zweite ist der Rückgabewert.

69
00:04:38,245 --> 00:04:40,625
Also in diesem Fall, da wir einen Fehler haben,

70
00:04:40,625 --> 00:04:44,750
weil x kleiner oder gleich Null ist und y kleiner oder gleich Null ist,

71
00:04:44,750 --> 00:04:50,820
also der erste Wert, den ich als neuer Fehler übergeben werde,

72
00:04:50,820 --> 00:05:00,603
und dieser Fehler ist genau diese Zeichenfolge, die ich dann in der console.log verwendet habe,

73
00:05:00,603 --> 00:05:03,915
und das ist, was ich als der Fehler hier.

74
00:05:03,915 --> 00:05:06,160
Lassen Sie mich jetzt die console.log löschen,

75
00:05:06,160 --> 00:05:07,625
ich brauche sie nicht mehr.

76
00:05:07,625 --> 00:05:08,890
Also für den Callback

77
00:05:08,890 --> 00:05:13,210
werde ich ein neues Fehlerobjekt generieren und dann

78
00:05:13,210 --> 00:05:18,850
als Rückgabewert für die Callback-Funktion, den ersten Parameter, übergeben.

79
00:05:18,850 --> 00:05:23,770
Also werde ich sagen, Rechteck-Dimensionen sollten größer als Null sein.

80
00:05:23,770 --> 00:05:28,240
Also sagen wir l,

81
00:05:28,240 --> 00:05:39,000
das ist der x und der y-Wert, den wir als Eingabewerte dort bekommen haben.

82
00:05:39,000 --> 00:05:40,650
Das ist also der Rückruf.

83
00:05:40,650 --> 00:05:43,890
Und der zweite Teil dieses Rückrufs

84
00:05:43,890 --> 00:05:51,290
werde ich als null übergeben, weil dies einen Fehler zurückgeben wird.

85
00:05:51,290 --> 00:05:54,345
Wenn Sie also einen Fehler als ersten Parameter zurückgeben,

86
00:05:54,345 --> 00:05:59,250
wird der zweite Parameter ignoriert, wenn dieser Rückruf gerade vom

87
00:05:59,250 --> 00:06:06,510
Knotenmodul empfangen wurde, von dem wir diese bestimmte Funktion dort aufrufen.

88
00:06:06,510 --> 00:06:09,085
Also, mit dieser Anordnung,

89
00:06:09,085 --> 00:06:10,700
also weniger als Null,

90
00:06:10,700 --> 00:06:18,590
lassen Sie mich hier etwas Platz geben, damit es hier richtig eingerückt ist.

91
00:06:18,590 --> 00:06:21,650
Also, die Art und Weise, wie ich dies

92
00:06:21,650 --> 00:06:26,135
hier arrangiere, ist, dass, wenn x kleiner als Null ist und y kleiner als Null ist,

93
00:06:26,135 --> 00:06:30,040
ich die Callback-Funktion zurückrufen werde, die übergeben wurde,

94
00:06:30,040 --> 00:06:32,424
aber der erste Parameter wird

95
00:06:32,424 --> 00:06:36,307
irrtümlich übergeben, weil wir hier bemerken, dass es einen Fehler gibt,

96
00:06:36,307 --> 00:06:38,930
und der zweite Parameter wird null sein.

97
00:06:38,930 --> 00:06:40,940
Wenn dies nicht der Fall ist

98
00:06:40,940 --> 00:06:44,550
, rufe ich den gleichen Callback auf,

99
00:06:44,550 --> 00:06:46,910
aber mit dem ersten Parameter.

100
00:06:46,910 --> 00:06:51,800
Also lassen Sie mich den Code hier kopieren.

101
00:06:51,800 --> 00:07:05,490
Ich werde immer noch das setTimeout hier verwenden.

102
00:07:05,490 --> 00:07:10,727
Aber dieser erste Teil wird kein Fehler sein

103
00:07:10,727 --> 00:07:13,005
, sondern der erste Teil,

104
00:07:13,005 --> 00:07:15,235
in diesem Fall gibt es keinen Fehler.

105
00:07:15,235 --> 00:07:20,455
Also werde ich diesen Wert einfach als null zurückgeben.

106
00:07:20,455 --> 00:07:22,950
Das bedeutet also, dass der Fehler auf null gesetzt ist.

107
00:07:22,950 --> 00:07:26,335
Dies ist also ein gültiges Rechteck.

108
00:07:26,335 --> 00:07:29,965
So können wir die Werte für das Rechteck berechnen.

109
00:07:29,965 --> 00:07:35,165
Aber stattdessen werde ich einfach

110
00:07:35,165 --> 00:07:40,020
ein JavaScript-Objekt übergeben, das die beiden Funktionen

111
00:07:40,020 --> 00:07:45,330
als die beiden Werte in diesem JavaScript-Objekt enthält.

112
00:07:45,330 --> 00:07:50,355
Also, hier werde ich diese zwei nehmen,

113
00:07:50,355 --> 00:07:54,530
den Umfang und das Gebiet,

114
00:07:55,250 --> 00:08:05,639
und dann werden diese beiden als die beiden Werte hier übergeben werden,

115
00:08:05,639 --> 00:08:07,807
Umfang und Gebiet.

116
00:08:07,807 --> 00:08:12,740
Und diese beiden, da sie ein JavaScript-Objekt sind, werden

117
00:08:12,740 --> 00:08:16,544
Umfang und Bereich

118
00:08:16,544 --> 00:08:22,690
die beiden Eigenschaften sein, die ich in diesem JavaScript-Objekt übergeben werde,

119
00:08:22,690 --> 00:08:25,295
und das ist es.

120
00:08:25,295 --> 00:08:28,570
Also hier, im zweiten Fall,

121
00:08:28,570 --> 00:08:32,034
wird der Fehler auf null gesetzt, weil es keinen Fehler gibt,

122
00:08:32,034 --> 00:08:33,190
aber der zweite Teil,

123
00:08:33,190 --> 00:08:37,715
beachten Sie, dass ich ein JavaScript-Objekt übergeben, das zwei Eigenschaften enthält,

124
00:08:37,715 --> 00:08:41,530
Umfang und Fläche, die hier zwei Funktionen sind.

125
00:08:41,530 --> 00:08:46,060
Die beiden Funktionen sind also die Perimeter-Funktion und Flächenfunktion.

126
00:08:46,060 --> 00:08:49,390
Dieses JavaScript-Objekt wird also als

127
00:08:49,390 --> 00:08:53,705
Rückgabewert für den Callback hier, der zweite Wert, zurückgegeben.

128
00:08:53,705 --> 00:08:56,035
Und wieder werde ich dies um

129
00:08:56,035 --> 00:09:02,900
ein zwei-Sekunden-Intervall verzögern, bevor der Wert von dieser Funktion zurückgegeben wird.

130
00:09:02,900 --> 00:09:07,075
Der Grund, warum ich das setTimeout verwende, besteht darin,

131
00:09:07,075 --> 00:09:11,780
eine Verzögerung zu simulieren, bevor der Callback von der anderen Seite kommt.

132
00:09:11,780 --> 00:09:15,280
Diese Art von stellt also Situationen dar, in denen

133
00:09:15,280 --> 00:09:18,565
Sie beispielsweise einen Datenbankaufruf an die Datenbank ausgeben

134
00:09:18,565 --> 00:09:23,300
und die Datenbank gelesen werden muss, bevor der Wert an Sie zurückgegeben wird.

135
00:09:23,300 --> 00:09:25,855
Das wird also eine gewisse Zeit in Anspruch nehmen.

136
00:09:25,855 --> 00:09:32,560
Also simuliere ich dies in diesem Moment im Grunde, indem ich hier die setTimeout-Funktion verwende.

137
00:09:32,560 --> 00:09:37,000
Später werden Sie sehen, dass, wenn wir die MongoDB mit

138
00:09:37,000 --> 00:09:43,060
unserem Express in den späteren Übungen integrieren,

139
00:09:43,060 --> 00:09:45,580
diese Verzögerung simuliert werden müsste,

140
00:09:45,580 --> 00:09:48,670
sie wird automatisch verursacht, weil Sie

141
00:09:48,670 --> 00:09:54,190
Datenbankoperationen hinter den Kulissen durchführen müssen, bevor die Daten abgerufen werden.

142
00:09:54,190 --> 00:10:00,325
Also hier, nachdem Sie dieses Rechteck-Modul-Update abgeschlossen haben,

143
00:10:00,325 --> 00:10:03,135
sehen Sie hier, dass das Rechteck-Modul

144
00:10:03,135 --> 00:10:06,830
drei Parameter übernimmt, da es hier ein Eingabeaufruf ist,

145
00:10:06,830 --> 00:10:08,920
x, y und Callback.

146
00:10:08,920 --> 00:10:12,445
Und so ist der Callback die Callback-Funktion, die hier bereitgestellt wird.

147
00:10:12,445 --> 00:10:16,585
Und diese Callback-Funktion wird hier im Inneren aufgerufen,

148
00:10:16,585 --> 00:10:18,685
und wenn die Callback-Funktion aufgerufen wird,

149
00:10:18,685 --> 00:10:22,495
geben Sie entweder einen Fehler zurück oder Sie geben

150
00:10:22,495 --> 00:10:28,045
eine Funktion zurück, mit der Sie den Umfang und die Fläche des Rechtecks berechnen können.

151
00:10:28,045 --> 00:10:33,835
Nun, dieses Muster des Aufrufs und Übergabe einer Callback-Funktion

152
00:10:33,835 --> 00:10:40,300
von einem Node-Modul und dann dem zweiten Node-Modul, das, wenn es abgeschlossen ist,

153
00:10:40,300 --> 00:10:44,800
das Ergebnis mit der Callback-Funktion zurückgibt, ist

154
00:10:44,800 --> 00:10:50,135
genau das Muster, das Sie oft in Node-Anwendungen wiederholt sehen werden.

155
00:10:50,135 --> 00:10:52,360
Das ist der Grund, warum ich es illustriere.

156
00:10:52,360 --> 00:10:58,735
Natürlich ist dies ein erfundenes Beispiel, das ich hier illustriere, aber es zeigt

157
00:10:58,735 --> 00:11:02,525
alle Standardmuster, die Sie mit Knoten-

158
00:11:02,525 --> 00:11:07,065
und Callback-Funktionen und auch die Fehlerbehandlung verwenden werden.

159
00:11:07,065 --> 00:11:10,955
Jetzt haben wir das Rechteck-Modul hier aktualisiert.

160
00:11:10,955 --> 00:11:16,870
Lassen Sie uns gehen und beheben Sie die Datei index.js, so dass sie die Callback-Funktion übergeben und

161
00:11:16,870 --> 00:11:23,770
dann den Rückgabewert behandeln kann, der vom Rechteck-Modul zurückgesendet wird.

162
00:11:23,770 --> 00:11:26,940
Wechseln Sie zurück zu index.js,

163
00:11:26,940 --> 00:11:31,270
jetzt werden wir die index.js Datei wie folgt aktualisieren.

164
00:11:31,270 --> 00:11:37,955
Ich werde dies stattdessen aus der Datei index.js entfernen.

165
00:11:37,955 --> 00:11:42,430
Hier, was wir am Ende tun werden, ist

166
00:11:42,430 --> 00:11:49,120
dieses Rechteck-Modul aufrufen und

167
00:11:49,120 --> 00:11:53,880
dann die l und die b als die beiden Parameter übergeben.

168
00:11:53,880 --> 00:12:00,300
Und der dritte Parameter, den ich übergeben werde, ist diese Callback-Funktion.

169
00:12:00,300 --> 00:12:10,080
Die Callback-Funktion hat also zwei Parameter, err und rechteck.

170
00:12:10,080 --> 00:12:15,860
Und diese Callback-Funktion ist hier wie folgt implementiert.

171
00:12:15,860 --> 00:12:19,090
Hier sehen Sie, dass ich

172
00:12:19,090 --> 00:12:23,785
dieses Rechteck-Knoten-Modul aufrufe und ich

173
00:12:23,785 --> 00:12:29,050
die Länge und die Breite der ersten beiden Parameter übergebe.

174
00:12:29,050 --> 00:12:31,285
Und der dritte Parameter ist natürlich

175
00:12:31,285 --> 00:12:34,355
eine Callback-Funktion, die ich hier implementiere.

176
00:12:34,355 --> 00:12:38,250
Also, das ist eine Pfeilfunktion, die ich hier implementiere.

177
00:12:38,250 --> 00:12:40,510
Also,

178
00:12:40,510 --> 00:12:43,245
wie handle ich in dieser Callback-Funktion mit dem Rückgabewert?

179
00:12:43,245 --> 00:12:46,860
Also hier werde ich sagen, wenn (err),

180
00:12:46,860 --> 00:12:51,335
also wenn der Fehlerwert an Sie zurückgegeben wird,

181
00:12:51,335 --> 00:12:59,500
dann werde ich einfach console.log machen und ich werde

182
00:12:59,500 --> 00:13:09,100
„ERROR“ sagen und dann ist der zweite Wert err.message.

183
00:13:09,100 --> 00:13:11,445
Erinnern Sie sich, dass

184
00:13:11,445 --> 00:13:14,820
wir im Rechteck dieses neue Fehlerobjekt erstellt

185
00:13:14,820 --> 00:13:18,155
und dann diese Zeichenfolge innerhalb dieses Fehlerobjekts übergeben hatten.

186
00:13:18,155 --> 00:13:20,100
Diese Zeichenfolge wird

187
00:13:20,100 --> 00:13:24,380
hier an das Error-Objekt an die message-Eigenschaft des Error-Objekts angehängt.

188
00:13:24,380 --> 00:13:26,830
Also, in der Datei index.js,

189
00:13:26,830 --> 00:13:30,090
also rufe ich die Nachrichteneigenschaft des Fehlerobjekts ab

190
00:13:30,090 --> 00:13:33,755
und drucke sie dann hier auf meine Konsole aus.

191
00:13:33,755 --> 00:13:35,310
Wenn also ein Fehler auftritt,

192
00:13:35,310 --> 00:13:39,215
werde ich die Fehlermeldung mit diesem ausdrucken.

193
00:13:39,215 --> 00:13:45,820
Und so würde ich mit einem Fehler umgehen, der von einer Callback-Funktion zurückgegeben wurde.

194
00:13:45,820 --> 00:13:51,360
Andernfalls

195
00:13:51,360 --> 00:13:57,450
hat das Rechteck-Modul natürlich in diesem Fall die Rechteck-Funktion zurückgegeben,

196
00:13:57,450 --> 00:14:01,620
das Objekt, das den Umfang und die Flächenfunktionen enthält,

197
00:14:01,620 --> 00:14:08,108
so dass ich diesen Wert ausdrucken kann.

198
00:14:08,108 --> 00:14:14,175
Also, hier werde ich sagen, die Fläche

199
00:14:14,175 --> 00:14:23,030
des Rechtecks der Dimensionen l gleich,

200
00:14:23,140 --> 00:14:28,270
also werde ich sagen,

201
00:14:29,170 --> 00:14:37,155
und b gleich.

202
00:14:37,155 --> 00:14:40,530
Der Grund, warum ich es

203
00:14:40,530 --> 00:14:47,340
explizit identifiziere, wird sehr klar, wenn wir dieses Beispiel ausführen.

204
00:14:47,340 --> 00:15:01,480
Ich werde sagen, ist rechtwinklig. Bereich.

205
00:15:01,480 --> 00:15:04,188
Nun, beachten Sie, dass für diesen Bereich,

206
00:15:04,188 --> 00:15:09,555
Ich schicke hier keine Parameter, weil geht zu Werten,

207
00:15:09,555 --> 00:15:14,540
die Länge und der Atem wurden bereits hier in der l und b übergeben,

208
00:15:14,540 --> 00:15:19,065
und diese wären bereits verfügbar für diese

209
00:15:19,065 --> 00:15:24,245
und hier wegen der Schließung, die JavaScript unterstützt.

210
00:15:24,245 --> 00:15:27,470
Da diese x und y als Parameter eingegangen sind,

211
00:15:27,470 --> 00:15:32,710
sind diese direkt dort in dieser Callback-Funktion zugänglich.

212
00:15:32,710 --> 00:15:37,315
Diese x_y werden also automatisch für uns hier zur Verfügung stehen.

213
00:15:37,315 --> 00:15:39,890
Also, in der Tat

214
00:15:39,890 --> 00:15:43,970
muss ich diese x- und y-Parameter hier überhaupt nicht angeben, weil

215
00:15:43,970 --> 00:15:49,090
diese x und y von diesem x und y direkt dort abgerufen werden.

216
00:15:49,090 --> 00:15:53,375
Also muss ich nicht einmal diese beiden Werte hier drin übergeben.

217
00:15:53,375 --> 00:15:55,385
Deshalb, genau da,

218
00:15:55,385 --> 00:15:57,905
kann ich rectangle.area anrufen.

219
00:15:57,905 --> 00:16:03,170
Und diese Flächenberechnung wird automatisch die l und b erhalten, die

220
00:16:03,170 --> 00:16:09,505
vom Rechteck-Aufruf an das direkte Knotenmodul früher übergeben wurden.

221
00:16:09,505 --> 00:16:14,980
Dies ist also die Schließung von JavaScript, das hier funktioniert.

222
00:16:14,980 --> 00:16:17,945
Also, das ist der erste.

223
00:16:17,945 --> 00:16:23,305
Ich drucke den Bereich des Rechtecks aus.

224
00:16:23,305 --> 00:16:32,990
Das Gleiche, lassen Sie mich auch die Umfänge ausdrucken.

225
00:16:32,990 --> 00:16:34,608
Also, um die Umfänge auszudrucken,

226
00:16:34,608 --> 00:16:36,720
so werde ich console.log sagen.

227
00:16:36,720 --> 00:16:46,560
Der Umfang des Rechtecks wird Rechteck Umfang sein.

228
00:16:46,560 --> 00:16:53,280
Jetzt muss ich Ihnen sagen, dass diese Art von Ansatz für die Implementierung ein wenig

229
00:16:53,280 --> 00:17:02,335
Aufwand erfordert, um die asynchrone Funktionsfähigkeit zu verstehen und zu verinnerlichen. Es

230
00:17:02,335 --> 00:17:06,360
braucht einige Zeit, um vollständig zu verstehen, wie es wirklich funktioniert.

231
00:17:06,360 --> 00:17:08,550
Nun, um die Tatsache zu veranschaulichen, dass

232
00:17:08,550 --> 00:17:14,642
dieser Funktionsaufruf zu einem Aufruf des Node-Moduls führt,

233
00:17:14,642 --> 00:17:19,280
aber dieser Teil wird erst nach

234
00:17:19,280 --> 00:17:24,830
einer zwei-Sekunden-Verzögerung ausgeführt, da wir die eingestellte Zeitmarke verwenden.

235
00:17:24,830 --> 00:17:28,745
Nun, da wir im asynchronen Betrieb studiert

236
00:17:28,745 --> 00:17:33,155
haben, weil wir die Verarbeitung nach hinten verschoben haben,

237
00:17:33,155 --> 00:17:41,420
lassen Sie mich hier auch eine weitere console.log vorstellen, um einen Punkt zu machen.

238
00:17:41,420 --> 00:17:46,175
Also sagen wir, diese Aussage ist

239
00:17:46,175 --> 00:17:53,869
nach dem Aufruf von rect.

240
00:17:53,869 --> 00:18:00,210
Der Grund, warum ich diesen Punkt illustriere, ist, dass, wenn Sie diesen Aufruf ausführen,

241
00:18:00,210 --> 00:18:06,130
dieser Code erst nach einer zwei-Sekunden-Verzögerung ausgeführt wird.

242
00:18:06,130 --> 00:18:10,360
In der Zwischenzeit

243
00:18:10,360 --> 00:18:16,340
wird Ihre Funktion, die Hauptfunktion hier, fortgesetzt und dann die nächste Codezeile ausführen, die Sie hier sehen.

244
00:18:16,340 --> 00:18:19,745
Das ist also die Fortsetzung, die Sie hier sehen werden.

245
00:18:19,745 --> 00:18:21,805
Also, mit diesen Änderungen,

246
00:18:21,805 --> 00:18:27,815
lassen Sie uns die Änderungen speichern und dann schauen, wie diese Anwendung jetzt ausgeführt wird.

247
00:18:27,815 --> 00:18:29,410
So speichern Sie die Änderungen.

248
00:18:29,410 --> 00:18:35,220
Gehen wir zum Terminal und führen Sie diese Knotenanwendung aus.

249
00:18:35,220 --> 00:18:37,570
Gehen Sie nun zum Terminal und fügen Sie die Eingabeaufforderung hinzu.

250
00:18:37,570 --> 00:18:43,795
Lassen Sie mich npm start eingeben und Sie werden sofort bemerken

251
00:18:43,795 --> 00:18:51,790
, dass die Lösung und diese Aussage früher ausgedruckt wurden.

252
00:18:51,790 --> 00:18:54,505
Und dann nach dieser gewissen Verzögerung wurden

253
00:18:54,505 --> 00:18:57,855
das Gebiet und der Umfang ausgedruckt.

254
00:18:57,855 --> 00:19:02,130
Das ist also eine Verzögerung von zwei Sekunden, die wir mit dem festgelegten Timeout eingeführt haben.

255
00:19:02,130 --> 00:19:05,755
Sie haben also bemerkt, dass in der früheren Version

256
00:19:05,755 --> 00:19:10,290
dies gedruckt wurde und sofort der Bereich und der Umfang direkt darunter gedruckt wurden.

257
00:19:10,290 --> 00:19:15,120
Aber jetzt, beachten Sie, dass diese Werte ein wenig später gedruckt werden.

258
00:19:15,120 --> 00:19:20,460
Dazwischen ruft ihre Funktion mit den verschiedenen Parametern auf, die bereits eingegangen sind,

259
00:19:20,460 --> 00:19:26,505
und dann werden die Callbacks nach zwei Sekunden Verzögerung für jeden von ihnen zurückgerufen.

260
00:19:26,505 --> 00:19:32,500
Und aufgrund der Tatsache, dass es die Schließung gibt, die das JavaScript unterstützt,

261
00:19:32,500 --> 00:19:35,980
so dass die Werte, die übergeben werden, erhalten bleiben.

262
00:19:35,980 --> 00:19:38,440
Und so, wenn die Callback-Funktion aufgerufen wird,

263
00:19:38,440 --> 00:19:40,615
wird der entsprechende Wert gedruckt.

264
00:19:40,615 --> 00:19:42,730
Deshalb sehen Sie, dass die Fläche und

265
00:19:42,730 --> 00:19:46,330
der Umfang korrekt gedruckt sind und diese beiden hier,

266
00:19:46,330 --> 00:19:48,070
diese beiden Aussagen hier,

267
00:19:48,070 --> 00:19:51,340
entsprechen diesem speziellen Aufruf zu direkter

268
00:19:51,340 --> 00:19:55,100
mit l gleich zwei und b ist gleich vier.

269
00:19:55,100 --> 00:19:58,150
Und dann

270
00:19:58,150 --> 00:20:05,000
entsprechen diese beiden, die nächsten zwei, natürlich dieser besonderen und den übrigen, wie Sie hier sehen.

271
00:20:05,000 --> 00:20:10,410
Was ich also veranschaulichen wollte, ist die Tatsache, dass bei asynchroner Berechnung

272
00:20:10,410 --> 00:20:12,730
die asynchrone Berechnung ihre eigene Zeit benötigt,

273
00:20:12,730 --> 00:20:16,270
um den Wert zurückzugeben, während Ihre Hauptrechnung

274
00:20:16,270 --> 00:20:22,460
vorwärts fortgesetzt wird, ohne auf den Abschluss des Callbacks zu warten.

275
00:20:22,460 --> 00:20:25,245
Also, wenn Sie eine bestimmte Menge an Arbeit tun müssen,

276
00:20:25,245 --> 00:20:29,365
haben Sie als Rückruf an dieses andere Modul übergeben.

277
00:20:29,365 --> 00:20:31,375
Und wenn dieses andere Modul seine Arbeit abgeschlossen hat,

278
00:20:31,375 --> 00:20:35,010
wird es zurückgerufen und dann wird dieser Code ausgeführt.

279
00:20:35,010 --> 00:20:41,565
Das ist also der Punkt, den ich anhand dieses Beispiels illustriert habe.

280
00:20:41,565 --> 00:20:45,210
Wieder, wie ich sagte, erfordert dies ein wenig Phantasie und Verständnis

281
00:20:45,210 --> 00:20:48,930
für Sie, um die Art und Weise zu verinnerlichen, wie dies funktioniert,

282
00:20:48,930 --> 00:20:55,185
aber Sie werden sehen, dass mit Node und auch Express und wenn wir MongoDB verwenden,

283
00:20:55,185 --> 00:21:01,785
werden Sie sehen, dass sich diese Art von Muster sehr oft in der Art und Weise wiederholen, wie wir unseren Code schreiben.

284
00:21:01,785 --> 00:21:06,210
Mit dieser einfachen Abbildung von Callbacks und Fehlerbehandlung

285
00:21:06,210 --> 00:21:08,940
schließen wir diese Übung ab.

286
00:21:08,940 --> 00:21:13,675
Dies ist ein guter Zeitpunkt für Sie, einen get Kommentar mit dieser Nachricht,

287
00:21:13,675 --> 00:21:17,700
Knoten, Rückrufe und Fehlerbehandlung zu tun.