1
00:00:00,000 --> 00:00:04,946
[MÚSICA]

2
00:00:04,946 --> 00:00:09,700
Neste exercício, vamos explorar alguns dos módulos de nó de código.

3
00:00:09,700 --> 00:00:15,326
Em particular, vamos olhar para o módulo HTTP que é construído em Node e

4
00:00:15,326 --> 00:00:20,411
usar o módulo HTTP para configurar e iniciar um servidor web simples.

5
00:00:20,411 --> 00:00:28,090
Vamos também olhar para como podemos servir arquivos estáticos do nosso servidor HTTP Node.

6
00:00:28,090 --> 00:00:32,510
Nós também vamos olhar para esse módulo de sistema de arquivos e o módulo de caminho e

7
00:00:32,510 --> 00:00:39,640
como eles podem nos ajudar a servir arquivos estáticos em nosso servidor HTTP baseado em nós.

8
00:00:39,640 --> 00:00:43,790
Então vamos explorar alguns dos módulos de nó de código neste exercício.

9
00:00:45,710 --> 00:00:51,050
Para começar com este exercício, vá para um local conveniente no seu computador.

10
00:00:51,050 --> 00:00:54,820
Então, vamos para a pasta NodeJS que já criamos em um

11
00:00:54,820 --> 00:00:56,400
dos exercícios anteriores.

12
00:00:56,400 --> 00:01:02,663
E na pasta NodeJS, vou criar uma nova pasta chamada node-http.

13
00:01:02,663 --> 00:01:07,370
E, em seguida, vamos configurar isso como um aplicativo Node.

14
00:01:07,370 --> 00:01:11,440
Além disso, movendo-se para a pasta node-http,

15
00:01:11,440 --> 00:01:16,770
vamos criar uma sub-pasta lá chamada public que vai continuar

16
00:01:16,770 --> 00:01:23,080
alguns dos arquivos html que vamos servidor a partir de nosso aplicativo Node HTTP.

17
00:01:23,080 --> 00:01:28,072
Agora movendo-se para um terminal, navegue até o nó,

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

19
00:01:38,222 --> 00:01:43,320
E vamos inicializar esta pasta para estar em nosso aplicativo.

20
00:01:43,320 --> 00:01:45,901
Então vamos começar com npm init e

21
00:01:45,901 --> 00:01:49,734
inicializar esse pacote para o nosso arquivo JSON aqui.

22
00:01:49,734 --> 00:01:56,450
E, em seguida, vamos dar o nome do pacote como node-http e

23
00:01:56,450 --> 00:02:00,684
aceitar a versão padrão,

24
00:02:00,684 --> 00:02:06,390
ea descrição é Node Exemplo de Módulo HTTP.

25
00:02:06,390 --> 00:02:10,830
E o ponto de partida é index.js, nenhum comando test,

26
00:02:10,830 --> 00:02:14,890
nenhum repositório git para o momento, e autor,

27
00:02:15,960 --> 00:02:21,460
digite seu nome e aceite o resto como está.

28
00:02:23,360 --> 00:02:27,240
E isso deve criar o pacote para um arquivo de manifesto JSON.

29
00:02:27,240 --> 00:02:32,310
Agora vamos abrir este projeto em nosso editor favorito.

30
00:02:32,310 --> 00:02:40,860
Então deixe-me iniciar o meu código do Visual Studio nesta pasta.

31
00:02:40,860 --> 00:02:44,919
E no código do Visual Studio, vamos para o pacote para o nosso arquivo JSON.

32
00:02:44,919 --> 00:02:51,179
E, em seguida, vamos adicionar em outro script para o pacote,

33
00:02:51,179 --> 00:02:54,936
para o nosso arquivo JSON chamado start e

34
00:02:54,936 --> 00:02:58,850
que iria executar índice nó.

35
00:02:58,850 --> 00:03:02,710
E lembre-se de colocar uma vírgula após o engate do teste.

36
00:03:04,300 --> 00:03:08,797
E salve as alterações no arquivo package.json.

37
00:03:08,797 --> 00:03:11,805
Agora em que Project,

38
00:03:11,805 --> 00:03:16,720
crie um novo arquivo chamado index.js.

39
00:03:16,720 --> 00:03:24,920
Vamos configurar este index.js para usar o módulo Nó HTTP.

40
00:03:24,920 --> 00:03:29,825
Então, neste arquivo, vamos digitar const

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

42
00:03:34,160 --> 00:03:38,485
Então você pode ver que estamos usando o módulo de código HTTP, e

43
00:03:38,485 --> 00:03:44,484
estamos exigindo isso simplesmente especificando o nome do módulo de código HTTP lá.

44
00:03:46,647 --> 00:03:48,994
Além disso, vamos declarar,

45
00:03:52,843 --> 00:03:57,551
Um par de constantes aqui e, em seguida,

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

47
00:04:02,931 --> 00:04:08,580
o número da porta como 3000 por padrão.

48
00:04:08,580 --> 00:04:10,990
Agora vamos configurar o servidor.

49
00:04:10,990 --> 00:04:18,330
Para configurar o servidor, vamos dizer servidor const = http.

50
00:04:18,330 --> 00:04:24,210
O módulo HTTP suporta um método chamado CreateServer,

51
00:04:24,210 --> 00:04:28,312
então eles vão usar o método CreateServer sobre isso.

52
00:04:28,312 --> 00:04:36,670
Este método CreateServer terá uma função como um parâmetro e

53
00:04:36,670 --> 00:04:40,683
esta função leva dois

54
00:04:40,683 --> 00:04:46,560
valores como parâmetros, solicitação e resposta.

55
00:04:46,560 --> 00:04:49,960
E como você pode ver, estou escrevendo uma função de seta aqui.

56
00:04:49,960 --> 00:04:54,770
Assim, a solicitação e resposta são os dois parâmetros para a função que fornecemos

57
00:04:54,770 --> 00:04:59,290
como um parâmetro para o método CreateServer aqui.

58
00:04:59,290 --> 00:05:04,224
E dentro disso, diremos

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

60
00:05:10,580 --> 00:05:18,892
Então, aqui, o req e res são a solicitação HTTP de entrada para o servidor.

61
00:05:18,892 --> 00:05:22,548
E eles tipo de geração de objeto de resposta que vai

62
00:05:22,548 --> 00:05:26,443
ser construído por este servidor e retornado para o cliente

63
00:05:26,443 --> 00:05:30,820
que se conecta a este servidor HTTP que estamos criando aqui.

64
00:05:30,820 --> 00:05:35,120
Então a solicitação é a solicitação de entrada de qualquer navegador ou

65
00:05:35,120 --> 00:05:39,700
de qualquer lugar que está tentando acessar este servidor que vamos iniciar

66
00:05:39,700 --> 00:05:45,590
usando este aplicativo de nó HTTP que estamos desenvolvendo aqui.

67
00:05:45,590 --> 00:05:47,500
Assim, a partir da

68
00:05:47,500 --> 00:05:53,190
solicitação, o objeto request nos dá acesso aos cabeçalhos na solicitação HTTP de entrada.

69
00:05:53,190 --> 00:05:55,690
Então eu vou registrar

70
00:05:55,690 --> 00:06:00,420
os cabeçalhos de entrada da solicitação HTTP entrando usando este console.log.

71
00:06:00,420 --> 00:06:05,920
Só para minha informação, só para saber de onde vem este pedido.

72
00:06:05,920 --> 00:06:11,948
Depois disso, podemos construir a resposta usando o res e

73
00:06:11,948 --> 00:06:16,739
isso nos fornecerá um método chamado StatusCode.

74
00:06:16,739 --> 00:06:24,315
O StatusCode nos permitirá configurar o StatusCode para a mensagem de resposta.

75
00:06:24,315 --> 00:06:28,026
Então, neste caso, vou configurar o StatusCode como 200.

76
00:06:28,026 --> 00:06:32,259
Se você se lembrar da discussão anterior sobre os fundamentos de rede,

77
00:06:32,259 --> 00:06:36,576
você saberá que StatusCode de 200 significa que tudo está bem.

78
00:06:36,576 --> 00:06:41,856
E assim, nós configuramos o código de status aqui para a mensagem de resposta e

79
00:06:41,856 --> 00:06:46,763
, em seguida, vamos também configurar o cabeçalho para a mensagem de resposta.

80
00:06:46,763 --> 00:06:51,984
E um dos temores de cabeçalho que vamos

81
00:06:51,984 --> 00:06:56,344
configurar é chamado Content-Type.

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

83
00:06:59,447 --> 00:07:04,928
vamos especificar isso para ser 'text/html'.

84
00:07:04,928 --> 00:07:13,360
Assim, o corpo de resposta irá conter os dados na forma de html aqui.

85
00:07:13,360 --> 00:07:18,740
Portanto, o cabeçalho é configurado para informar o cliente que você está enviando

86
00:07:18,740 --> 00:07:25,160
na resposta e o corpo é formatado no formato html.

87
00:07:25,160 --> 00:07:27,840
E então, finalmente, vamos dizer res.end ('').

88
00:07:27,840 --> 00:07:32,500
Então isso termina a resposta aqui, e quando isso for feito,

89
00:07:32,500 --> 00:07:37,620
essa informação será enviada de volta para o cliente.

90
00:07:37,620 --> 00:07:45,992
Então aqui, deixe-me apenas construir uma página html in-line aqui,

91
00:07:45,992 --> 00:07:52,754
então eu vou dizer <html><body><h1><Olá,

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

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

94
00:08:04,211 --> 00:08:09,270
e a tag html, bem ali.

95
00:08:09,270 --> 00:08:13,850
E essa é uma resposta HTML válida que pode

96
00:08:13,850 --> 00:08:18,100
ser enviada de volta do nosso servidor aqui.

97
00:08:18,100 --> 00:08:23,730
Então este servidor, como você espera simplesmente vai enviar um Olá mundo para o cliente.

98
00:08:23,730 --> 00:08:28,320
Então, agora que configuramos o servidor, precisamos iniciar este servidor.

99
00:08:28,320 --> 00:08:32,350
Para iniciar este servidor em nota,

100
00:08:32,350 --> 00:08:37,930
precisamos dizer server.listen.

101
00:08:37,930 --> 00:08:43,330
E isso iniciará a porta de escuta na qual o servidor escutará

102
00:08:43,330 --> 00:08:45,030
solicitações recebidas.

103
00:08:45,030 --> 00:08:50,050
E isso seria iniciado no número da porta dado o meu porto,

104
00:08:50,050 --> 00:08:53,910
que nós já configuramos aqui no porto const.

105
00:08:53,910 --> 00:08:59,990
E o segundo parâmetro é o nome do host que já configuramos anteriormente.

106
00:08:59,990 --> 00:09:03,560
E o terceiro parâmetro é uma função que será

107
00:09:04,720 --> 00:09:07,520
executada quando o servidor for iniciado.

108
00:09:07,520 --> 00:09:13,560
Nesta função, basta ir para imprimir as informações sobre o servidor.

109
00:09:13,560 --> 00:09:18,505
Então, aqui eu vou apenas dizer console.log.

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

111
00:09:22,110 --> 00:09:26,640
eu vou imprimir as informações para que eu vou usar uma citação traseira.

112
00:09:26,640 --> 00:09:30,876
Portanto, note o uso de aspas não a cotação normal.

113
00:09:30,876 --> 00:09:35,103
A razão pela qual estamos usando isso é porque nós vamos estar usando

114
00:09:35,103 --> 00:09:39,830
algumas variáveis dentro da string que estamos indo para construir aqui.

115
00:09:39,830 --> 00:09:45,608
Então, vamos dizer servidor em execução em http://.

116
00:09:45,608 --> 00:09:50,965
E, em seguida, vamos dizer $ e

117
00:09:50,965 --> 00:09:55,780
, em seguida, nome do host.

118
00:09:55,780 --> 00:09:59,582
Lembre-se que este nome de host, você já declarou anteriormente.

119
00:09:59,582 --> 00:10:04,187
E, em seguida, a segunda parte,

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

121
00:10:08,800 --> 00:10:14,130
Portanto, esses dois valores serão substituídos pelos valores correspondentes.

122
00:10:14,130 --> 00:10:17,370
E já que estamos encerrando isso entre aspas.

123
00:10:17,370 --> 00:10:21,070
E se você incluir algo dentro dos aumentos do dólar,

124
00:10:21,070 --> 00:10:26,150
que será substituído por seu valor nesta string aqui.

125
00:10:28,230 --> 00:10:29,150
É isso.

126
00:10:29,150 --> 00:10:33,990
Temos um servidor HTTP simples em funcionamento.

127
00:10:33,990 --> 00:10:37,480
Então, vamos salvar as alterações para isso.

128
00:10:37,480 --> 00:10:42,920
E vamos começar nosso aplicativo e ver o que ele serve.

129
00:10:42,920 --> 00:10:47,010
Indo para o terminal, vamos digitar npm start, e

130
00:10:47,010 --> 00:10:50,820
isso deve iniciar nosso aplicativo.

131
00:10:50,820 --> 00:10:54,020
E notamos que ele imprime nosso dizendo que o servidor

132
00:10:54,020 --> 00:10:57,420
em execução em http://localhost:3000.

133
00:10:57,420 --> 00:11:05,950
Agora você pode acessar este URL digitando-o na barra de endereço de qualquer navegador.

134
00:11:05,950 --> 00:11:09,490
Então deixe-me iniciar uma janela do navegador Chrome e, em seguida, digite isso e

135
00:11:09,490 --> 00:11:11,340
ver o que o servidor retornará.

136
00:11:19,160 --> 00:11:20,848
Iniciando uma nova janela.

137
00:11:20,848 --> 00:11:27,260
Deixe-me apenas digitar http://

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

139
00:11:34,400 --> 00:11:39,490
E isso deve retornar um Hello World como esperamos.

140
00:11:39,490 --> 00:11:47,020
Agora, quando vamos para o console você vê que no console há

141
00:11:48,820 --> 00:11:54,530
detalhes do cabeçalho solicitações de entrada é impresso aqui.

142
00:11:54,530 --> 00:11:56,650
Algumas coisas são muito fáceis de localizar aqui.

143
00:11:56,650 --> 00:12:02,290
Então este é o host, localhost: 3000, e você também vê que o “user-agent”

144
00:12:02,290 --> 00:12:08,200
está definido como “Chrome” aqui, a versão do Chrome que estou usando aqui.

145
00:12:08,200 --> 00:12:14,470
Então essa é uma ilustração interessante da mensagem de solicitação HTTP.

146
00:12:14,470 --> 00:12:19,860
E o que está contido no cabeçalho da mensagem de solicitação que veio aqui.

147
00:12:19,860 --> 00:12:24,700
É tão interessante observar o que o seu sever está

148
00:12:24,700 --> 00:12:28,690
imprimindo na tela aqui.

149
00:12:28,690 --> 00:12:32,935
Com isso, completamos a primeira metade deste exercício.

150
00:12:32,935 --> 00:12:38,895
Agora podemos inicializar este aplicativo em um repositório Git

151
00:12:38,895 --> 00:12:41,505
e, em seguida, salvar as alterações para o repositório Git.

152
00:12:41,505 --> 00:12:44,695
Então vamos em frente e fazer isso a seguir.

153
00:12:44,695 --> 00:12:51,435
No tipo de prompt, get init e que inicializou o repositório.

154
00:12:51,435 --> 00:12:57,420
E então vamos dizer status git e você vê que esses dois arquivos são novos.

155
00:12:57,420 --> 00:12:59,502
Então vamos dizer git add.

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

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

158
00:13:15,260 --> 00:13:19,260
E, em seguida, verifique isso em nosso repositório Git.

159
00:13:19,260 --> 00:13:22,640
Agora mais uma ferramenta que é muito útil

160
00:13:22,640 --> 00:13:28,370
quando estamos olhando para aplicativos do lado do servidor é chamado Postman.

161
00:13:28,370 --> 00:13:33,330
Agora Postman vem na forma de uma extensão do navegador Chrome ou de

162
00:13:33,330 --> 00:13:38,430
uma ferramenta autônoma que você pode baixar e instalar em seu computador.

163
00:13:38,430 --> 00:13:43,998
Então, para fazer isso, em nosso navegador vamos digitar http.

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

165
00:13:47,425 --> 00:13:52,550
E então é aqui que você pode obter a

166
00:13:52,550 --> 00:13:57,660
ferramenta Postman para o seu sistema operacional específico e instalá-lo.

167
00:13:57,660 --> 00:14:04,360
A ferramenta Postman permite criar solicitações HTTP e, em seguida, enviá-las.

168
00:14:04,360 --> 00:14:09,960
Além disso, ele também oferece a flexibilidade de configurar os cabeçalhos para

169
00:14:09,960 --> 00:14:12,520
sua solicitação HTTP antes de enviá-la.

170
00:14:12,520 --> 00:14:16,140
E então, quando a resposta voltar, você será capaz de examinar a resposta

171
00:14:16,140 --> 00:14:20,500
incluindo os cabeçalhos da resposta que vem do lado do servidor.

172
00:14:20,500 --> 00:14:23,160
Então acho que o Carteiro é muito útil.

173
00:14:23,160 --> 00:14:25,410
Existem algumas outras ferramentas como esta,

174
00:14:25,410 --> 00:14:30,040
mas o Carteiro parece ser o melhor do mercado no momento.

175
00:14:30,040 --> 00:14:35,010
Então eu vou fazer uso do Carteiro através do resto deste curso.

176
00:14:35,010 --> 00:14:36,830
Se você não quiser instalá-lo,

177
00:14:36,830 --> 00:14:41,720
você também pode instalar a extensão do navegador Chrome do Postman e usá-lo.

178
00:14:41,720 --> 00:14:45,260
Vou baixar a versão do Postman para macOS e

179
00:14:45,260 --> 00:14:49,130
depois instalá-la na minha máquina e depois fazer uso dela.

180
00:14:50,230 --> 00:14:54,280
Depois de ter o Postman, a versão autônoma ou

181
00:14:54,280 --> 00:14:57,880
a extensão do navegador Chrome instalada, você poderá iniciá-lo.

182
00:14:57,880 --> 00:15:02,210
E você verá que a interface do usuário é mais ou menos a mesma para

183
00:15:02,210 --> 00:15:07,060
a versão padrão e também para a extensão do navegador Chrome.

184
00:15:07,060 --> 00:15:10,955
E uma vez que você tenha o Postman funcionando,

185
00:15:10,955 --> 00:15:18,105
digite na caixa URL de solicitação,

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

187
00:15:21,510 --> 00:15:24,090
E envie o pedido para si mesmo.

188
00:15:24,090 --> 00:15:28,990
Certifique-se de que o servidor HTTP do nó está ativo e em execução.

189
00:15:28,990 --> 00:15:30,440
Então, quando você envia a solicitação,

190
00:15:30,440 --> 00:15:36,100
você obteria imediatamente uma resposta do servidor com o código HTML aqui.

191
00:15:36,100 --> 00:15:38,170
Agora, a vantagem, como você vê,

192
00:15:38,170 --> 00:15:43,480
com o uso do Postman é que você pode ver o corpo real da mensagem.

193
00:15:43,480 --> 00:15:49,380
Você também pode olhar para os cabeçalhos para ver o que foi enviado de volta do servidor.

194
00:15:49,380 --> 00:15:54,890
Você também pode configurar muitos detalhes no Postman quando estiver enviando.

195
00:15:54,890 --> 00:15:57,600
Pedido do servidor.

196
00:15:57,600 --> 00:16:02,930
Agora, muitos desses podem não ser muito fáceis de fazer usando uma janela padrão do navegador.

197
00:16:02,930 --> 00:16:07,092
Então essa é a razão pela qual eu prefiro usar [INAUDIBLE] para

198
00:16:07,092 --> 00:16:10,780
gerar as solicitações HTTP para o meu servidor.

199
00:16:10,780 --> 00:16:14,630
E, em seguida, observando a resposta que vem de volta do lado do servidor.

200
00:16:14,630 --> 00:16:20,490
Observe também que ele mostra o código de status aqui e algumas outras informações sobre

201
00:16:21,650 --> 00:16:26,140
a solicitação e o tempo de resposta do lado do servidor.

202
00:16:26,140 --> 00:16:31,760
Agora que criamos seu servidor HTTP baseado em nó simples,

203
00:16:31,760 --> 00:16:39,380
vamos estender ainda mais, vamos criar alguns arquivos HTML na pasta pública.

204
00:16:39,380 --> 00:16:43,632
Vamos chamá-lo assim como index.html.

205
00:16:43,632 --> 00:16:49,657
E, em seguida, também aboutus.html,

206
00:16:49,657 --> 00:16:55,160
e, em seguida, apenas incluir algumas informações sobre ossos nuos aqui.

207
00:16:55,160 --> 00:17:00,809
Então, vamos dizer html, e

208
00:17:00,809 --> 00:17:08,160
título como Este é index.html.

209
00:17:08,160 --> 00:17:15,790
E, em seguida, vamos digitar o corpo da página html.

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

211
00:17:21,044 --> 00:17:26,298
o corpo e, em seguida, este é

212
00:17:26,298 --> 00:17:32,346
o conteúdo deste arquivo.

213
00:17:32,346 --> 00:17:36,187
Alguns código html básico aqui, deixe-me copiar isso e, em

214
00:17:36,187 --> 00:17:40,040
seguida, colar também na página aboutus.html.

215
00:17:58,607 --> 00:18:02,560
E o conteúdo do arquivo aboutus.html, é isso.

216
00:18:02,560 --> 00:18:05,310
Acabamos de criar duas páginas HTML, e

217
00:18:05,310 --> 00:18:09,840
estas são páginas HTML estáticas que criamos na pasta pública.

218
00:18:09,840 --> 00:18:16,800
Agora, podemos configurar nosso servidor HTTP nó para ser capaz de servir páginas estáticas?

219
00:18:16,800 --> 00:18:24,030
Então isso é o que vamos configurar na segunda parte deste exercício.

220
00:18:24,030 --> 00:18:27,928
Então, voltando para o arquivo index.js,

221
00:18:27,928 --> 00:18:32,244
além do módulo de código HTTP,

222
00:18:32,244 --> 00:18:38,660
eu também vou importar o módulo de código do sistema de arquivos.

223
00:18:45,192 --> 00:18:49,920
E esse módulo de código de caminho.

224
00:18:51,230 --> 00:18:56,560
O caminho permite que você especifique a parte de um arquivo em seu sistema de arquivos local.

225
00:18:56,560 --> 00:18:59,430
O módulo do sistema de arquivos permite ler e

226
00:18:59,430 --> 00:19:02,330
gravar arquivos do sistema de arquivos local.

227
00:19:02,330 --> 00:19:08,880
Então, com isso, eles vão dizer servidor constante, HTTP.CreateServer.

228
00:19:08,880 --> 00:19:13,583
Para o log do console, em vez de digitar cabeçalhos de solicitação inteiros,

229
00:19:13,583 --> 00:19:17,378
vou simplesmente digitar apenas informações suficientes, então

230
00:19:17,378 --> 00:19:24,212
eu vou dizer, Solicitar,

231
00:19:29,291 --> 00:19:32,329
Apenas a URL dessa solicitação.

232
00:19:39,786 --> 00:19:41,195
Por método.

233
00:19:46,917 --> 00:19:51,218
Portanto, o método seria obter postagem de porta ou excluir métodos.

234
00:19:51,218 --> 00:19:56,450
Então isso registrará essa informação.

235
00:19:56,450 --> 00:20:01,478
Agora, o que vamos fazer é em vez de enviar

236
00:20:01,478 --> 00:20:06,440
esta resposta, a resposta padrão Olá Mundo.

237
00:20:06,440 --> 00:20:11,176
Aqui, vamos examinar o método e,

238
00:20:11,176 --> 00:20:16,600
em seguida, vamos dizer se req.method é igual a GET.

239
00:20:16,600 --> 00:20:21,689
Portanto, vamos atender apenas solicitações GET neste exemplo.

240
00:20:25,904 --> 00:20:28,750
Caso contrário, diremos que há um “se”.

241
00:20:28,750 --> 00:20:34,035
Então, se houver uma solicitação GET que vem em,

242
00:20:34,035 --> 00:20:36,911
então vamos examinar,

243
00:20:42,139 --> 00:20:47,577
A URL que vem em,

244
00:20:47,577 --> 00:20:55,304
então vamos dizer se req.url é/,

245
00:20:55,304 --> 00:21:03,615
vamos dizer fileURL igual a html.

246
00:21:03,615 --> 00:21:06,645
Então, se você não obter um nome de arquivo específico, mas

247
00:21:06,645 --> 00:21:10,380
você apenas enviar solicitação para o código de host local 3000.

248
00:21:10,380 --> 00:21:15,371
Ele será padrão para o index.html,

249
00:21:15,371 --> 00:21:22,460
caso contrário ele vai dizer fileURL é igual a req.url.

250
00:21:24,650 --> 00:21:28,148
Então, desta forma, você construiu qual arquivo para servidor.

251
00:21:28,148 --> 00:21:35,929
Agora, vamos dizer Vamos encontrar o caminho do arquivo,

252
00:21:35,929 --> 00:21:41,279
vamos dizer caminho, Resolver,

253
00:21:41,279 --> 00:21:48,404
então o módulo path suporta este método resolve, então isso irá

254
00:21:52,013 --> 00:21:57,331
Traduzir isso para o arquivo de pastas caminho completo,

255
00:21:57,331 --> 00:22:01,096
o arquivo que acabamos de construir,

256
00:22:01,096 --> 00:22:05,620
o fileURL que acabamos de construir.

257
00:22:05,620 --> 00:22:10,480
Então, isso nos dará o caminho completo para o arquivo, e

258
00:22:10,480 --> 00:22:17,000
então vamos dizer FileExtension constante.

259
00:22:17,000 --> 00:22:21,524
Então, se você quiser ter certeza de que

260
00:22:21,524 --> 00:22:26,808
a extensão de nome de arquivo é HTML.

261
00:22:30,003 --> 00:22:32,904
Então, a partir do FilePath,

262
00:22:32,904 --> 00:22:38,402
vamos examinar a extensão do nome do arquivo e

263
00:22:38,402 --> 00:22:42,710
, em seguida, vamos dizer se FileExt ==.

264
00:22:42,710 --> 00:22:47,270
Então, se é um arquivo HTML, então sabemos como servi-lo a partir desta

265
00:22:48,410 --> 00:22:51,830
relação particular do servidor HTTP nó.

266
00:22:51,830 --> 00:22:57,025
Então, vamos dizer se a extensão do arquivo é HTML, então sabemos que

267
00:22:57,025 --> 00:23:02,835
o arquivo é um arquivo HTML e temos os dois arquivos, index e aboutus.html.

268
00:23:02,835 --> 00:23:06,986
Então vamos verificar se este arquivo existe, então

269
00:23:06,986 --> 00:23:11,435
vamos dizer se o arquivo existe, FilePath.

270
00:23:11,435 --> 00:23:17,915
Assim, o método existe irá verificar para ver se o arquivo existe,

271
00:23:17,915 --> 00:23:24,180
então vamos dizer fs.exists (FilePath),

272
00:23:24,180 --> 00:23:26,860
e este vai tomar

273
00:23:29,780 --> 00:23:34,170
como um segundo parâmetro, uma função de retorno de chamada.

274
00:23:34,170 --> 00:23:39,180
Portanto, observe o uso da primeira função de retorno de chamada em nosso exemplo.

275
00:23:39,180 --> 00:23:46,430
Portanto, esta função de retorno de chamada será chamada com este parâmetro existe lá.

276
00:23:46,430 --> 00:23:50,740
Portanto, dentro deste parâmetro de retorno de chamada, isso existe será verdadeiro ou falso.

277
00:23:50,740 --> 00:23:54,160
Então este é o parâmetro de retorno para esta função de retorno de chamada.

278
00:23:54,160 --> 00:23:58,336
Então aqui, vamos verificar, e

279
00:23:58,336 --> 00:24:02,584
vamos dizer se (! existe), então

280
00:24:02,584 --> 00:24:08,248
o que significa que o arquivo não existe,

281
00:24:08,248 --> 00:24:14,241
então vamos dizer res.statusCode = 404.

282
00:24:14,241 --> 00:24:19,107
Lembre-se que se o arquivo não existir, você enviará um código de status de 404 dizendo,

283
00:24:19,107 --> 00:24:20,608
você não pode encontrar o arquivo.

284
00:24:20,608 --> 00:24:26,393
E então vamos dizer Res.setHeader,

285
00:24:26,393 --> 00:24:33,996
e vamos definir o cabeçalho para 'Content-Type',

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

287
00:24:42,729 --> 00:24:51,940
E então precisamos enviar o, arquivo HTML aqui, ou o código HTML.

288
00:24:51,940 --> 00:24:59,150
Então eu vou fazer o código HTML básico, html body h1.

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

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

291
00:25:17,421 --> 00:25:20,668
'não encontrado'.

292
00:25:24,185 --> 00:25:31,670
E feche, A página HTML.

293
00:25:31,670 --> 00:25:36,560
Então aqui, como você percebe, você está usando a função exista

294
00:25:36,560 --> 00:25:41,350
do módulo do sistema de arquivos para verificar se o arquivo existe.

295
00:25:41,350 --> 00:25:43,670
Então você dá o caminho do arquivo como o primeiro parâmetro, e

296
00:25:43,670 --> 00:25:45,970
o segundo é a função de retorno de chamada.

297
00:25:45,970 --> 00:25:51,380
Dentro desta função de retorno de chamada, se ele diz que o existe é falso, então você vai

298
00:25:51,380 --> 00:25:58,010
enviar de volta a mensagem de erro 404 padrão, dizendo que você não pode encontrar o arquivo.

299
00:25:58,010 --> 00:26:01,420
E depois de fazer isso, vamos simplesmente,

300
00:26:04,918 --> 00:26:08,088
retornar, caso contrário,

301
00:26:10,507 --> 00:26:16,151
Vamos dizer 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
Agora, precisamos ler o arquivo e enviar o arquivo para fora.

305
00:26:41,950 --> 00:26:44,950
Então é aqui que, a partir do módulo do sistema de arquivos,

306
00:26:44,950 --> 00:26:50,510
vamos usar o CreateReadStream,

307
00:26:50,510 --> 00:26:54,770
que tomará o FilePath como um parâmetro.

308
00:26:54,770 --> 00:27:00,810
Então, este método CreateReadStream irá ler no arquivo a partir deste FilePath.

309
00:27:00,810 --> 00:27:05,930
E então converta isso em fluxo de bytes,

310
00:27:05,930 --> 00:27:10,530
e então eles vão canalizar isso para a resposta.

311
00:27:10,530 --> 00:27:15,300
Então isso será incluído na resposta, no corpo da resposta.

312
00:27:15,300 --> 00:27:17,978
Assim, nós apenas pegamos o arquivo e

313
00:27:17,978 --> 00:27:22,274
, em seguida, construímos na resposta aqui.

314
00:27:22,274 --> 00:27:26,640
E é isso, o arquivo está pronto para ser enviado, ok?

315
00:27:26,640 --> 00:27:29,875
Então, isto é, se a extensão do arquivo for html,

316
00:27:29,875 --> 00:27:34,740
estamos verificando para ter certeza de que você lida com isso corretamente.

317
00:27:34,740 --> 00:27:38,770
Então é aqui que você vai ler no arquivo e depois enviá-lo para fora.

318
00:27:38,770 --> 00:27:46,560
Se a extensão do arquivo não for html, então, é claro, precisamos enviar uma mensagem de erro.

319
00:27:46,560 --> 00:27:51,481
Então, bem ali vamos ver, vamos copiar este

320
00:27:51,481 --> 00:27:56,890
particular, Código daqui.

321
00:27:58,774 --> 00:28:03,364
E, em seguida, colá-lo lá dentro.

322
00:28:03,364 --> 00:28:10,553
Vamos dizer, senão StatusCode = 404, Texto/html de contexto,

323
00:28:10,553 --> 00:28:16,685
e a mensagem de erro diz, Erro 404, FileURL.

324
00:28:16,685 --> 00:28:20,849
Não foi encontrado, mas

325
00:28:20,849 --> 00:28:25,250
não é um arquivo HTML.

326
00:28:25,250 --> 00:28:28,648
Então esse é o erro que vamos enviar de volta neste caso.

327
00:28:28,648 --> 00:28:34,384
E, finalmente, para o último caso,

328
00:28:34,384 --> 00:28:39,650
então aqui estamos dizendo o método.

329
00:28:39,650 --> 00:28:44,910
Então, este mais corresponde ao método de solicitação.

330
00:28:44,910 --> 00:28:48,230
Então, se o método de solicitação não é GET, mas algum outro método de solicitação,

331
00:28:48,230 --> 00:28:54,380
então não vamos lidar com isso nesta versão nosso aplicativo Node.

332
00:28:54,380 --> 00:28:58,333
Então, vamos enviar de volta StatusCode 404

333
00:28:58,333 --> 00:29:02,759
, conteúdo html, e vamos dizer Erro 404.

334
00:29:04,100 --> 00:29:09,117
E vamos dizer, método req,

335
00:29:11,763 --> 00:29:16,394
Não, Suportado,

336
00:29:16,394 --> 00:29:21,800
não suportado por este servidor HTML nó aqui, é isso.

337
00:29:21,800 --> 00:29:28,667
Com essas mudanças, estamos prontos para reiniciar nosso navegador.

338
00:29:28,667 --> 00:29:33,850
E, em seguida, deixe-o servir os arquivos HTML aqui.

339
00:29:35,800 --> 00:29:42,351
Então vamos salvar as alterações, E, em seguida, ir e reiniciar o nosso servidor, e,

340
00:29:42,351 --> 00:29:48,018
em seguida, examinar o que ele envia quando enviamos vários pedidos para o servidor.

341
00:29:48,018 --> 00:29:51,974
Indo para o terminal, se o servidor estiver em execução,

342
00:29:51,974 --> 00:29:56,398
interrompa-o digitando Ctrl+C e, em seguida, reinicie o servidor.

343
00:29:56,398 --> 00:30:00,490
E quando o servidor estiver funcionando, vamos enviar algumas solicitações para ele.

344
00:30:00,490 --> 00:30:05,722
Primeiro, de um navegador, e depois de Postman.

345
00:30:05,722 --> 00:30:10,340
Vá para a janela do seu navegador, vamos digitar localhost:3000, e

346
00:30:10,340 --> 00:30:16,320
ver que isso retorna o arquivo index.html como esperamos.

347
00:30:16,320 --> 00:30:21,073
E então vamos dizer localhost: 3000/index.html,

348
00:30:21,073 --> 00:30:24,974
e isso também retornará o arquivo index.html.

349
00:30:24,974 --> 00:30:32,530
Agora, se enviarmos aboutus.html, ele diz Aboutus.html, e ele retorna corretamente.

350
00:30:32,530 --> 00:30:38,390
Vamos agora enviar uma solicitação para aboutus.txt e ver o que ele faz.

351
00:30:38,390 --> 00:30:43,365
Então ele diz que /aboutus.txt é não é um arquivo HTML.

352
00:30:43,365 --> 00:30:49,992
Então vamos enviar uma solicitação para test.html.

353
00:30:49,992 --> 00:30:56,005
E sabemos que test.html não existe, então diz /test.html não encontrado.

354
00:30:56,005 --> 00:31:01,185
Então vemos que usando o navegador, somos capazes de buscar

355
00:31:01,185 --> 00:31:06,620
os arquivos que existem, e o servidor é capaz de enviar os arquivos para o navegador.

356
00:31:06,620 --> 00:31:10,420
Vamos agora para Postman e tentar gerar os mesmos pedidos,

357
00:31:10,420 --> 00:31:13,400
e ver a resposta do servidor.

358
00:31:13,400 --> 00:31:20,280
Em seguida, indo para Postman, vamos enviar uma solicitação GET para localhost:3000/.

359
00:31:20,280 --> 00:31:25,150
E você vê que isso retorna o arquivo index.html.

360
00:31:25,150 --> 00:31:30,530
Vamos enviar uma solicitação para aboutus.html.

361
00:31:30,530 --> 00:31:35,159
E então você vê que ele retorna o arquivo aboutus.html.

362
00:31:35,159 --> 00:31:38,650
E então vamos enviar uma solicitação para o arquivo de texto,

363
00:31:38,650 --> 00:31:42,240
e então ele diz erro 404, não um arquivo HTML.

364
00:31:42,240 --> 00:31:46,920
E você verá que o status aqui diz, 404 não encontrado.

365
00:31:46,920 --> 00:31:51,400
E então vamos, em vez de enviar um pedido GET,

366
00:31:51,400 --> 00:31:56,730
ver que esta é a vantagem de usar o Postman, eu vou enviar um pedido PUT.

367
00:31:56,730 --> 00:32:01,040
E você notará que isso diz, Erro: PUT não suportado, e

368
00:32:01,040 --> 00:32:04,800
assim com o Status 404 aqui, e assim por diante.

369
00:32:04,800 --> 00:32:11,010
Então é assim que você pode configurar um servidor HTTP nó

370
00:32:11,010 --> 00:32:16,600
para ser capaz de servir arquivos, arquivos HTTP neste caso particular.

371
00:32:16,600 --> 00:32:19,420
Agora você pode facilmente imaginar estendendo

372
00:32:19,420 --> 00:32:23,900
este servidor HTTP para lidar com muitos tipos diferentes de arquivos e assim por diante.

373
00:32:23,900 --> 00:32:25,630
Mas é claro, correspondentemente,

374
00:32:25,630 --> 00:32:30,350
o código também ficará mais complicado do que o que temos neste momento.

375
00:32:30,350 --> 00:32:33,140
Com isso, completamos este exercício.

376
00:32:33,140 --> 00:32:38,589
Neste exercício, vimos como podemos configurar um

377
00:32:38,589 --> 00:32:45,356
servidor HTTP baseado em nós simples que serve arquivos do nosso site de servidor.

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