1
00:00:03,680 --> 00:00:07,140
Eine Diskussion über Knotenmodule ist unvollständig,

2
00:00:07,140 --> 00:00:10,310
ohne über Callbacks und Fehlerbehandlung zu sprechen.

3
00:00:10,310 --> 00:00:14,820
Was sind Callbacks und warum sind sie für die

4
00:00:14,820 --> 00:00:17,250
Unterstützung asynchroner Berechnungen wichtig, die sehr

5
00:00:17,250 --> 00:00:20,610
nützlich ist, wenn wir Node.js Anwendungen schreiben?

6
00:00:20,610 --> 00:00:25,130
Wie wird die Fehlerbehandlung in Node-Anwendungen durchgeführt?

7
00:00:25,130 --> 00:00:29,615
Lassen Sie uns kurz darüber in dieser Vorlesung sprechen.

8
00:00:29,615 --> 00:00:34,305
Bevor wir über Knotenmodule und Callbacks sprechen,

9
00:00:34,305 --> 00:00:40,315
müssen wir zwei herausragende Funktionen über die JavaScript-Sprache selbst verstehen.

10
00:00:40,315 --> 00:00:46,295
In erster Linie unterstützt JavaScript, was als erstklassige Funktionen bezeichnet wird.

11
00:00:46,295 --> 00:00:48,430
Was meinen wir mit erstklassigen Funktionen?

12
00:00:48,430 --> 00:00:52,838
Ist, dass eine Funktion wie jede andere Variable behandelt werden kann.

13
00:00:52,838 --> 00:00:55,620
Und daher können Funktionen als

14
00:00:55,620 --> 00:01:00,955
Parameter innerhalb von Funktionsaufrufen an andere Funktionen übergeben werden.

15
00:01:00,955 --> 00:01:06,630
Und das ermöglicht es uns im Wesentlichen, Funktionen als Callback-Funktionen zu senden, die

16
00:01:06,630 --> 00:01:14,110
von einem anderen Node-Modul aufgerufen werden können, um etwas Arbeit zu erledigen.

17
00:01:14,110 --> 00:01:20,010
Dann schauen Sie sich an, wie dies sehr nützlich ist, um Callbacks in Node.js zu unterstützen.

18
00:01:20,010 --> 00:01:25,107
Der zweite Aspekt von JavaScript ist die Unterstützung für Closures.

19
00:01:25,107 --> 00:01:26,835
Was meinen wir mit Closures?

20
00:01:26,835 --> 00:01:31,185
Vor allem, wenn Sie mit funktionalen Programmiersprachen vertraut sind,

21
00:01:31,185 --> 00:01:33,325
verstehen Sie, wie die Schließung funktioniert.

22
00:01:33,325 --> 00:01:37,050
Eine Funktion, die in einer anderen Funktion definiert ist,

23
00:01:37,050 --> 00:01:42,955
erhält automatisch Zugriff auf die Variablen, die in der äußeren Funktion deklariert werden.

24
00:01:42,955 --> 00:01:46,185
Also, selbst wenn die äußere Funktion abgeschlossen ist,

25
00:01:46,185 --> 00:01:51,000
wenn die innere Funktion später ausgeführt wird, hat die innere Funktion immer noch Zugriff auf

26
00:01:51,000 --> 00:01:56,020
die Werte der Variablen innerhalb dieser äußeren Funktion.

27
00:01:56,020 --> 00:01:57,465
Und das wird wieder

28
00:01:57,465 --> 00:02:05,244
sehr effektiv verwendet, wenn wir Callbacks in Node-Anwendungen verwenden.

29
00:02:05,244 --> 00:02:08,790
Wenn Sie an die Standardmethode des Schreibens von Anwendungen gewöhnt sind,

30
00:02:08,790 --> 00:02:12,870
sind Sie mit der synchronen Berechnung vertraut, bei der Sie

31
00:02:12,870 --> 00:02:17,918
eine Berechnung als eine Reihe von Schritten angeben, die nacheinander durchgeführt werden sollen.

32
00:02:17,918 --> 00:02:21,165
Nun, wenn Sie Ihre Berechnung wie folgt organisieren,

33
00:02:21,165 --> 00:02:27,885
wie auf der linken Seite der Folie hier gezeigt,

34
00:02:27,885 --> 00:02:33,260
haben wir Berechnung eins, gefolgt von einer lang laufenden Berechnung,

35
00:02:33,260 --> 00:02:38,400
gefolgt von Berechnung zwei und Berechnung drei.

36
00:02:38,400 --> 00:02:41,940
Nehmen wir in dieser Anordnung an, dass Berechnung zwei von

37
00:02:41,940 --> 00:02:45,250
der lang laufenden Berechnung abhängt, die ihre Arbeit beendet,

38
00:02:45,250 --> 00:02:48,690
dann macht es Sinn, dass Berechnung zwei warten muss, bis

39
00:02:48,690 --> 00:02:53,430
die lange laufende Berechnung abgeschlossen ist, bevor sie ausgeführt wird.

40
00:02:53,430 --> 00:02:56,670
Nun, wir könnten noch ein Stück Arbeit

41
00:02:56,670 --> 00:03:00,435
zu tun haben, die durch Berechnung drei definiert ist.

42
00:03:00,435 --> 00:03:05,055
Berechnung drei kann in keiner Weise abhängig von der Berechnung zwei sein,

43
00:03:05,055 --> 00:03:11,092
oder der lang laufenden Berechnung, die abgeschlossen werden muss, bevor sie ausgeführt wird.

44
00:03:11,092 --> 00:03:12,420
Also,

45
00:03:12,420 --> 00:03:16,635
wenn wir in diesem Fall synchrone Ausführung dieser Berechnung durchführen,

46
00:03:16,635 --> 00:03:18,825
dann wird die Berechnung drei stecken bleiben,

47
00:03:18,825 --> 00:03:23,895
obwohl es keine Möglichkeit ist, abhängig von der Fertigstellung entweder der Berechnung zwei

48
00:03:23,895 --> 00:03:25,800
oder der lang laufenden Berechnung.

49
00:03:25,800 --> 00:03:29,310
So wird die Menge der Arbeit, die durch Berechnung drei zu erledigen ist,

50
00:03:29,310 --> 00:03:35,625
verzögert werden, weil es keinen eigenen Grund gibt, oder?

51
00:03:35,625 --> 00:03:41,725
Stattdessen wird aufgrund von etwas verzögert, das ihm in der Reihenfolge der Berechnung vorausgeht.

52
00:03:41,725 --> 00:03:45,735
Nun, asynchrone Berechnung, können wir diese Arbeit

53
00:03:45,735 --> 00:03:50,265
so neu anordnen, dass die Berechnung eins, wenn sie abgeschlossen ist,

54
00:03:50,265 --> 00:03:57,350
diese lang laufenden Berechnungen hervorbringen kann, die unabhängig hinter den Kulissen durchgeführt werden,

55
00:03:57,350 --> 00:04:02,706
und da die Berechnung zwei von der lang laufenden Berechnung abhängt,

56
00:04:02,706 --> 00:04:09,314
dann kann die Berechnung zwei ausgeführt werden, wenn die lange laufende Berechnung beendet ist.

57
00:04:09,314 --> 00:04:14,265
Nun, dies befreit die Berechnung drei, um fortzufahren,

58
00:04:14,265 --> 00:04:16,820
direkt nach der Berechnung eins abgeschlossen ist.

59
00:04:16,820 --> 00:04:18,585
Diese Art der Anordnung stellt also

60
00:04:18,585 --> 00:04:22,815
sicher, dass die Berechnung drei viel schneller beendet wird

61
00:04:22,815 --> 00:04:28,000
, als hinter der lang laufenden Berechnung und der Berechnung zwei stecken bleibt.

62
00:04:28,000 --> 00:04:33,945
Dieser Ansatz der Neuanordnung Ihrer Arbeit ist daher sehr nützlich, besonders

63
00:04:33,945 --> 00:04:37,650
wenn Sie eine lange laufende Berechnung haben, insbesondere wenn Sie eine

64
00:04:37,650 --> 00:04:40,000
E/A-gebundene Berechnung durchführen müssen.

65
00:04:40,000 --> 00:04:43,174
In diesem Fall können Sie die I/O-gebundene Berechnung auslösen,

66
00:04:43,174 --> 00:04:47,580
und wenn dies abgeschlossen ist,

67
00:04:47,580 --> 00:04:51,830
kann alles, was danach getan werden muss, als Rückruf an sie gesendet werden.

68
00:04:51,830 --> 00:04:54,540
Die Berechnung zwei wird also in

69
00:04:54,540 --> 00:04:58,490
einen Callback umgewandelt und dann der lang laufenden Berechnung übergeben.

70
00:04:58,490 --> 00:05:01,440
Wenn das seine Arbeit abgeschlossen ist,

71
00:05:01,440 --> 00:05:07,015
ruft es die Funktion zurück, die innerhalb des Callbacks eingeschlossen ist.

72
00:05:07,015 --> 00:05:11,020
Dies wird also sehr effektiv von Node.js genutzt, um

73
00:05:11,020 --> 00:05:17,250
die Berechnung innerhalb unserer Node-Anwendungen neu anzuordnen.

74
00:05:17,250 --> 00:05:20,740
Nun, das ist sehr,

75
00:05:20,740 --> 00:05:25,520
sehr nützlich, wenn wir uns die Art und Weise ansehen, wie Node.js selbst läuft.

76
00:05:25,520 --> 00:05:26,735
Wie wir erkennen,

77
00:05:26,735 --> 00:05:31,830
ist Node.js in einer einzelnen Thread-Ereignisschleife organisiert.

78
00:05:31,830 --> 00:05:34,690
Diese Single-Thread-Ereignisschleife

79
00:05:34,690 --> 00:05:39,620
nimmt im Grunde Anfragen auf, wie sie eingehen und sie nacheinander ausführen.

80
00:05:39,620 --> 00:05:42,592
Immer wenn eine E/A-Anforderung

81
00:05:42,592 --> 00:05:44,650
erzeugt werden muss, wird die E/A-Anforderung ausgelöst

82
00:05:44,650 --> 00:05:48,910
und jede Arbeit, die nach Abschluss der E/A-Anforderung ausgeführt werden muss,

83
00:05:48,910 --> 00:05:51,330
wird in einen Callback eingeschlossen.

84
00:05:51,330 --> 00:05:52,940
Wenn die E/A-Anforderung abgeschlossen

85
00:05:52,940 --> 00:05:55,660
ist, wird der Callback in die Anforderungswarteschlange gesetzt,

86
00:05:55,660 --> 00:05:58,510
und der Rückruf wird danach

87
00:05:58,510 --> 00:06:00,030
von der Ereignisschleife behandelt.

88
00:06:00,030 --> 00:06:02,890
Die Ereignisschleife ist also eine kontinuierlich laufende Schleife

89
00:06:02,890 --> 00:06:06,595
, die im Grunde Anfragen aus der Anforderungswarteschlange aufnimmt

90
00:06:06,595 --> 00:06:09,240
und sie dann nacheinander bedient.

91
00:06:09,240 --> 00:06:11,470
Wenn Sie also darüber nachdenken,

92
00:06:11,470 --> 00:06:14,093
erkennen Sie, dass Node.js ein einzelner Thread ist,

93
00:06:14,093 --> 00:06:15,340
aber gleichzeitig

94
00:06:15,340 --> 00:06:19,645
ist es in der Lage, viel schnellere Abschlussrate der Arbeit zu erreichen,

95
00:06:19,645 --> 00:06:24,580
einfach wegen der vernünftigen Verwendung von Callbacks

96
00:06:24,580 --> 00:06:29,680
und der asynchronen Ausführung von E/A-Anfragen,

97
00:06:29,680 --> 00:06:32,815
wie für Datei Zugriffe oder eine Datenbank

98
00:06:32,815 --> 00:06:39,280
oder eine lange laufende Verarbeitung, die unabhängig hinter den Kulissen durchgeführt werden kann.

99
00:06:39,280 --> 00:06:43,045
Nun

100
00:06:43,045 --> 00:06:48,410
ist die Art und Weise, wie die Ereignisschleife Node.js all dies behandelt, dass die Ereignisschleife in einer Folge von Phasen angeordnet ist.

101
00:06:48,410 --> 00:06:51,710
Wie Sie in dem hier gezeigten Diagramm sehen,

102
00:06:51,710 --> 00:06:55,060
umfassen die Phasen Timerhandhabung,

103
00:06:55,060 --> 00:06:58,390
I/O-Callback-Behandlung, dann haben Sie Leerlauf, Vorbereitung,

104
00:06:58,390 --> 00:07:05,800
dann die Abfrage, in der die eingehenden Anfragen für Verbindungen oder Daten behandelt werden,

105
00:07:05,800 --> 00:07:07,585
und dann die Prüfphase

106
00:07:07,585 --> 00:07:10,290
und schließlich die Callback-Phase schließen.

107
00:07:10,290 --> 00:07:16,351
Nun, einige Details darüber, was in jeder dieser Phasen getan wird, sind auf der rechten Seite aufgeführt.

108
00:07:16,351 --> 00:07:17,905
In der Timer-Phase

109
00:07:17,905 --> 00:07:21,550
verarbeitet die Ereignisschleife alles, was durch die

110
00:07:21,550 --> 00:07:25,770
Funktion setTimeout () in JavaScript ausgelöst wird.

111
00:07:25,770 --> 00:07:29,010
Die I/O-Callbacks werden ausgeführt,

112
00:07:29,010 --> 00:07:32,620
fast alle Callbacks, die

113
00:07:32,620 --> 00:07:36,795
nach einer E/A-Anforderung ausgeführt werden, werden von der I/O-Callback-Warteschlange behandelt.

114
00:07:36,795 --> 00:07:41,065
Jede dieser Phasen behält also ihre eigene separate Warteschlange,

115
00:07:41,065 --> 00:07:46,053
und die Ereignisschleife Node.js nimmt Anforderungen aus jeder dieser Warteschlangen auf und behandelt sie.

116
00:07:46,053 --> 00:07:52,150
Die, Leerlauf, Vorbereitung, ist für den internen Gebrauch durch Node.js gedacht.

117
00:07:52,150 --> 00:07:57,910
In der Umfrage werden neue E/A-Ereignisse abgerufen, die behandelt werden sollen, und vielleicht

118
00:07:57,910 --> 00:08:00,313
die Anfragen, die von außen eingehen.

119
00:08:00,313 --> 00:08:08,354
Die Close-Callback-Phase behandelt alle Socket Closures, die behandelt werden müssen, und so weiter.

120
00:08:08,354 --> 00:08:11,050
Jetzt müssen wir uns nicht zu sehr um

121
00:08:11,050 --> 00:08:15,430
all diese Details kümmern, wenn wir wirklich eine Node.js Anwendung schreiben müssen.

122
00:08:15,430 --> 00:08:19,720
Wenn erforderlich, werden wir einige dieser Details betrachten, wie und wann

123
00:08:19,720 --> 00:08:25,030
es wichtig ist, um zu verstehen, wie unsere Node-Anwendung funktioniert.

124
00:08:25,030 --> 00:08:27,985
Aber im Moment gibt Ihnen dies eine große Übersicht darüber,

125
00:08:27,985 --> 00:08:31,990
wie die Ereignisschleife Node.js behandelt wird.

126
00:08:31,990 --> 00:08:35,830
Es genügt zu sagen, dass dies ausreichend Informationen für uns ist, um

127
00:08:35,830 --> 00:08:40,590
die Node-Anwendungen zu verstehen und wie sie für den Moment funktionieren.

128
00:08:40,590 --> 00:08:42,895
Wenn Sie mehr Details wissen möchten,

129
00:08:42,895 --> 00:08:46,810
dann habe ich Ihnen einen Link zu einer detaillierten Beschreibung in der Node.js

130
00:08:46,810 --> 00:08:53,930
Dokumentation gegeben, die die Ereignisschleife ausführlicher erläutert.

131
00:08:53,930 --> 00:08:58,615
Mit diesem schnellen Verständnis von Node,

132
00:08:58,615 --> 00:09:01,445
Callbacks und Fehlerbehandlung

133
00:09:01,445 --> 00:09:03,296
werden wir zu der Übung übergehen,

134
00:09:03,296 --> 00:09:09,280
wo wir untersuchen, wie eine Node-Anwendung mit Callbacks geschrieben

135
00:09:09,280 --> 00:09:14,110
werden kann und wie Fehler innerhalb einer Node-Anwendung behandelt werden können.

136
00:09:14,110 --> 00:09:18,840
Wir werden die wiederholte Verwendung dieses Musters in nachfolgenden Übungen

137
00:09:18,840 --> 00:09:21,421
und nachfolgenden Lektionen speziell sehen,

138
00:09:21,421 --> 00:09:22,960
wenn wir Express betrachten,

139
00:09:22,960 --> 00:09:26,860
und wie wir serverseitige Anwendungen mit Express

140
00:09:26,860 --> 00:09:32,720
im späteren Teil dieses Kurses im Detail erstellen.