1
00:00:00,000 --> 00:00:04,946
[MUSIC]

2
00:00:04,946 --> 00:00:09,700
In dieser Übung werden wir einige der Code-Knoten-Module untersuchen.

3
00:00:09,700 --> 00:00:15,326
Insbesondere werden wir uns das HTTP-Modul ansehen, das in Node integriert ist und

4
00:00:15,326 --> 00:00:20,411
das HTTP-Modul verwenden, um einen einfachen Webserver zu konfigurieren und zu starten.

5
00:00:20,411 --> 00:00:28,090
Wir werden auch untersuchen, wie wir statische Dateien von unserem Knoten HTTP-Server bereitstellen können.

6
00:00:28,090 --> 00:00:32,510
Wir werden auch dieses Dateisystemmodul und das Pfadmodul betrachten und

7
00:00:32,510 --> 00:00:39,640
wie sie uns helfen können, statische Dateien in unserem node-basierten HTTP-Server bereitzustellen.

8
00:00:39,640 --> 00:00:43,790
Lassen Sie uns also einige der Code-Knoten-Module in dieser Übung untersuchen.

9
00:00:45,710 --> 00:00:51,050
Um mit dieser Übung zu beginnen, wechseln Sie zu einem geeigneten Speicherort auf Ihrem Computer.

10
00:00:51,050 --> 00:00:54,820
Also werden wir zu dem NodeJS-Ordner gehen, den wir bereits in einer

11
00:00:54,820 --> 00:00:56,400
der vorherigen Übungen erstellt haben.

12
00:00:56,400 --> 00:01:02,663
Und im NodeJS-Ordner werde ich einen neuen Ordner namens node-http erstellen.

13
00:01:02,663 --> 00:01:07,370
Und dann werden wir dies als Knotenanwendung einrichten.

14
00:01:07,370 --> 00:01:11,440
Auch in den Node-http-Ordner zu bewegen,

15
00:01:11,440 --> 00:01:16,770
lassen Sie uns einen Unterordner dort mit dem Namen public erstellen,

16
00:01:16,770 --> 00:01:23,080
der einige der HTML-Dateien fortsetzen wird, die wir von unserer Node HTTP-Anwendung Server werden.

17
00:01:23,080 --> 00:01:28,072
Wechseln Sie nun zu einem Terminal, navigieren Sie zum Knoten,

18
00:01:32,012 --> 00:01:33,478
-http Ordner.

19
00:01:38,222 --> 00:01:43,320
Und lassen Sie uns diesen Ordner initialisieren, um in unserer Anwendung zu sein.

20
00:01:43,320 --> 00:01:45,901
Also beginnen wir mit npm init und

21
00:01:45,901 --> 00:01:49,734
initialisieren dieses Paket in unsere JSON-Datei hier.

22
00:01:49,734 --> 00:01:56,450
Und dann geben wir den Paketnamen als node-http und

23
00:01:56,450 --> 00:02:00,684
akzeptieren Sie die Standardversion, und

24
00:02:00,684 --> 00:02:06,390
die Beschreibung ist Knoten HTTP-Modul Beispiel.

25
00:02:06,390 --> 00:02:10,830
Und der Ausgangspunkt ist index.js, kein Testbefehl,

26
00:02:10,830 --> 00:02:14,890
kein Git-Repository für den Moment, und Autor,

27
00:02:15,960 --> 00:02:21,460
geben Sie Ihren Namen ein und akzeptieren Sie den Rest wie es ist.

28
00:02:23,360 --> 00:02:27,240
Und das sollte das Paket für eine JSON-Manifestdatei erstellen.

29
00:02:27,240 --> 00:02:32,310
Nun lassen Sie uns dieses Projekt in unserem Lieblings-Editor öffnen.

30
00:02:32,310 --> 00:02:40,860
Lassen Sie mich also meinen Visual Studio-Code in diesem Ordner starten.

31
00:02:40,860 --> 00:02:44,919
Und im Visual Studio-Code gehen wir zum Paket in unsere JSON-Datei.

32
00:02:44,919 --> 00:02:51,179
Und dann werden wir in einem anderen Skript zum Paket hinzufügen,

33
00:02:51,179 --> 00:02:54,936
zu unserer JSON-Datei namens start und

34
00:02:54,936 --> 00:02:58,850
die Knoten Index ausführen würde.

35
00:02:58,850 --> 00:03:02,710
Und denken Sie daran, nach dem Test ein Komma zu setzen.

36
00:03:04,300 --> 00:03:11,805
Und speichern Sie die Änderungen in der Datei package.json.

37
00:03:11,805 --> 00:03:16,720
Erstellen Sie nun in Project eine neue Datei namens index.js.

38
00:03:16,720 --> 00:03:24,920
Wir werden diese index.js konfigurieren, um den Knoten HTTP-Modul zu verwenden.

39
00:03:24,920 --> 00:03:29,825
Also geben wir in dieser Datei const

40
00:03:29,825 --> 00:03:34,160
http = require („http“) ein.

41
00:03:34,160 --> 00:03:38,485
So können Sie sehen, dass wir das HTTP-Code-Modul verwenden, und

42
00:03:38,485 --> 00:03:44,484
wir benötigen es, indem Sie einfach den Namen des HTTP-Codemoduls dort angeben.

43
00:03:46,647 --> 00:03:48,994
Darüber hinaus, Lassen Sie uns erklären,

44
00:03:52,843 --> 00:03:57,551
Ein paar Konstanten hier und dann,

45
00:03:59,779 --> 00:04:02,931
Wir rufen Hostname und

46
00:04:02,931 --> 00:04:08,580
die Portnummer als 3000 standardmäßig.

47
00:04:08,580 --> 00:04:10,990
Nun lassen Sie uns den Server einrichten.

48
00:04:10,990 --> 00:04:18,330
Um den Server einzurichten, sagen wir const server = http.

49
00:04:18,330 --> 00:04:24,210
Das HTTP-Modul unterstützt eine Methode namens CreateServer,

50
00:04:24,210 --> 00:04:28,312
so dass sie die CreateServer-Methode verwenden.

51
00:04:28,312 --> 00:04:36,670
Diese CreateServer-Methode wird eine Funktion als Parameter nehmen und

52
00:04:36,670 --> 00:04:40,683
diese Funktion nimmt zwei

53
00:04:40,683 --> 00:04:46,560
Werte als Parameter, Anfrage und Antwort.

54
00:04:46,560 --> 00:04:49,960
Und wie Sie sehen können, schreibe ich hier eine Pfeilfunktion.

55
00:04:49,960 --> 00:04:54,770
Die Anfrage und Antwort sind also die beiden Parameter für die Funktion, die wir

56
00:04:54,770 --> 00:04:59,290
hier als Parameter für die CreateServer-Methode liefern.

57
00:04:59,290 --> 00:05:04,224
Und darin werden wir

58
00:05:04,224 --> 00:05:10,580
console.log (req.headers) sagen.

59
00:05:10,580 --> 00:05:18,892
Hier sind die req und res die eingehende HTTP-Anforderung an den Server.

60
00:05:18,892 --> 00:05:22,548
Und sie spawning Response-Objekt, das

61
00:05:22,548 --> 00:05:26,443
von diesem Server konstruiert und an den Client zurückgegeben wird

62
00:05:26,443 --> 00:05:30,820
, der mit diesem HTTP-Server verbindet, den wir hier erstellen.

63
00:05:30,820 --> 00:05:35,120
Die Anfrage ist also die eingehende Anfrage von jedem Browser oder

64
00:05:35,120 --> 00:05:39,700
von überall, der versucht, auf diesen Server zuzugreifen, den wir

65
00:05:39,700 --> 00:05:45,590
mit dieser HTTP-Knoten-Anwendung starten, die wir hier entwickeln.

66
00:05:45,590 --> 00:05:47,500
Aus der Anfrage

67
00:05:47,500 --> 00:05:53,190
gibt uns das Anforderungsobjekt Zugriff auf die Header in der eingehenden HTTP-Anfrage.

68
00:05:53,190 --> 00:05:55,690
Also werde ich die eingehenden

69
00:05:55,690 --> 00:06:00,420
Header der HTTP-Anfrage protokollieren, die mit dieser console.log eingeht.

70
00:06:00,420 --> 00:06:05,920
Nur zu meiner Information, nur um zu wissen, woher diese Anfrage kommt.

71
00:06:05,920 --> 00:06:11,948
Danach können wir die Antwort konstruieren, indem wir die res verwenden und

72
00:06:11,948 --> 00:06:16,739
dies wird uns eine Methode namens StatusCode zur Verfügung stellen.

73
00:06:16,739 --> 00:06:24,315
Der StatusCode ermöglicht es uns, den StatusCode für die Antwortnachricht einzurichten.

74
00:06:24,315 --> 00:06:28,026
In diesem Fall werde ich den StatusCode als 200 einrichten.

75
00:06:28,026 --> 00:06:32,259
Wenn Sie sich aus der früheren Diskussion über Netzwerk-Essentials erinnern,

76
00:06:32,259 --> 00:06:36,576
werden Sie wissen, dass StatusCode von 200 bedeutet, dass alles in Ordnung ist.

77
00:06:36,576 --> 00:06:41,856
Und so richten wir hier den Statuscode für die Antwortnachricht ein und

78
00:06:41,856 --> 00:06:46,763
dann werden wir auch den Header für die Antwortnachricht einrichten.

79
00:06:46,763 --> 00:06:51,984
Und eine der Kopfbefürchtungen, die wir

80
00:06:51,984 --> 00:06:56,344
einrichten werden, heißt Content-Type.

81
00:06:56,344 --> 00:06:59,447
Und der Content-Type,

82
00:06:59,447 --> 00:07:04,928
wir werden dies angeben, um 'text/html' zu sein.

83
00:07:04,928 --> 00:07:13,360
Der Antwortkörper enthält also hier die Daten in Form von HTML.

84
00:07:13,360 --> 00:07:18,740
Der Header ist also eingerichtet, um den Client zu informieren, dass Sie

85
00:07:18,740 --> 00:07:25,160
die Antwort senden und der Text im HTML-Format formatiert ist.

86
00:07:25,160 --> 00:07:27,840
Und dann schließlich sagen wir res.end ('').

87
00:07:27,840 --> 00:07:32,500
Dies beendet also die Antwort hier, und wenn dies geschehen ist,

88
00:07:32,500 --> 00:07:37,620
werden diese Informationen an den Client zurückgesendet.

89
00:07:37,620 --> 00:07:45,992
Also hier, lassen Sie mich einfach eine Inline-HTML-Seite hier erstellen,

90
00:07:45,992 --> 00:07:52,754
also werde ich sagen <html><body><h1><Hallo,

91
00:07:52,754 --> 00:07:55,540
Welt! </h1>.

92
00:07:58,328 --> 00:08:04,211
Und schließen Sie das h1-Tag, das body-Tag

93
00:08:04,211 --> 00:08:09,270
und das html-Tag, genau dort.

94
00:08:09,270 --> 00:08:13,850
Und das ist eine gültige HTML-Antwort, die

95
00:08:13,850 --> 00:08:18,100
von unserem Server hier zurückgeschickt werden kann.

96
00:08:18,100 --> 00:08:23,730
Also dieser Server, wie Sie erwarten, einfach gehen eine Hallo Welt an den Client senden.

97
00:08:23,730 --> 00:08:28,320
Nun, da wir den Server eingerichtet haben, müssen wir diesen Server starten.

98
00:08:28,320 --> 00:08:32,350
Um diesen Server in Notiz zu starten,

99
00:08:32,350 --> 00:08:37,930
müssen wir sagen server.listen.

100
00:08:37,930 --> 00:08:43,330
Und dies startet den Listening-Port, auf dem der Server auf

101
00:08:43,330 --> 00:08:45,030
eingehende Anfragen wartet.

102
00:08:45,030 --> 00:08:50,050
Und das würde an der Portnummer gestartet werden,

103
00:08:50,050 --> 00:08:53,910
die meinen Port gegeben hat, den wir bereits hier im const Port eingerichtet haben.

104
00:08:53,910 --> 00:08:59,990
Und der zweite Parameter ist der Hostname, den wir bereits früher eingerichtet haben.

105
00:08:59,990 --> 00:09:03,560
Und der dritte Parameter ist eine Funktion, die

106
00:09:04,720 --> 00:09:07,520
ausgeführt wird, wenn der Server startet.

107
00:09:07,520 --> 00:09:13,560
In dieser Funktion drucken wir nur die Informationen über den Server aus.

108
00:09:13,560 --> 00:09:18,505
Also hier drin werde ich nur console.log sagen.

109
00:09:19,560 --> 00:09:22,110
Und in der console.log

110
00:09:22,110 --> 00:09:26,640
werde ich die Informationen ausdrucken, damit ich ein Back-Zitat verwenden werde.

111
00:09:26,640 --> 00:09:30,876
Beachten Sie also die Verwendung von Back-Zitat nicht das normale Zitat.

112
00:09:30,876 --> 00:09:35,103
Der Grund, warum wir das verwenden, ist, weil wir

113
00:09:35,103 --> 00:09:39,830
einige Variablen innerhalb der Zeichenfolge verwenden werden, die wir hier konstruieren werden.

114
00:09:39,830 --> 00:09:45,608
Also sagen wir Server läuft unter http://.

115
00:09:45,608 --> 00:09:50,965
Und dann werden wir $ und

116
00:09:50,965 --> 00:09:55,780
dann Hostname sagen.

117
00:09:55,780 --> 00:09:59,582
Daran erinnern, dass dieser Hostname, Sie bereits zuvor deklariert haben.

118
00:09:59,582 --> 00:10:04,187
Und dann der zweite Teil,

119
00:10:04,187 --> 00:10:08,800
werden wir sagen: $ und Port.

120
00:10:08,800 --> 00:10:14,130
Diese beiden Werte werden also durch die entsprechenden Werte ersetzt.

121
00:10:14,130 --> 00:10:17,370
Und da wir dies in hinteren Anführungszeichen einschließen.

122
00:10:17,370 --> 00:10:21,070
Und wenn Sie etwas in Dollar-Erhöhungen einschließen,

123
00:10:21,070 --> 00:10:26,150
wird das hier durch seinen Wert in dieser Zeichenfolge ersetzt.

124
00:10:28,230 --> 00:10:29,150
Das war's.

125
00:10:29,150 --> 00:10:33,990
Wir haben einen einfachen HTTP-Server und läuft.

126
00:10:33,990 --> 00:10:37,480
Also lassen Sie uns die Änderungen daran speichern.

127
00:10:37,480 --> 00:10:42,920
Und wir gehen und starten unsere Anwendung und sehen, was sie dient.

128
00:10:42,920 --> 00:10:47,010
Gehen wir zum Terminal, geben wir npm start ein, und

129
00:10:47,010 --> 00:10:50,820
dies sollte unsere Anwendung starten.

130
00:10:50,820 --> 00:10:54,020
Und wir bemerken, dass es unser Sprichwort ausdruckt, dass Server läuft

131
00:10:54,020 --> 00:10:57,420
auf http://localhost:3000.

132
00:10:57,420 --> 00:11:05,950
Jetzt können Sie auf diese URL zugreifen, indem Sie sie in die Adressleiste eines beliebigen Browsers eingeben.

133
00:11:05,950 --> 00:11:09,490
Lassen Sie mich also ein Chrome-Browserfenster starten und geben Sie dies ein und

134
00:11:09,490 --> 00:11:11,340
sehen Sie, was der Server zurückgeben wird.

135
00:11:19,160 --> 00:11:20,848
Starten eines neuen Fensters.

136
00:11:20,848 --> 00:11:27,260
Lassen Sie mich einfach http://

137
00:11:30,028 --> 00:11:34,400
localhost: 3000 eingeben.

138
00:11:34,400 --> 00:11:39,490
Und das sollte eine Hello World zurückgeben, wie wir es erwarten.

139
00:11:39,490 --> 00:11:47,020
Wenn wir nun zur Konsole gehen, sehen Sie, dass auf der Konsole

140
00:11:48,820 --> 00:11:54,530
Details der eingehenden Anfragen Header hier ausgedruckt werden.

141
00:11:54,530 --> 00:11:56,650
Einige Dinge sind hier sehr einfach zu finden.

142
00:11:56,650 --> 00:12:02,290
Das ist also host, localhost: 3000, und Sie sehen auch, dass der „user-Agent“

143
00:12:02,290 --> 00:12:08,200
hier auf „Chrome“ gesetzt ist, die Chrome-Version, die ich hier verwende.

144
00:12:08,200 --> 00:12:14,470
Das ist also eine interessante Illustration der HTTP-Anforderungsnachricht.

145
00:12:14,470 --> 00:12:19,860
Und was in der Kopfzeile der Anforderungsnachricht enthalten ist, die hier hereinkam.

146
00:12:19,860 --> 00:12:24,700
So interessant zu beobachten, was Ihr Server

147
00:12:24,700 --> 00:12:28,690
hier auf den Bildschirm ausdruckt.

148
00:12:28,690 --> 00:12:32,935
Damit schließen wir die erste Hälfte dieser Übung ab.

149
00:12:32,935 --> 00:12:38,895
Jetzt können wir diese Anwendung in ein Git-Repository initialisieren

150
00:12:38,895 --> 00:12:41,505
und dann die Änderungen im Git-Repository speichern.

151
00:12:41,505 --> 00:12:44,695
Also gehen wir weiter und machen das als nächstes.

152
00:12:44,695 --> 00:12:51,435
Geben Sie an der Eingabeaufforderung init ab, und das hat das Repository initialisiert.

153
00:12:51,435 --> 00:12:57,420
Und dann sagen wir git status und Sie sehen, dass diese beiden Dateien neu sind.

154
00:12:57,420 --> 00:12:59,502
Also sagen wir git add.

155
00:12:59,502 --> 00:13:04,702
Und git commit

156
00:13:04,702 --> 00:13:15,260
-m „Knoten HTTP Example 1".

157
00:13:15,260 --> 00:13:19,260
Und dann überprüfe das in unser Git-Repository.

158
00:13:19,260 --> 00:13:22,640
Jetzt noch ein weiteres Tool, das sehr nützlich ist

159
00:13:22,640 --> 00:13:28,370
, wenn wir auf serverseitige Anwendungen suchen, heißt Postman.

160
00:13:28,370 --> 00:13:33,330
Jetzt Postman kommt in Form von entweder einer Chrome-Browsererweiterung oder

161
00:13:33,330 --> 00:13:38,430
einem eigenständigen Tool, das Sie herunterladen und auf Ihrem Computer installieren können.

162
00:13:38,430 --> 00:13:43,998
Also, um das zu tun, lassen Sie uns in unserem Browser http eingeben.

163
00:13:43,998 --> 00:13:47,425
getpostman.com.

164
00:13:47,425 --> 00:13:52,550
Und dann können Sie hier das

165
00:13:52,550 --> 00:13:57,660
Postman-Tool für Ihr spezifisches Betriebssystem erhalten und es installieren. Mit

166
00:13:57,660 --> 00:14:04,360
dem Postman-Tool können Sie HTTP-Anfragen erstellen und dann senden.

167
00:14:04,360 --> 00:14:09,960
Und es gibt Ihnen auch die Flexibilität, die Header für

168
00:14:09,960 --> 00:14:12,520
Ihre HTTP-Anfrage einzurichten, bevor Sie sie einsenden.

169
00:14:12,520 --> 00:14:16,140
Und wenn die Antwort zurückkommt, können Sie die Antwort

170
00:14:16,140 --> 00:14:20,500
einschließlich der Header der Antwort untersuchen, die von der Serverseite zurückkommt.

171
00:14:20,500 --> 00:14:23,160
Also finde ich Postman sehr nützlich.

172
00:14:23,160 --> 00:14:25,410
Es gibt ein paar andere Werkzeuge wie diese,

173
00:14:25,410 --> 00:14:30,040
aber Postman scheint derzeit der beste auf dem Markt zu sein.

174
00:14:30,040 --> 00:14:35,010
Also werde ich Postman durch den Rest dieses Kurses nutzen.

175
00:14:35,010 --> 00:14:36,830
Wenn Sie es nicht installieren möchten,

176
00:14:36,830 --> 00:14:41,720
können Sie auch die Chrome-Browser-Erweiterung von Postman installieren und dann verwenden.

177
00:14:41,720 --> 00:14:45,260
Ich werde die macOS-Version von Postman herunterladen und

178
00:14:45,260 --> 00:14:49,130
sie dann auf meinem Computer installieren und dann nutzen.

179
00:14:50,230 --> 00:14:54,280
Sobald Sie den Postman, entweder die Standalone-Version oder

180
00:14:54,280 --> 00:14:57,880
die Chrome-Browser-Erweiterung installiert haben, können Sie es starten.

181
00:14:57,880 --> 00:15:02,210
Und Sie werden sehen, dass die Benutzeroberfläche

182
00:15:02,210 --> 00:15:07,060
sowohl für die Standardversion als auch für die Chrome-Browsererweiterung mehr oder weniger gleich ist.

183
00:15:07,060 --> 00:15:10,955
Und sobald Sie den Postboten ausgeführt haben,

184
00:15:10,955 --> 00:15:18,105
geben Sie in das Feld Request URL

185
00:15:18,105 --> 00:15:21,510
localhost: 3000 ein.

186
00:15:21,510 --> 00:15:24,090
Und senden Sie die Anfrage an sich.

187
00:15:24,090 --> 00:15:28,990
Stellen Sie sicher, dass Ihr Knoten HTTP-Server betriebsbereit ist.

188
00:15:28,990 --> 00:15:30,440
Wenn Sie also die Anfrage senden,

189
00:15:30,440 --> 00:15:36,100
würden Sie sofort eine Antwort vom Server mit dem HTML-Code hier erhalten.

190
00:15:36,100 --> 00:15:38,170
Nun ist der Vorteil, wie Sie sehen,

191
00:15:38,170 --> 00:15:43,480
bei der Verwendung von Postman, dass Sie den eigentlichen Text der Nachricht sehen können.

192
00:15:43,480 --> 00:15:49,380
Sie können sich auch die Header ansehen, um zu sehen, was vom Server zurückgesendet wurde.

193
00:15:49,380 --> 00:15:54,890
Sie können auch viele Details in Postman einrichten, wenn Sie senden.

194
00:15:54,890 --> 00:15:57,600
Anfrage vom Server.

195
00:15:57,600 --> 00:16:02,930
Jetzt sind viele von ihnen möglicherweise nicht sehr einfach mit einem Standard-Browserfenster zu tun.

196
00:16:02,930 --> 00:16:07,092
Das ist der Grund, warum ich es vorziehe, [INAUDIBLE] zu verwenden, um

197
00:16:07,092 --> 00:16:10,780
die HTTP-Anfragen an meinen Server zu generieren.

198
00:16:10,780 --> 00:16:14,630
Und dann beobachten Sie die Antwort, die von der Serverseite zurückkommt.

199
00:16:14,630 --> 00:16:20,490
Beachten Sie auch, dass hier der Statuscode und einige andere Informationen über

200
00:16:21,650 --> 00:16:26,140
die Anfrage und die Antwortzeit von der Serverseite angezeigt werden.

201
00:16:26,140 --> 00:16:31,760
Nun, da wir seinen einfachen Knoten basierten HTTP-Server erstellt haben,

202
00:16:31,760 --> 00:16:39,380
lassen Sie uns es weiter erweitern, lassen Sie uns ein paar HTML-Dateien im Öffentlichen Ordner erstellen.

203
00:16:39,380 --> 00:16:43,632
Wir werden es als index.html nennen.

204
00:16:43,632 --> 00:16:49,657
Und dann auch aboutus.html,

205
00:16:49,657 --> 00:16:55,160
und dann fügen Sie einfach einige nackte Knochen Informationen in hier.

206
00:16:55,160 --> 00:17:00,809
Also sagen wir html, und

207
00:17:00,809 --> 00:17:08,160
Titel wie Dies ist index.html.

208
00:17:08,160 --> 00:17:15,790
Und dann geben wir den Text der HTML-Seite ein.

209
00:17:15,790 --> 00:17:21,044
Sagen Sie h1 Index.html

210
00:17:21,044 --> 00:17:26,298
und den Körper und dann ist dies

211
00:17:26,298 --> 00:17:32,346
der Inhalt dieser Datei.

212
00:17:32,346 --> 00:17:36,187
Einige grundlegende HTML-Code hier, lassen Sie mich dies kopieren und

213
00:17:36,187 --> 00:17:40,040
dann auch in die aboutus.html Seite einfügen.

214
00:17:58,607 --> 00:18:02,560
Und der Inhalt der Datei aboutus.html, das war's.

215
00:18:02,560 --> 00:18:05,310
Wir haben gerade zwei HTML-Seiten erstellt, und

216
00:18:05,310 --> 00:18:09,840
dies sind statische HTML-Seiten, die wir im Öffentlichen Ordner erstellt haben.

217
00:18:09,840 --> 00:18:16,800
Können wir nun unseren Knoten HTTP-Server einrichten, um statische Seiten bereitstellen zu können?

218
00:18:16,800 --> 00:18:24,030
Das ist also, was wir im zweiten Teil dieser Übung konfigurieren werden.

219
00:18:24,030 --> 00:18:27,928
Also gehe ich zurück zur Datei index.js,

220
00:18:27,928 --> 00:18:32,244
zusätzlich zum HTTP-Code-Modul,

221
00:18:32,244 --> 00:18:38,660
werde ich auch das Dateisystem-Code-Modul importieren.

222
00:18:45,192 --> 00:18:49,920
Und das Pfadcode-Modul. Mit

223
00:18:51,230 --> 00:18:56,560
dem Pfad können Sie den Teil einer Datei in Ihrem lokalen Dateisystem angeben. Mit

224
00:18:56,560 --> 00:18:59,430
dem Dateisystemmodul können Sie

225
00:18:59,430 --> 00:19:02,330
Dateien aus Ihrem lokalen Dateisystem lesen und schreiben.

226
00:19:02,330 --> 00:19:08,880
Damit werden sie also konstanter Server, http.CreateServer sagen.

227
00:19:08,880 --> 00:19:13,583
Für das Konsolenprotokoll, anstatt ganze Anforderungsheader

228
00:19:13,583 --> 00:19:17,378
einzugeben, werde ich einfach nur ausreichende Informationen eingeben, also

229
00:19:17,378 --> 00:19:24,212
werde ich sagen, Anfrage für,

230
00:19:29,291 --> 00:19:32,329
Nur die URL dieser Anfrage.

231
00:19:39,786 --> 00:19:41,195
Nach Methode.

232
00:19:46,917 --> 00:19:51,218
Die Methode wäre also entweder Port-Post oder Delete-Methoden.

233
00:19:51,218 --> 00:19:56,450
Dies wird also diese Informationen protokollieren.

234
00:19:56,450 --> 00:20:01,478
Nun, was wir tun werden, ist, anstatt

235
00:20:01,478 --> 00:20:06,440
diese Antwort zu senden, die Standard-Hallo Welt-Antwort.

236
00:20:06,440 --> 00:20:11,176
Hier werden wir die Methode untersuchen und

237
00:20:11,176 --> 00:20:16,600
dann werden wir sagen, ob req.method gleich GET ist.

238
00:20:16,600 --> 00:20:21,689
So werden wir nur GET-Anfragen in diesem Beispiel bedienen.

239
00:20:25,904 --> 00:20:28,750
Andernfalls werden wir sagen, dass es ein Wenn gibt.

240
00:20:28,750 --> 00:20:34,035
Also, wenn es eine GET-Anfrage gibt, die in kommt

241
00:20:34,035 --> 00:20:36,911
, dann werden wir untersuchen,

242
00:20:42,139 --> 00:20:47,577
die URL, die in kommt,

243
00:20:47,577 --> 00:20:55,304
also sagen wir, wenn req.url/ist,

244
00:20:55,304 --> 00:21:03,615
sagen wir FileURL gleich html.

245
00:21:03,615 --> 00:21:06,645
Wenn Sie also keinen bestimmten Dateinamen erhalten, aber

246
00:21:06,645 --> 00:21:10,380
Sie senden nur eine Anfrage an den lokalen Hostcode 3000.

247
00:21:10,380 --> 00:21:15,371
Es wird standardmäßig auf die index.html gesetzt,

248
00:21:15,371 --> 00:21:22,460
sonst wird FileURL gleich req.url.

249
00:21:24,650 --> 00:21:28,148
Auf diese Weise haben Sie konstruiert, welche Datei Server ist.

250
00:21:28,148 --> 00:21:35,929
Jetzt werden wir sagen, Wir werden den Pfad der Datei finden,

251
00:21:35,929 --> 00:21:41,279
wir sagen Pfad, Resolve,

252
00:21:41,279 --> 00:21:48,404
also unterstützt das Pfadmodul diese Auflösungsmethode, also wird

253
00:21:52,013 --> 00:21:57,331
dies in die vollwertige Pfadordnerdatei übersetzen,

254
00:21:57,331 --> 00:22:01,096
die Datei, die wir gerade erstellt haben,

255
00:22:01,096 --> 00:22:05,620
die FileURL, die wir gerade erstellt haben.

256
00:22:05,620 --> 00:22:10,480
Dies wird uns also den vollständigen Pfad für die Datei geben, und

257
00:22:10,480 --> 00:22:17,000
dann sagen wir konstante FileExtension.

258
00:22:17,000 --> 00:22:21,524
Also, wenn Sie sicherstellen möchten, dass

259
00:22:21,524 --> 00:22:26,808
die Dateinamenerweiterung HTML ist.

260
00:22:30,003 --> 00:22:32,904
Aus dem FilePath

261
00:22:32,904 --> 00:22:38,402
werden wir die Dateinamenerweiterung untersuchen und

262
00:22:38,402 --> 00:22:42,710
dann sagen wir, ob FileExt ==.

263
00:22:42,710 --> 00:22:47,270
Wenn es sich also um eine HTML-Datei handelt, dann wissen wir, wie man es aus dieser speziellen

264
00:22:48,410 --> 00:22:51,830
Beziehung des Knotens HTTP-Server bedient.

265
00:22:51,830 --> 00:22:57,025
Also werden wir sagen, wenn die Dateierweiterung HTML ist, dann wissen wir, dass

266
00:22:57,025 --> 00:23:02,835
die Datei eine HTML-Datei ist und wir haben die beiden Dateien, Index und aboutus.html.

267
00:23:02,835 --> 00:23:06,986
Also werden wir überprüfen, ob diese Datei existiert, also

268
00:23:06,986 --> 00:23:11,435
sagen wir, ob Datei existiert, FilePath.

269
00:23:11,435 --> 00:23:17,915
Die Methode existiert also, um zu sehen, ob die Datei existiert,

270
00:23:17,915 --> 00:23:24,180
also sagen wir fs.exists (FilePath),

271
00:23:24,180 --> 00:23:26,860
und dieser wird

272
00:23:29,780 --> 00:23:34,170
als zweiter Parameter eine Rückruffunktion nehmen.

273
00:23:34,170 --> 00:23:39,180
Beachten Sie also die Verwendung der ersten Rückruffunktion in unserem Beispiel.

274
00:23:39,180 --> 00:23:46,430
So wird diese Callback-Funktion aufgerufen, wobei dieser Parameter dort vorhanden ist.

275
00:23:46,430 --> 00:23:50,740
In diesem Callback-Parameter wird dies entweder wahr oder falsch sein.

276
00:23:50,740 --> 00:23:54,160
Dies ist also der Rückgabeparameter für diese Callback-Funktion.

277
00:23:54,160 --> 00:23:58,336
Also hier, Wir werden überprüfen, und

278
00:23:58,336 --> 00:24:02,584
wir werden sagen, ob (! existiert),

279
00:24:02,584 --> 00:24:08,248
was bedeutet, dass die Datei nicht existiert,

280
00:24:08,248 --> 00:24:14,241
dann sagen wir res.StatusCode = 404. Denken Sie

281
00:24:14,241 --> 00:24:19,107
daran, dass, wenn die Datei nicht existiert, Sie einen Statuscode von 404 senden, der besagt, dass

282
00:24:19,107 --> 00:24:20,608
Sie die Datei nicht finden können.

283
00:24:20,608 --> 00:24:26,393
Und dann sagen wir res.setHeader,

284
00:24:26,393 --> 00:24:33,996
und wir setzen den Header auf 'Content-Type',

285
00:24:37,305 --> 00:24:39,587
'text/html'.

286
00:24:42,729 --> 00:24:51,940
Und dann müssen wir die HTML-Datei hier oder den HTML-Code senden.

287
00:24:51,940 --> 00:24:59,150
Also werde ich den grundlegenden HTML-Code, html body h1 tun.

288
00:25:01,582 --> 00:25:05,590
Fehler 404,

289
00:25:05,590 --> 00:25:12,378
wir sagen, + FileURL +

290
00:25:17,421 --> 00:25:20,668
'nicht gefunden'.

291
00:25:24,185 --> 00:25:31,670
Und schließen Sie, Die HTML-Seite.

292
00:25:31,670 --> 00:25:36,560
Hier, wie Sie bemerken, verwenden Sie die Funktion existiert

293
00:25:36,560 --> 00:25:41,350
des Dateisystemmoduls, um zu überprüfen, ob die Datei existiert.

294
00:25:41,350 --> 00:25:43,670
Sie geben also den Dateipfad als ersten Parameter an, und

295
00:25:43,670 --> 00:25:45,970
der zweite ist die Callback-Funktion.

296
00:25:45,970 --> 00:25:51,380
Wenn in dieser Callback-Funktion angegeben wird, dass das existiert falsch ist,

297
00:25:51,380 --> 00:25:58,010
senden Sie die Standardfehlermeldung 404 zurück, die besagt, dass Sie die Datei nicht finden können.

298
00:25:58,010 --> 00:26:01,420
Und nachdem wir dies tun, werden wir einfach,

299
00:26:04,918 --> 00:26:08,088
zurückkehren, sonst,

300
00:26:10,507 --> 00:26:16,151
Wir sagen res.StatusCode

301
00:26:16,151 --> 00:26:22,267
= 200, res.setHeader,

302
00:26:26,156 --> 00:26:32,481
('Content-Type', 'text/html').

303
00:26:37,154 --> 00:26:41,950
Jetzt müssen wir die Datei einlesen und dann die Datei aussenden.

304
00:26:41,950 --> 00:26:44,950
Hier

305
00:26:44,950 --> 00:26:50,510
werden wir also aus dem Dateisystemmodul den CreateReadStream verwenden

306
00:26:50,510 --> 00:26:54,770
, der den FilePath als Parameter verwendet.

307
00:26:54,770 --> 00:27:00,810
Diese CreateReadStream-Methode wird also die Datei aus diesem FilePath einlesen.

308
00:27:00,810 --> 00:27:05,930
Und dann konvertieren Sie das in Byte-Stream,

309
00:27:05,930 --> 00:27:10,530
und dann werden sie dies an die Antwort übergeben.

310
00:27:10,530 --> 00:27:15,300
Das wird also in die Antwort aufgenommen, im Körper der Antwort.

311
00:27:15,300 --> 00:27:17,978
Auf diese Weise haben wir gerade die Datei genommen und

312
00:27:17,978 --> 00:27:22,274
sie dann in die Antwort hier aufgebaut.

313
00:27:22,274 --> 00:27:26,640
Und das war's, die Akte ist bereit, verschickt zu werden, okay?

314
00:27:26,640 --> 00:27:29,875
Wenn also die Dateierweiterung html ist,

315
00:27:29,875 --> 00:27:34,740
überprüfen wir, um sicherzustellen, dass Sie dies richtig behandeln.

316
00:27:34,740 --> 00:27:38,770
Hier werden Sie die Datei einlesen und sie dann versenden.

317
00:27:38,770 --> 00:27:46,560
Wenn die Dateierweiterung nicht html ist, müssen wir natürlich eine Fehlermeldung senden.

318
00:27:46,560 --> 00:27:51,481
Also genau dort werden wir sehen, wir werden diesen

319
00:27:51,481 --> 00:27:56,890
speziellen Code von hier kopieren.

320
00:27:58,774 --> 00:28:03,364
Und dann kleben Sie es dort hinein.

321
00:28:03,364 --> 00:28:10,553
Wir sagen, sonst StatusCode = 404, Context text/html,

322
00:28:10,553 --> 00:28:16,685
und die Fehlermeldung sagt, Fehler 404, FileURL.

323
00:28:16,685 --> 00:28:20,849
Es wurde nicht gefunden, aber

324
00:28:20,849 --> 00:28:25,250
es ist keine HTML-Datei.

325
00:28:25,250 --> 00:28:28,648
Das ist also der Fehler, den wir in diesem Fall zurücksenden werden.

326
00:28:28,648 --> 00:28:34,384
Und schließlich, für den letzten anderen Fall,

327
00:28:34,384 --> 00:28:39,650
also hier sagen wir die Methode.

328
00:28:39,650 --> 00:28:44,910
Das entspricht also der Anforderungsmethode.

329
00:28:44,910 --> 00:28:48,230
Also, wenn die Anforderungsmethode nicht GET ist, sondern eine andere Anforderungsmethode,

330
00:28:48,230 --> 00:28:54,380
dann werden wir das in dieser Version unserer Node-Anwendung nicht behandeln.

331
00:28:54,380 --> 00:28:58,333
Also senden wir zurück StatusCode 404,

332
00:28:58,333 --> 00:29:02,759
Inhalt html, und wir sagen Fehler 404.

333
00:29:04,100 --> 00:29:09,117
Und wir werden sagen,, req Methode,

334
00:29:11,763 --> 00:29:16,394
Nicht, Unterstützt,

335
00:29:16,394 --> 00:29:21,800
nicht von diesem Knoten HTML-Server hier unterstützt, das ist es.

336
00:29:21,800 --> 00:29:28,667
Mit diesen Änderungen sind wir nun bereit, unseren Browser neu zu starten.

337
00:29:28,667 --> 00:29:33,850
Und dann lassen Sie es die HTML-Dateien hier servieren.

338
00:29:35,800 --> 00:29:42,351
Also lassen Sie uns die Änderungen speichern, und dann gehen und starten Sie unseren Server neu, und

339
00:29:42,351 --> 00:29:48,018
dann untersuchen, was er sendet, wenn wir verschiedene Anfragen an den Server senden.

340
00:29:48,018 --> 00:29:51,974
Gehen Sie zum Terminal, wenn Ihr Server läuft,

341
00:29:51,974 --> 00:29:56,398
stoppen Sie ihn, indem Sie Strg+C eingeben, und starten Sie den Server neu.

342
00:29:56,398 --> 00:30:00,490
Und wenn der Server betriebsbereit ist, senden wir einige Anfragen an ihn.

343
00:30:00,490 --> 00:30:05,722
Zuerst von einem Browser und danach von Postman.

344
00:30:05,722 --> 00:30:10,340
Gehen Sie in Ihr Browserfenster, geben Sie localhost:3000 ein und

345
00:30:10,340 --> 00:30:16,320
sehen Sie, dass dies die Datei index.html zurückgibt, wie wir erwarten.

346
00:30:16,320 --> 00:30:21,073
Und dann sagen wir localhost: 3000/index.html,

347
00:30:21,073 --> 00:30:24,974
und dies wird auch die Datei index.html zurückgeben.

348
00:30:24,974 --> 00:30:32,530
Nun, wenn wir aboutus.html senden, heißt es Aboutus.html, und es gibt es richtig zurück.

349
00:30:32,530 --> 00:30:38,390
Lassen Sie uns jetzt eine Anfrage für aboutus.txt senden und sehen, was es tut.

350
00:30:38,390 --> 00:30:43,365
Also sagt es /aboutus.txt ist keine HTML-Datei.

351
00:30:43,365 --> 00:30:49,992
Dann lassen Sie uns eine Anfrage an test.html senden.

352
00:30:49,992 --> 00:30:56,005
Und wir wissen, dass test.html nicht existiert, also heißt es /test.html nicht gefunden.

353
00:30:56,005 --> 00:31:01,185
Wir sehen also, dass wir durch die Verwendung des Browsers

354
00:31:01,185 --> 00:31:06,620
die vorhandenen Dateien abrufen können und der Server die Dateien an den Browser senden kann.

355
00:31:06,620 --> 00:31:10,420
Lassen Sie uns nun zu Postman gehen und versuchen, die gleichen Anfragen zu generieren,

356
00:31:10,420 --> 00:31:13,400
und sehen Sie die Antwort vom Server.

357
00:31:13,400 --> 00:31:20,280
Als nächstes gehen wir zu Postman, lassen Sie uns eine GET-Anfrage an localhost senden: 3000/.

358
00:31:20,280 --> 00:31:25,150
Und Sie sehen, dass dies die Datei index.html zurückgibt.

359
00:31:25,150 --> 00:31:30,530
Lassen Sie uns eine Anfrage an aboutus.html senden.

360
00:31:30,530 --> 00:31:35,159
Und dann sehen Sie, dass es die Datei aboutus.html zurückgibt.

361
00:31:35,159 --> 00:31:38,650
Und dann senden wir eine Anfrage an die Textdatei,

362
00:31:38,650 --> 00:31:42,240
und dann steht Fehler 404, keine HTML-Datei.

363
00:31:42,240 --> 00:31:46,920
Und Sie werden sehen, dass der Status hier sagt, 404 nicht gefunden.

364
00:31:46,920 --> 00:31:51,400
Und dann werden wir, anstatt eine GET-Anfrage zu senden,

365
00:31:51,400 --> 00:31:56,730
sehen, dass dies der Vorteil der Verwendung von Postman ist, ich werde eine PUT-Anfrage senden.

366
00:31:56,730 --> 00:32:01,040
Und Sie werden feststellen, dass dies sagt, Fehler: PUT nicht unterstützt, und

367
00:32:01,040 --> 00:32:04,800
so mit dem Status 404 hier, und so weiter.

368
00:32:04,800 --> 00:32:11,010
So können Sie einen Knoten HTTP-Server konfigurieren,

369
00:32:11,010 --> 00:32:16,600
um Dateien, HTTP-Dateien in diesem speziellen Fall bereitstellen zu können.

370
00:32:16,600 --> 00:32:19,420
Jetzt können Sie sich leicht vorstellen,

371
00:32:19,420 --> 00:32:23,900
diesen HTTP-Server auf viele verschiedene Arten von Dateien zu erweitern und so weiter.

372
00:32:23,900 --> 00:32:25,630
Aber natürlich

373
00:32:25,630 --> 00:32:30,350
wird der Code entsprechend auch komplizierter als das, was wir in diesem Moment haben.

374
00:32:30,350 --> 00:32:33,140
Damit schließen wir diese Übung ab.

375
00:32:33,140 --> 00:32:38,589
In dieser Übung haben wir gesehen, wie wir einen einfachen

376
00:32:38,589 --> 00:32:45,356
knotenbasierten HTTP-Server einrichten können, der Dateien von unserer Server-Site bereitstellt.

377
00:32:45,356 --> 00:32:48,260
( MUSIK)