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

2
00:00:04,946 --> 00:00:09,700
In questo esercizio, esploreremo alcuni dei moduli nodo codice.

3
00:00:09,700 --> 00:00:15,326
In particolare, vedremo il modulo HTTP che è integrato nel nodo e

4
00:00:15,326 --> 00:00:20,411
utilizzare il modulo HTTP per configurare e avviare un semplice server web.

5
00:00:20,411 --> 00:00:28,090
Vedremo anche come possiamo servire i file statici dal nostro server HTTP nodo.

6
00:00:28,090 --> 00:00:32,510
Vedremo anche a quel modulo di file system e il modulo di percorso e

7
00:00:32,510 --> 00:00:39,640
come possono aiutarci a servire i file statici nel nostro server HTTP basato su nodo.

8
00:00:39,640 --> 00:00:43,790
Quindi cerchiamo di esplorare alcuni dei moduli nodo codice in questo esercizio.

9
00:00:45,710 --> 00:00:51,050
Per iniziare a utilizzare questo esercizio, andare in una posizione comoda sul computer.

10
00:00:51,050 --> 00:00:54,820
Quindi andremo alla cartella NodeJS che abbiamo già creato in uno

11
00:00:54,820 --> 00:00:56,400
degli esercizi precedenti.

12
00:00:56,400 --> 00:01:02,663
E nella cartella NodeJS, creerò una nuova cartella denominata node-http.

13
00:01:02,663 --> 00:01:07,370
E poi, lo imposteremo come un'applicazione nodo.

14
00:01:07,370 --> 00:01:11,440
Inoltre, spostandosi nella cartella node-http,

15
00:01:11,440 --> 00:01:16,770
creiamo una sottocartella lì chiamato pubblico che continuerà

16
00:01:16,770 --> 00:01:23,080
alcuni dei file html che ci server dalla nostra applicazione HTTP nodo.

17
00:01:23,080 --> 00:01:28,072
Ora spostandosi su un terminale, passare al nodo,

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

19
00:01:38,222 --> 00:01:43,320
E inizializziamo questa cartella per essere nella nostra applicazione.

20
00:01:43,320 --> 00:01:45,901
Quindi inizieremo con npm init e

21
00:01:45,901 --> 00:01:49,734
inizializzeremo quel pacchetto nel nostro file JSON qui.

22
00:01:49,734 --> 00:01:56,450
E poi daremo il nome del pacchetto come node-http e

23
00:01:56,450 --> 00:02:00,684
accettare la versione standard, e

24
00:02:00,684 --> 00:02:06,390
la descrizione è Node HTTP Module Esempio.

25
00:02:06,390 --> 00:02:10,830
E il punto di partenza è index.js, nessun comando di test,

26
00:02:10,830 --> 00:02:14,890
nessun repository git per il momento, e autore,

27
00:02:15,960 --> 00:02:21,460
digita il tuo nome e accetta il resto così com'è.

28
00:02:23,360 --> 00:02:27,240
E questo dovrebbe creare il pacchetto per un file manifest JSON.

29
00:02:27,240 --> 00:02:32,310
Ora apriamo questo progetto nel nostro editor preferito.

30
00:02:32,310 --> 00:02:40,860
Quindi fammi avviare il mio codice di Visual Studio in questa cartella.

31
00:02:40,860 --> 00:02:44,919
E nel codice di Visual Studio, andiamo al pacchetto nel nostro file JSON.

32
00:02:44,919 --> 00:02:51,179
E poi aggiungeremo in un altro script al pacchetto,

33
00:02:51,179 --> 00:02:54,936
al nostro file JSON chiamato start e

34
00:02:54,936 --> 00:02:58,850
che eseguirebbe indice nodo.

35
00:02:58,850 --> 00:03:02,710
E ricordati di mettere una virgola dopo l'attacco di prova.

36
00:03:04,300 --> 00:03:08,797
E salva le modifiche al file package.json.

37
00:03:08,797 --> 00:03:11,805
Ora in cui Project,

38
00:03:11,805 --> 00:03:16,720
creare un nuovo file chiamato index.js.

39
00:03:16,720 --> 00:03:24,920
Stiamo andando a configurare questo index.js per utilizzare il modulo HTTP nodo.

40
00:03:24,920 --> 00:03:29,825
Quindi, in questo file, scriviamo const

41
00:03:29,825 --> 00:03:34,160
http = require («http»).

42
00:03:34,160 --> 00:03:38,485
Così si può vedere che stiamo usando il modulo di codice HTTP, e

43
00:03:38,485 --> 00:03:44,484
stiamo richiedendo semplicemente specificando il nome del modulo di codice HTTP lì.

44
00:03:46,647 --> 00:03:48,994
Inoltre, dichiariamo,

45
00:03:52,843 --> 00:03:57,551
Un paio di costanti qui e poi,

46
00:03:59,779 --> 00:04:02,931
Chiameremo hostname e

47
00:04:02,931 --> 00:04:08,580
il numero di porta come 3000 per impostazione predefinita.

48
00:04:08,580 --> 00:04:10,990
Ora impostiamo il server.

49
00:04:10,990 --> 00:04:18,330
Per impostare il server, diremo const server = http.

50
00:04:18,330 --> 00:04:24,210
Il modulo HTTP supporta un metodo chiamato CreateServer,

51
00:04:24,210 --> 00:04:28,312
quindi utilizzeranno il metodo CreateServer su questo.

52
00:04:28,312 --> 00:04:36,670
Questo metodo CreateServer prenderà una funzione come parametro e

53
00:04:36,670 --> 00:04:40,683
questa funzione prende due

54
00:04:40,683 --> 00:04:46,560
valori come parametri, richiesta e risposta.

55
00:04:46,560 --> 00:04:49,960
E come puoi vedere, sto scrivendo una funzione freccia qui.

56
00:04:49,960 --> 00:04:54,770
Quindi la richiesta e la risposta sono i due parametri alla funzione che forniamo

57
00:04:54,770 --> 00:04:59,290
come parametro al metodo CreateServer qui.

58
00:04:59,290 --> 00:05:04,224
E all'interno di questo, diremo

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

60
00:05:10,580 --> 00:05:18,892
Quindi qui, il req e res sono la richiesta HTTP in arrivo al server.

61
00:05:18,892 --> 00:05:22,548
E loro tipo di oggetto di risposta che sta

62
00:05:22,548 --> 00:05:26,443
per essere costruito da questo server e restituito al client

63
00:05:26,443 --> 00:05:30,820
che si connette a questo server HTTP che stiamo creando qui.

64
00:05:30,820 --> 00:05:35,120
Quindi la richiesta è la richiesta in arrivo da qualsiasi browser o

65
00:05:35,120 --> 00:05:39,700
da qualsiasi luogo che sta cercando di accedere a questo server che stiamo per avviare

66
00:05:39,700 --> 00:05:45,590
utilizzando questa applicazione nodo HTTP che stiamo sviluppando qui.

67
00:05:45,590 --> 00:05:47,500
Quindi dalla richiesta,

68
00:05:47,500 --> 00:05:53,190
l'oggetto richiesta ci dà accesso alle intestazioni nella richiesta HTTP in arrivo.

69
00:05:53,190 --> 00:05:55,690
Quindi ho intenzione di registrare le

70
00:05:55,690 --> 00:06:00,420
intestazioni in arrivo della richiesta HTTP in arrivo utilizzando questo console.log.

71
00:06:00,420 --> 00:06:05,920
Solo per mia informazione, solo per sapere da dove viene questa richiesta.

72
00:06:05,920 --> 00:06:11,948
Successivamente, possiamo costruire la risposta utilizzando la res e

73
00:06:11,948 --> 00:06:16,739
questo ci fornirà un metodo chiamato StatusCode.

74
00:06:16,739 --> 00:06:24,315
Lo StatusCode ci permetterà di impostare lo StatusCode per il messaggio di risposta.

75
00:06:24,315 --> 00:06:28,026
Quindi, in questo caso, imposterò lo StatusCode come 200.

76
00:06:28,026 --> 00:06:32,259
Se ricordi dalla discussione precedente sugli elementi essenziali di rete,

77
00:06:32,259 --> 00:06:36,576
saprai che StatusCode di 200 significa che tutto va bene.

78
00:06:36,576 --> 00:06:41,856
E così, abbiamo impostato il codice di stato qui per il messaggio di risposta e

79
00:06:41,856 --> 00:06:46,763
poi ci sarà anche impostare l'intestazione per il messaggio di risposta.

80
00:06:46,763 --> 00:06:51,984
E uno dei timori di intestazione che stiamo

81
00:06:51,984 --> 00:06:56,344
per impostare è chiamato Content-Type.

82
00:06:56,344 --> 00:06:59,447
E il Content-Type,

83
00:06:59,447 --> 00:07:04,928
specificeremo questo per essere 'testo/html'.

84
00:07:04,928 --> 00:07:13,360
Quindi il corpo della risposta conterrà i dati sotto forma di html qui.

85
00:07:13,360 --> 00:07:18,740
Quindi l'intestazione è impostata per informare il client che stai inviando

86
00:07:18,740 --> 00:07:25,160
la risposta e il corpo è formattato in formato html.

87
00:07:25,160 --> 00:07:27,840
E poi, infine, diremo res.end (').

88
00:07:27,840 --> 00:07:32,500
Quindi questo termina la risposta qui, e quando questo è fatto,

89
00:07:32,500 --> 00:07:37,620
questa informazione verrà inviata al client.

90
00:07:37,620 --> 00:07:45,992
Quindi qui, lasciami costruire una pagina html in linea qui,

91
00:07:45,992 --> 00:07:52,754
quindi dirò <html><body><h1><Ciao,

92
00:07:52,754 --> 00:07:55,540
World! </h1>.

93
00:07:58,328 --> 00:08:04,211
E chiudi il tag h1, il tag body

94
00:08:04,211 --> 00:08:09,270
e il tag html, proprio lì.

95
00:08:09,270 --> 00:08:13,850
E questa è una risposta HTML valida che può

96
00:08:13,850 --> 00:08:18,100
essere rimandata dal nostro server qui.

97
00:08:18,100 --> 00:08:23,730
Quindi questo server, come ci si aspetta di andare semplicemente inviare un ciao mondo al client.

98
00:08:23,730 --> 00:08:28,320
Quindi, ora che abbiamo impostato il server, abbiamo bisogno di avviare questo server.

99
00:08:28,320 --> 00:08:32,350
Per avviare questo server in nota,

100
00:08:32,350 --> 00:08:37,930
abbiamo bisogno di dire server.listen.

101
00:08:37,930 --> 00:08:43,330
E questo avvierà la porta di ascolto su cui il server ascolterà

102
00:08:43,330 --> 00:08:45,030
le richieste in arrivo.

103
00:08:45,030 --> 00:08:50,050
E questo sarebbe iniziato al numero di porta dato il mio porto,

104
00:08:50,050 --> 00:08:53,910
che abbiamo già impostato qui nella porta const.

105
00:08:53,910 --> 00:08:59,990
E il secondo parametro è il nome host che abbiamo già impostato in precedenza.

106
00:08:59,990 --> 00:09:03,560
E il terzo parametro è una funzione che verrà

107
00:09:04,720 --> 00:09:07,520
eseguita all'avvio del server.

108
00:09:07,520 --> 00:09:13,560
In questa funzione basta andare a stampare le informazioni sul server.

109
00:09:13,560 --> 00:09:18,505
Quindi qui ho intenzione di dire console.log.

110
00:09:19,560 --> 00:09:22,110
E nel console.log,

111
00:09:22,110 --> 00:09:26,640
ho intenzione di stampare le informazioni, quindi userò una citazione indietro.

112
00:09:26,640 --> 00:09:30,876
Quindi nota l'uso della citazione posteriore non la citazione normale.

113
00:09:30,876 --> 00:09:35,103
Il motivo per cui stiamo usando questo è perché useremo

114
00:09:35,103 --> 00:09:39,830
alcune variabili all'interno della stringa che stiamo per costruire qui.

115
00:09:39,830 --> 00:09:45,608
Quindi diremo server in esecuzione a http://.

116
00:09:45,608 --> 00:09:50,965
E poi diremo $ e

117
00:09:50,965 --> 00:09:55,780
poi nome host.

118
00:09:55,780 --> 00:09:59,582
Ricordiamo che questo nome host, hai già dichiarato in precedenza.

119
00:09:59,582 --> 00:10:04,187
E poi la seconda parte,

120
00:10:04,187 --> 00:10:08,800
diremo: $ e porto.

121
00:10:08,800 --> 00:10:14,130
Quindi questi due valori saranno sostituiti con i valori corrispondenti.

122
00:10:14,130 --> 00:10:17,370
E dal momento che stiamo allegando questo tra virgolette posteriori.

123
00:10:17,370 --> 00:10:21,070
E se includi qualcosa all'interno dei rilanci del dollaro,

124
00:10:21,070 --> 00:10:26,150
che sarà sostituito dal suo valore in questa stringa qui.

125
00:10:28,230 --> 00:10:29,150
Questo è tutto.

126
00:10:29,150 --> 00:10:33,990
Abbiamo un semplice server HTTP installato e funzionante.

127
00:10:33,990 --> 00:10:37,480
Quindi salviamo le modifiche a questo.

128
00:10:37,480 --> 00:10:42,920
E andremo ad avviare la nostra applicazione e vedere cosa serve.

129
00:10:42,920 --> 00:10:47,010
Andando al terminale, digitiamo npm start, e

130
00:10:47,010 --> 00:10:50,820
questo dovrebbe avviare la nostra applicazione.

131
00:10:50,820 --> 00:10:54,020
E notiamo che stampa il nostro dicendo che il server in esecuzione

132
00:10:54,020 --> 00:10:57,420
a http://localhost:3000.

133
00:10:57,420 --> 00:11:05,950
Ora puoi accedere a questo URL digitandolo nella barra degli indirizzi di qualsiasi browser.

134
00:11:05,950 --> 00:11:09,490
Quindi fammi avviare una finestra del browser Chrome e quindi digitare questo e

135
00:11:09,490 --> 00:11:11,340
vedere cosa restituirà il server.

136
00:11:19,160 --> 00:11:20,848
Avvio di una nuova finestra.

137
00:11:20,848 --> 00:11:27,260
Permettetemi di digitare http://

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

139
00:11:34,400 --> 00:11:39,490
E questo dovrebbe restituire un Hello World come ci aspettiamo.

140
00:11:39,490 --> 00:11:47,020
Ora, quando andiamo alla console si vede che sulla console ci sono

141
00:11:48,820 --> 00:11:54,530
i dettagli dell'intestazione delle richieste in arrivo sono stampati qui.

142
00:11:54,530 --> 00:11:56,650
Alcune cose sono molto facili da individuare qui.

143
00:11:56,650 --> 00:12:02,290
Quindi questo è host, localhost: 3000, e vedi anche che «user-agent»

144
00:12:02,290 --> 00:12:08,200
è impostato su «Chrome» qui, la versione di Chrome che sto usando qui.

145
00:12:08,200 --> 00:12:14,470
Quindi questa è un'illustrazione interessante del messaggio di richiesta HTTP.

146
00:12:14,470 --> 00:12:19,860
E ciò che è contenuto nell'intestazione del messaggio di richiesta che è arrivato qui.

147
00:12:19,860 --> 00:12:24,700
Così interessante osservare ciò che il vostro server sta

148
00:12:24,700 --> 00:12:28,690
stampando sullo schermo qui.

149
00:12:28,690 --> 00:12:32,935
Con questo, completiamo la prima metà di questo esercizio.

150
00:12:32,935 --> 00:12:38,895
Ora possiamo inizializzare questa applicazione in un repository Git,

151
00:12:38,895 --> 00:12:41,505
e quindi salvare le modifiche al repository Git.

152
00:12:41,505 --> 00:12:44,695
Quindi andiamo avanti e facciamolo dopo.

153
00:12:44,695 --> 00:12:51,435
Al tipo di prompt, ottenere init, e che inizializzato il repository.

154
00:12:51,435 --> 00:12:57,420
E poi diremo git status e vedrete che questi due file sono nuovi.

155
00:12:57,420 --> 00:12:59,502
Quindi diremo git add.

156
00:12:59,502 --> 00:13:04,702
E fai git commit

157
00:13:04,702 --> 00:13:15,260
-m «Node HTTP Esempio 1".

158
00:13:15,260 --> 00:13:19,260
E poi controlla questo nel nostro repository Git.

159
00:13:19,260 --> 00:13:22,640
Ora ancora un altro strumento che è molto utile

160
00:13:22,640 --> 00:13:28,370
quando stiamo guardando applicazioni lato server è chiamato Postman.

161
00:13:28,370 --> 00:13:33,330
Ora Postman si presenta sotto forma di un'estensione del browser Chrome o

162
00:13:33,330 --> 00:13:38,430
uno strumento autonomo che è possibile scaricare e installare sul computer.

163
00:13:38,430 --> 00:13:43,998
Quindi, per farlo, nel nostro browser digitiamo http.

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

165
00:13:47,425 --> 00:13:52,550
E poi questo è dove puoi ottenere lo

166
00:13:52,550 --> 00:13:57,660
strumento Postman per il tuo sistema operativo specifico e installarlo.

167
00:13:57,660 --> 00:14:04,360
Lo strumento Postman consente di creare richieste HTTP e quindi inviarle.

168
00:14:04,360 --> 00:14:09,960
E ti dà anche la flessibilità di impostare le intestazioni per

169
00:14:09,960 --> 00:14:12,520
la tua richiesta HTTP prima di inviarla.

170
00:14:12,520 --> 00:14:16,140
E poi quando la risposta ritorna, sei in grado di esaminare la risposta

171
00:14:16,140 --> 00:14:20,500
incluse le intestazioni della risposta che ritorna dal lato server.

172
00:14:20,500 --> 00:14:23,160
Quindi trovo che Postman sia molto utile.

173
00:14:23,160 --> 00:14:25,410
Ci sono alcuni altri strumenti come questo,

174
00:14:25,410 --> 00:14:30,040
ma Postman sembra essere il migliore sul mercato al momento.

175
00:14:30,040 --> 00:14:35,010
Quindi ho intenzione di fare uso di Postman per il resto di questo corso.

176
00:14:35,010 --> 00:14:36,830
Se non si desidera installarlo, è

177
00:14:36,830 --> 00:14:41,720
anche possibile installare l'estensione del browser Chrome di Postman e quindi utilizzarlo.

178
00:14:41,720 --> 00:14:45,260
Sto per scaricare la versione macOS di Postman e

179
00:14:45,260 --> 00:14:49,130
poi installarla sulla mia macchina e poi farne uso.

180
00:14:50,230 --> 00:14:54,280
Una volta che hai il Postman, sia la versione standalone o

181
00:14:54,280 --> 00:14:57,880
l'estensione del browser Chrome installato, è possibile avviarlo.

182
00:14:57,880 --> 00:15:02,210
E vedrete che l'interfaccia utente è più o meno la stessa

183
00:15:02,210 --> 00:15:07,060
sia per la versione standard e anche l'estensione del browser Chrome.

184
00:15:07,060 --> 00:15:10,955
E una volta che il Postman è attivo e funzionante

185
00:15:10,955 --> 00:15:18,105
, digita nella casella URL richiesta,

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

187
00:15:21,510 --> 00:15:24,090
E invia la richiesta a te stesso.

188
00:15:24,090 --> 00:15:28,990
Assicurarsi che il server HTTP Node sia attivo e funzionante.

189
00:15:28,990 --> 00:15:30,440
Quindi, quando invii la richiesta,

190
00:15:30,440 --> 00:15:36,100
otterrai immediatamente una risposta dal server con il codice HTML qui.

191
00:15:36,100 --> 00:15:38,170
Ora il vantaggio, come vedi,

192
00:15:38,170 --> 00:15:43,480
con l'uso di Postman è che puoi vedere il corpo reale del messaggio.

193
00:15:43,480 --> 00:15:49,380
Puoi anche guardare le intestazioni per vedere cosa è stato inviato dal server.

194
00:15:49,380 --> 00:15:54,890
Puoi anche impostare molti dettagli in Postman quando invii.

195
00:15:54,890 --> 00:15:57,600
Richiesta dal server.

196
00:15:57,600 --> 00:16:02,930
Ora molti di questi potrebbero non essere molto facili da fare utilizzando una finestra standard del browser.

197
00:16:02,930 --> 00:16:07,092
Quindi questo è il motivo per cui preferisco usare [INAUDIBLE] per

198
00:16:07,092 --> 00:16:10,780
generare le richieste HTTP sul mio server.

199
00:16:10,780 --> 00:16:14,630
E poi osservando la risposta che ritorna dal lato server.

200
00:16:14,630 --> 00:16:20,490
Si noti inoltre che mostra il codice di stato qui e alcune altre informazioni sulla

201
00:16:21,650 --> 00:16:26,140
richiesta e il tempo di risposta dal lato server.

202
00:16:26,140 --> 00:16:31,760
Ora che abbiamo creato il suo server HTTP basato su semplice nodo,

203
00:16:31,760 --> 00:16:39,380
cerchiamo di estendere ulteriormente, creiamo un paio di file HTML nella cartella pubblica.

204
00:16:39,380 --> 00:16:43,632
Lo chiameremo questo come index.html.

205
00:16:43,632 --> 00:16:49,657
E poi anche aboutus.html,

206
00:16:49,657 --> 00:16:55,160
e quindi solo includere alcune informazioni sulle ossa nude qui.

207
00:16:55,160 --> 00:17:00,809
Quindi diremo html, e

208
00:17:00,809 --> 00:17:08,160
titolo come questo è index.html.

209
00:17:08,160 --> 00:17:15,790
E poi scriveremo nel corpo della pagina html.

210
00:17:15,790 --> 00:17:21,044
Dire h1 Index.html e

211
00:17:21,044 --> 00:17:26,298
il corpo e quindi questo è

212
00:17:26,298 --> 00:17:32,346
il contenuto di questo file.

213
00:17:32,346 --> 00:17:36,187
Alcuni codice html di base qui, fammi copiare questo e

214
00:17:36,187 --> 00:17:40,040
quindi incollare anche nella pagina aboutus.html.

215
00:17:58,607 --> 00:18:02,560
E il contenuto del file aboutus.html, è tutto.

216
00:18:02,560 --> 00:18:05,310
Abbiamo appena creato due pagine HTML, e

217
00:18:05,310 --> 00:18:09,840
queste sono pagine HTML statiche che abbiamo creato nella cartella pubblica.

218
00:18:09,840 --> 00:18:16,800
Ora, possiamo impostare il nostro server HTTP nodo per essere in grado di servire pagine statiche?

219
00:18:16,800 --> 00:18:24,030
Quindi questo è ciò che stiamo andando a configurare nella seconda parte di questo esercizio.

220
00:18:24,030 --> 00:18:27,928
Quindi tornando al file index.js,

221
00:18:27,928 --> 00:18:32,244
oltre al modulo di codice HTTP,

222
00:18:32,244 --> 00:18:38,660
importerò anche il modulo di codice del file system.

223
00:18:45,192 --> 00:18:49,920
E quel modulo di codice percorso.

224
00:18:51,230 --> 00:18:56,560
Il percorso consente di specificare la parte di un file nel file system locale.

225
00:18:56,560 --> 00:18:59,430
Il modulo file system consente di leggere e

226
00:18:59,430 --> 00:19:02,330
scrivere file dal file system locale.

227
00:19:02,330 --> 00:19:08,880
Quindi con questo, diranno server costante, http.CreateServer.

228
00:19:08,880 --> 00:19:13,583
Per il registro della console, invece di digitare intere intestazioni delle richieste,

229
00:19:13,583 --> 00:19:17,378
digiterò semplicemente informazioni sufficienti, quindi

230
00:19:17,378 --> 00:19:24,212
dirò, Richiesta per,

231
00:19:29,291 --> 00:19:32,329
Solo l'URL di quella richiesta.

232
00:19:39,786 --> 00:19:41,195
Per metodo.

233
00:19:46,917 --> 00:19:51,218
Quindi il metodo sarebbe ottenere il post della porta o eliminare i metodi.

234
00:19:51,218 --> 00:19:56,450
Quindi questo registrerà queste informazioni.

235
00:19:56,450 --> 00:20:01,478
Ora, quello che faremo è invece di inviare

236
00:20:01,478 --> 00:20:06,440
questa risposta, la risposta standard hello world.

237
00:20:06,440 --> 00:20:11,176
Qui, ci accingiamo ad esaminare il metodo e

238
00:20:11,176 --> 00:20:16,600
poi diremo se req.method è uguale a GET.

239
00:20:16,600 --> 00:20:21,689
Quindi serviremo solo richieste GET in questo esempio.

240
00:20:25,904 --> 00:20:28,750
Altrimenti, diremo che c'è un if.

241
00:20:28,750 --> 00:20:34,035
Quindi, se c'è una richiesta GET che entra,

242
00:20:34,035 --> 00:20:36,911
allora esamineremo,

243
00:20:42,139 --> 00:20:47,577
L'URL che entra,

244
00:20:47,577 --> 00:20:55,304
quindi diremo se req.url è/,

245
00:20:55,304 --> 00:21:03,615
diremo FileURL uguale a html.

246
00:21:03,615 --> 00:21:06,645
Quindi, se non si ottiene un nome di file specifico, ma

247
00:21:06,645 --> 00:21:10,380
si invia semplicemente la richiesta al codice host locale 3000.

248
00:21:10,380 --> 00:21:15,371
Sarà predefinito il index.html,

249
00:21:15,371 --> 00:21:22,460
altrimenti dirà che FileURL è uguale a req.url.

250
00:21:24,650 --> 00:21:28,148
Quindi in questo modo, hai costruito quale file al server.

251
00:21:28,148 --> 00:21:35,929
Ora, diremo Troveremo il percorso del file,

252
00:21:35,929 --> 00:21:41,279
diremo percorso, Resolve,

253
00:21:41,279 --> 00:21:48,404
quindi il modulo percorso supporta questo metodo di risoluzione, quindi

254
00:21:52,013 --> 00:21:57,331
questo tradurrà questo nel file completo delle cartelle percorso,

255
00:21:57,331 --> 00:22:01,096
il file che abbiamo appena costruito,

256
00:22:01,096 --> 00:22:05,620
il FileUrl che abbiamo appena costruito.

257
00:22:05,620 --> 00:22:10,480
Quindi questo ci darà il percorso completo per il file, e

258
00:22:10,480 --> 00:22:17,000
poi diremo costante FileExtension.

259
00:22:17,000 --> 00:22:21,524
Quindi, se vuoi assicurarti che

260
00:22:21,524 --> 00:22:26,808
l'estensione del nome del file sia HTML.

261
00:22:30,003 --> 00:22:32,904
Quindi, dal FilePath,

262
00:22:32,904 --> 00:22:38,402
esamineremo l'estensione del nome del file e

263
00:22:38,402 --> 00:22:42,710
poi diremo se FileExt ==.

264
00:22:42,710 --> 00:22:47,270
Quindi, se si tratta di un file HTML, allora sappiamo come servirlo da questa particolare

265
00:22:48,410 --> 00:22:51,830
relazione del server HTTP nodo.

266
00:22:51,830 --> 00:22:57,025
Quindi diremo se l'estensione del file è HTML, allora sappiamo che

267
00:22:57,025 --> 00:23:02,835
il file è un file HTML e abbiamo i due file, indice e aboutus.html.

268
00:23:02,835 --> 00:23:06,986
Quindi controlleremo per vedere se questo file esiste, quindi

269
00:23:06,986 --> 00:23:11,435
diremo se il file esiste, FilePath.

270
00:23:11,435 --> 00:23:17,915
Quindi il metodo exists controllerà se il file esiste,

271
00:23:17,915 --> 00:23:24,180
quindi diremo fs.exists (FilePath),

272
00:23:24,180 --> 00:23:26,860
e questo prenderà

273
00:23:29,780 --> 00:23:34,170
come secondo parametro, una funzione di richiamo.

274
00:23:34,170 --> 00:23:39,180
Quindi notare l'uso della prima funzione di richiamo nel nostro esempio.

275
00:23:39,180 --> 00:23:46,430
Quindi questa funzione di callback verrà chiamata con questo parametro esiste lì dentro.

276
00:23:46,430 --> 00:23:50,740
Quindi all'interno di questo parametro di callback, questo esiste sarà vero o falso.

277
00:23:50,740 --> 00:23:54,160
Quindi questo è il parametro return per questa funzione di callback.

278
00:23:54,160 --> 00:23:58,336
Quindi qui, controlleremo, e

279
00:23:58,336 --> 00:24:02,584
diremo se (! esiste), quindi

280
00:24:02,584 --> 00:24:08,248
il che significa che il file non esiste,

281
00:24:08,248 --> 00:24:14,241
allora diremo res.statusCode = 404.

282
00:24:14,241 --> 00:24:19,107
Ricordiamo che se il file non esiste, invierai un codice di stato di 404 dicendo che

283
00:24:19,107 --> 00:24:20,608
non puoi trovare il file.

284
00:24:20,608 --> 00:24:26,393
E poi diremo res.setHeader,

285
00:24:26,393 --> 00:24:33,996
e imposteremo l'intestazione su 'Content-Type',

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

287
00:24:42,729 --> 00:24:51,940
E poi abbiamo bisogno di inviare il, file HTML qui, o il codice HTML.

288
00:24:51,940 --> 00:24:59,150
Quindi farò il codice HTML di base, il corpo html h1.

289
00:25:01,582 --> 00:25:05,590
Errore 404,

290
00:25:05,590 --> 00:25:12,378
diremo, + FileURL +

291
00:25:17,421 --> 00:25:20,668
'non trovato'.

292
00:25:24,185 --> 00:25:31,670
E chiudere, La pagina HTML.

293
00:25:31,670 --> 00:25:36,560
Quindi qui, come noti, stai usando la funzione esiste del

294
00:25:36,560 --> 00:25:41,350
modulo del file system per verificare se il file esiste.

295
00:25:41,350 --> 00:25:43,670
Quindi dai il percorso del file come primo parametro e

296
00:25:43,670 --> 00:25:45,970
il secondo è la funzione di callback.

297
00:25:45,970 --> 00:25:51,380
All' interno di questa funzione di callback, se dice che esiste è falso, allora

298
00:25:51,380 --> 00:25:58,010
invierai un messaggio di errore standard 404, dicendo che non è possibile trovare il file.

299
00:25:58,010 --> 00:26:01,420
E dopo averlo fatto, ci sarà semplicemente,

300
00:26:04,918 --> 00:26:08,088
tornare, altrimenti,

301
00:26:10,507 --> 00:26:16,151
Diciamo res.statusCode

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

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

304
00:26:37,154 --> 00:26:41,950
Ora, dobbiamo leggere il file e poi inviare il file.

305
00:26:41,950 --> 00:26:44,950
Quindi questo è dove, dal modulo del file system,

306
00:26:44,950 --> 00:26:50,510
useremo il CreateReadStream,

307
00:26:50,510 --> 00:26:54,770
che prenderà il FilePath come parametro.

308
00:26:54,770 --> 00:27:00,810
Quindi questo metodo CreateReadStream leggerà nel file da questo FilePath.

309
00:27:00,810 --> 00:27:05,930
E poi convertirlo in flusso di byte,

310
00:27:05,930 --> 00:27:10,530
e poi lo reindirizzeranno alla risposta.

311
00:27:10,530 --> 00:27:15,300
Così che sarà incluso nella risposta, nel corpo della risposta.

312
00:27:15,300 --> 00:27:17,978
Quindi in questo modo abbiamo appena preso il file e

313
00:27:17,978 --> 00:27:22,274
poi costruito nella risposta qui.

314
00:27:22,274 --> 00:27:26,640
E questo è tutto, il file è pronto per essere inviato, ok?

315
00:27:26,640 --> 00:27:29,875
Quindi questo è se l'estensione del file è html,

316
00:27:29,875 --> 00:27:34,740
stiamo controllando per assicurarci che tu gestisca correttamente questo.

317
00:27:34,740 --> 00:27:38,770
Quindi questo è dove leggerai il file e poi lo invierai.

318
00:27:38,770 --> 00:27:46,560
Se l'estensione del file non è html, ovviamente, abbiamo bisogno di inviare un messaggio di errore.

319
00:27:46,560 --> 00:27:51,481
Quindi proprio lì vedremo, copieremo questo

320
00:27:51,481 --> 00:27:56,890
particolare, Codice da qui.

321
00:27:58,774 --> 00:28:03,364
E poi incollalo li' dentro.

322
00:28:03,364 --> 00:28:10,553
Diciamo, altrimenti statusCode = 404, testo contesto/html,

323
00:28:10,553 --> 00:28:16,685
e il messaggio di errore dice, Errore 404, FileURL.

324
00:28:16,685 --> 00:28:20,849
Non è stato trovato,

325
00:28:20,849 --> 00:28:25,250
ma non è un file HTML.

326
00:28:25,250 --> 00:28:28,648
Quindi questo è l'errore che invieremo in questo caso.

327
00:28:28,648 --> 00:28:34,384
E infine, per l'ultimo caso,

328
00:28:34,384 --> 00:28:39,650
quindi qui stiamo dicendo il metodo.

329
00:28:39,650 --> 00:28:44,910
Quindi questo altro corrisponde al metodo di richiesta.

330
00:28:44,910 --> 00:28:48,230
Quindi, se il metodo di richiesta non è GET, ma qualche altro metodo di richiesta,

331
00:28:48,230 --> 00:28:54,380
allora non gestiremo che in questa versione la nostra applicazione Node.

332
00:28:54,380 --> 00:28:58,333
Quindi invieremo indietro StatusCode 404,

333
00:28:58,333 --> 00:29:02,759
Content html, e diremo Errore 404.

334
00:29:04,100 --> 00:29:09,117
E diremo, metodo req,

335
00:29:11,763 --> 00:29:16,394
Non, supportato,

336
00:29:16,394 --> 00:29:21,800
non supportato da questo server HTML nodo qui, il gioco è fatto.

337
00:29:21,800 --> 00:29:28,667
Con queste modifiche, ora siamo pronti a riavviare il nostro browser.

338
00:29:28,667 --> 00:29:33,850
E poi lascia che serva i file HTML qui.

339
00:29:35,800 --> 00:29:42,351
Quindi cerchiamo di salvare le modifiche, E poi andare a riavviare il nostro server, e

340
00:29:42,351 --> 00:29:48,018
poi esaminare ciò che invia quando inviamo varie richieste al server.

341
00:29:48,018 --> 00:29:51,974
Andando al terminale, se il server è in esecuzione,

342
00:29:51,974 --> 00:29:56,398
interromperlo digitando Ctrl+C, quindi riavviare il server.

343
00:29:56,398 --> 00:30:00,490
E quando il server è attivo e funzionante, inviamo alcune richieste ad esso.

344
00:30:00,490 --> 00:30:05,722
In primo luogo, da un browser, e successivamente da Postman.

345
00:30:05,722 --> 00:30:10,340
Vai nella finestra del browser, digitiamo localhost: 3000 e

346
00:30:10,340 --> 00:30:16,320
vediamo che questo restituisce il file index.html come ci aspettiamo.

347
00:30:16,320 --> 00:30:21,073
E poi diremo localhost: 3000/index.html,

348
00:30:21,073 --> 00:30:24,974
e questo restituirà anche il file index.html.

349
00:30:24,974 --> 00:30:32,530
Ora, se inviamo aboutus.html, dice Aboutus.html, e lo restituisce correttamente.

350
00:30:32,530 --> 00:30:38,390
Vediamo ora inviare una richiesta per aboutus.txt, e vedere cosa fa.

351
00:30:38,390 --> 00:30:43,365
Quindi dice che /aboutus.txt non è un file HTML.

352
00:30:43,365 --> 00:30:49,992
Quindi inviamo una richiesta a test.html.

353
00:30:49,992 --> 00:30:56,005
E sappiamo che test.html non esiste, quindi dice /test.html non trovato.

354
00:30:56,005 --> 00:31:01,185
Quindi vediamo che utilizzando il browser, siamo in grado di recuperare

355
00:31:01,185 --> 00:31:06,620
quei file che esistono, e il server è in grado di inviare i file al browser.

356
00:31:06,620 --> 00:31:10,420
Andiamo ora a Postman e proviamo a generare le stesse richieste,

357
00:31:10,420 --> 00:31:13,400
e vedere la risposta dal server.

358
00:31:13,400 --> 00:31:20,280
Quindi, andando a Postman, inviamo una richiesta GET a localhost: 3000/.

359
00:31:20,280 --> 00:31:25,150
E vedi che questo restituisce il file index.html.

360
00:31:25,150 --> 00:31:30,530
Inviamo una richiesta a aboutus.html.

361
00:31:30,530 --> 00:31:35,159
E poi vedi che restituisce il file aboutus.html.

362
00:31:35,159 --> 00:31:38,650
E poi invieremo una richiesta al file di testo,

363
00:31:38,650 --> 00:31:42,240
e poi dice errore 404, non un file HTML.

364
00:31:42,240 --> 00:31:46,920
E vedrete che lo stato qui dice, 404 non trovato.

365
00:31:46,920 --> 00:31:51,400
E poi noi, invece di inviare una richiesta GET,

366
00:31:51,400 --> 00:31:56,730
vedere questo è il vantaggio di utilizzare Postman, invierò una richiesta PUT.

367
00:31:56,730 --> 00:32:01,040
E noterai che questo dice, Errore: PUT non supportato, e

368
00:32:01,040 --> 00:32:04,800
così con lo stato 404 qui, e così via.

369
00:32:04,800 --> 00:32:11,010
Quindi questo è il modo in cui è possibile configurare un server HTTP nodo

370
00:32:11,010 --> 00:32:16,600
per essere in grado di servire file, file HTTP in questo caso particolare.

371
00:32:16,600 --> 00:32:19,420
Ora puoi facilmente immaginare di estendere

372
00:32:19,420 --> 00:32:23,900
questo server HTTP per gestire molti tipi diversi di file e così via.

373
00:32:23,900 --> 00:32:25,630
Ma naturalmente, di conseguenza,

374
00:32:25,630 --> 00:32:30,350
il codice diventerà anche più complicato di quello che abbiamo in questo momento.

375
00:32:30,350 --> 00:32:33,140
Con questo, completiamo questo esercizio.

376
00:32:33,140 --> 00:32:38,589
In questo esercizio, abbiamo visto come possiamo impostare un semplice

377
00:32:38,589 --> 00:32:45,356
server HTTP basato su nodo che serve i file dal nostro sito server.

378
00:32:45,356 --> 00:32:48,260
[ MUSIC]