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

2
00:00:04,946 --> 00:00:09,700
En este ejercicio, vamos a explorar algunos de los módulos del nodo de código.

3
00:00:09,700 --> 00:00:15,326
En particular, veremos el módulo HTTP que está integrado en Node y

4
00:00:15,326 --> 00:00:20,411
usaremos el módulo HTTP para configurar e iniciar un servidor web simple.

5
00:00:20,411 --> 00:00:28,090
También veremos cómo podemos servir archivos estáticos desde nuestro servidor HTTP de nodo.

6
00:00:28,090 --> 00:00:32,510
También veremos ese módulo del sistema de archivos y el módulo de ruta y

7
00:00:32,510 --> 00:00:39,640
cómo pueden ayudarnos a servir archivos estáticos en nuestro servidor HTTP basado en Nodo.

8
00:00:39,640 --> 00:00:43,790
Así que vamos a explorar algunos de los módulos de nodo de código en este ejercicio.

9
00:00:45,710 --> 00:00:51,050
Para comenzar con este ejercicio, vaya a una ubicación conveniente en su computadora.

10
00:00:51,050 --> 00:00:54,820
Así que iremos a la carpeta NodeJS que ya hemos creado en uno de

11
00:00:54,820 --> 00:00:56,400
los ejercicios anteriores.

12
00:00:56,400 --> 00:01:02,663
Y en la carpeta NodeJS, voy a crear una nueva carpeta llamada node-http.

13
00:01:02,663 --> 00:01:07,370
Y luego, vamos a configurar esto como una aplicación Node.

14
00:01:07,370 --> 00:01:11,440
Además, moviéndose a la carpeta node-http,

15
00:01:11,440 --> 00:01:16,770
vamos a crear una subcarpeta allí llamada public que continuará

16
00:01:16,770 --> 00:01:23,080
algunos de los archivos html que vamos a servidor de nuestra aplicación HTTP Node.

17
00:01:23,080 --> 00:01:28,072
Ahora moviéndose a un terminal, navegue hasta el nodo,

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

19
00:01:38,222 --> 00:01:43,320
Y vamos a inicializar esta carpeta para que esté en nuestra aplicación.

20
00:01:43,320 --> 00:01:45,901
Así que comenzaremos con npm init e

21
00:01:45,901 --> 00:01:49,734
inicializaremos ese paquete a nuestro archivo JSON aquí.

22
00:01:49,734 --> 00:01:56,450
Y luego le daremos el nombre del paquete como node-http y

23
00:01:56,450 --> 00:02:00,684
aceptaremos la versión estándar, y

24
00:02:00,684 --> 00:02:06,390
la descripción es Node HTTP Module Ejemplo.

25
00:02:06,390 --> 00:02:10,830
Y el punto de partida es index.js, sin comando de prueba,

26
00:02:10,830 --> 00:02:14,890
sin repositorio git por el momento, y autor,

27
00:02:15,960 --> 00:02:21,460
escriba su nombre y acepte el resto tal como está.

28
00:02:23,360 --> 00:02:27,240
Y eso debería crear el paquete para un archivo de manifiesto JSON.

29
00:02:27,240 --> 00:02:32,310
Ahora vamos a abrir este proyecto en nuestro editor favorito.

30
00:02:32,310 --> 00:02:40,860
Así que permítanme iniciar mi código de Visual Studio en esta carpeta.

31
00:02:40,860 --> 00:02:44,919
Y en el código de Visual Studio, vayamos al paquete a nuestro archivo JSON.

32
00:02:44,919 --> 00:02:51,179
Y luego agregaremos otro script al paquete,

33
00:02:51,179 --> 00:02:54,936
a nuestro archivo JSON llamado start y

34
00:02:54,936 --> 00:02:58,850
que ejecutaría el índice del nodo.

35
00:02:58,850 --> 00:03:02,710
Y recuerda poner una coma después del enganche de prueba.

36
00:03:04,300 --> 00:03:08,797
Y guarde los cambios en el archivo package.json.

37
00:03:08,797 --> 00:03:11,805
Ahora en donde Project,

38
00:03:11,805 --> 00:03:16,720
cree un nuevo archivo llamado index.js.

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

40
00:03:24,920 --> 00:03:29,825
Entonces, en este archivo, escribamos const

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

42
00:03:34,160 --> 00:03:38,485
Así que puede ver que estamos usando el módulo de código HTTP, y

43
00:03:38,485 --> 00:03:44,484
lo estamos requiriendo simplemente especificando el nombre del módulo de código HTTP allí.

44
00:03:46,647 --> 00:03:48,994
Además, vamos a declarar,

45
00:03:52,843 --> 00:03:57,551
Un par de constantes aquí y luego,

46
00:03:59,779 --> 00:04:02,931
Vamos a llamar nombre de host y

47
00:04:02,931 --> 00:04:08,580
el número de puerto como 3000 por defecto.

48
00:04:08,580 --> 00:04:10,990
Ahora vamos a configurar el servidor.

49
00:04:10,990 --> 00:04:18,330
Para configurar el servidor, diremos const server = http.

50
00:04:18,330 --> 00:04:24,210
El módulo HTTP admite un método llamado CreateServer,

51
00:04:24,210 --> 00:04:28,312
por lo que van a utilizar el método CreateServer en eso.

52
00:04:28,312 --> 00:04:36,670
Este método CreateServer tomará una función como parámetro y

53
00:04:36,670 --> 00:04:40,683
esta función toma dos

54
00:04:40,683 --> 00:04:46,560
valores como parámetros, solicitud y respuesta.

55
00:04:46,560 --> 00:04:49,960
Y como puede ver, estoy escribiendo una función de flecha aquí.

56
00:04:49,960 --> 00:04:54,770
Entonces la solicitud y la respuesta son los dos parámetros a la función que proporcionamos

57
00:04:54,770 --> 00:04:59,290
como parámetro al método CreateServer aquí.

58
00:04:59,290 --> 00:05:04,224
Y dentro de esto, diremos

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

60
00:05:10,580 --> 00:05:18,892
Entonces, aquí, el req y res son la solicitud HTTP entrante al servidor.

61
00:05:18,892 --> 00:05:22,548
Y tipo de objeto de respuesta que va

62
00:05:22,548 --> 00:05:26,443
a ser construido por este servidor y devuelto al cliente

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

64
00:05:30,820 --> 00:05:35,120
Así que la solicitud es la solicitud entrante desde cualquier navegador o

65
00:05:35,120 --> 00:05:39,700
desde cualquier lugar que esté intentando acceder a este servidor que vamos a iniciar

66
00:05:39,700 --> 00:05:45,590
usando esta aplicación HTTP Node que estamos desarrollando aquí.

67
00:05:45,590 --> 00:05:47,500
Entonces, a partir de la solicitud,

68
00:05:47,500 --> 00:05:53,190
el objeto de solicitud nos da acceso a los encabezados en la solicitud HTTP entrante.

69
00:05:53,190 --> 00:05:55,690
Así que voy a registrar los

70
00:05:55,690 --> 00:06:00,420
encabezados entrantes de la solicitud HTTP que vienen usando este console.log.

71
00:06:00,420 --> 00:06:05,920
Sólo para mi información, sólo para saber de dónde viene esta solicitud.

72
00:06:05,920 --> 00:06:11,948
A partir de entonces, podemos construir la respuesta utilizando el res y

73
00:06:11,948 --> 00:06:16,739
esto nos proporcionará un método llamado StatusCode.

74
00:06:16,739 --> 00:06:24,315
El StatusCode nos permitirá configurar el StatusCode para el mensaje de respuesta.

75
00:06:24,315 --> 00:06:28,026
Entonces, en este caso, configuraré el StatusCode como 200.

76
00:06:28,026 --> 00:06:32,259
Si recuerdas de la discusión anterior sobre los elementos esenciales de redes,

77
00:06:32,259 --> 00:06:36,576
sabrás que StatusCode de 200 significa que todo está bien.

78
00:06:36,576 --> 00:06:41,856
Por lo tanto, configuramos el código de estado aquí para el mensaje de respuesta y

79
00:06:41,856 --> 00:06:46,763
luego también configuraremos el encabezado para el mensaje de respuesta.

80
00:06:46,763 --> 00:06:51,984
Y uno de los temores de cabecera que vamos

81
00:06:51,984 --> 00:06:56,344
a configurar se llama Content-Type.

82
00:06:56,344 --> 00:06:59,447
Y el tipo de contenido,

83
00:06:59,447 --> 00:07:04,928
especificaremos que esto sea 'text/html'.

84
00:07:04,928 --> 00:07:13,360
Entonces, el cuerpo de respuesta contendrá los datos en forma de html aquí.

85
00:07:13,360 --> 00:07:18,740
Entonces, el encabezado está configurado para informar al cliente que está enviando

86
00:07:18,740 --> 00:07:25,160
la respuesta y el cuerpo está formateado en formato html.

87
00:07:25,160 --> 00:07:27,840
Y luego, finalmente, diremos res.end ('').

88
00:07:27,840 --> 00:07:32,500
Así que esto termina la respuesta aquí, y cuando esto se hace,

89
00:07:32,500 --> 00:07:37,620
esta información se enviará de vuelta al cliente.

90
00:07:37,620 --> 00:07:45,992
Así que aquí, permítanme construir una página html en línea aquí,

91
00:07:45,992 --> 00:07:52,754
así que diré <html><body><h1><Hola,

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

93
00:07:58,328 --> 00:08:04,211
Y cierre la etiqueta h1, la etiqueta del cuerpo,

94
00:08:04,211 --> 00:08:09,270
y la etiqueta html, justo ahí.

95
00:08:09,270 --> 00:08:13,850
Y esa es una respuesta HTML válida que

96
00:08:13,850 --> 00:08:18,100
se puede enviar de vuelta desde nuestro servidor aquí.

97
00:08:18,100 --> 00:08:23,730
Así que este servidor, como usted espera simplemente va a enviar un hola mundo al cliente.

98
00:08:23,730 --> 00:08:28,320
Así que ahora que hemos configurado el servidor, tenemos que iniciar este servidor.

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

100
00:08:32,350 --> 00:08:37,930
tenemos que decir server.listen.

101
00:08:37,930 --> 00:08:43,330
Y esto iniciará el puerto de escucha en el que el servidor escuchará las

102
00:08:43,330 --> 00:08:45,030
solicitudes entrantes.

103
00:08:45,030 --> 00:08:50,050
Y esto se iniciaría en el número de puerto dado mi puerto,

104
00:08:50,050 --> 00:08:53,910
que ya hemos establecido aquí en el puerto const.

105
00:08:53,910 --> 00:08:59,990
Y el segundo parámetro es el nombre de host que ya configuramos anteriormente.

106
00:08:59,990 --> 00:09:03,560
Y el tercer parámetro es una función que se

107
00:09:04,720 --> 00:09:07,520
ejecutará cuando se inicie el servidor.

108
00:09:07,520 --> 00:09:13,560
En esta función sólo vamos a imprimir la información sobre el servidor.

109
00:09:13,560 --> 00:09:18,505
Así que aquí sólo voy a decir console.log.

110
00:09:19,560 --> 00:09:22,110
Y en el console.log,

111
00:09:22,110 --> 00:09:26,640
voy a imprimir la información, así que usaré una cita inversa.

112
00:09:26,640 --> 00:09:30,876
Así que tenga en cuenta el uso de la cita atrás no la cita normal.

113
00:09:30,876 --> 00:09:35,103
La razón por la que estamos usando eso es porque vamos a usar

114
00:09:35,103 --> 00:09:39,830
algunas variables dentro de la cadena que vamos a construir aquí.

115
00:09:39,830 --> 00:09:45,608
Entonces diremos que el servidor se ejecuta en http://.

116
00:09:45,608 --> 00:09:50,965
Y luego diremos $ y

117
00:09:50,965 --> 00:09:55,780
luego el nombre del host.

118
00:09:55,780 --> 00:09:59,582
Recuerde que este nombre de host, ya ha declarado anteriormente.

119
00:09:59,582 --> 00:10:04,187
Y luego la segunda parte,

120
00:10:04,187 --> 00:10:08,800
diremos: $ y puerto.

121
00:10:08,800 --> 00:10:14,130
Por lo tanto, estos dos valores serán sustituidos por los valores correspondientes.

122
00:10:14,130 --> 00:10:17,370
Y ya que estamos adjuntando esto entre comillas.

123
00:10:17,370 --> 00:10:21,070
Y si incluye algo dentro de aumentos de dólares,

124
00:10:21,070 --> 00:10:26,150
eso será reemplazado por su valor en esta cadena aquí.

125
00:10:28,230 --> 00:10:29,150
Eso es todo.

126
00:10:29,150 --> 00:10:33,990
Tenemos un servidor HTTP simple en funcionamiento.

127
00:10:33,990 --> 00:10:37,480
Así que vamos a guardar los cambios en esto.

128
00:10:37,480 --> 00:10:42,920
E iremos a poner en marcha nuestra aplicación y veremos qué sirve.

129
00:10:42,920 --> 00:10:47,010
Al ir al terminal, escribamos npm start, y

130
00:10:47,010 --> 00:10:50,820
esto debería iniciar nuestra aplicación.

131
00:10:50,820 --> 00:10:54,020
Y notamos que imprime nuestro dicho que el servidor se ejecuta

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

133
00:10:57,420 --> 00:11:05,950
Ahora puede acceder a esta URL escribiéndola en la barra de direcciones de cualquier navegador.

134
00:11:05,950 --> 00:11:09,490
Así que déjame iniciar una ventana del navegador Chrome y luego escribir esto y

135
00:11:09,490 --> 00:11:11,340
ver lo que el servidor devolverá.

136
00:11:19,160 --> 00:11:20,848
Iniciando una nueva ventana.

137
00:11:20,848 --> 00:11:27,260
Déjame escribir http://

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

139
00:11:34,400 --> 00:11:39,490
Y eso debería devolver un Hello World como esperamos.

140
00:11:39,490 --> 00:11:47,020
Ahora, cuando vamos a la consola, ves que en la consola hay

141
00:11:48,820 --> 00:11:54,530
detalles del encabezado de solicitudes entrantes se imprimen aquí.

142
00:11:54,530 --> 00:11:56,650
Algunas cosas son muy fáciles de localizar aquí.

143
00:11:56,650 --> 00:12:02,290
Entonces, este es el host, localhost: 3000, y también ves que el «user-agent»

144
00:12:02,290 --> 00:12:08,200
está configurado en «Chrome» aquí, la versión de Chrome que estoy usando aquí.

145
00:12:08,200 --> 00:12:14,470
Así que esa es una ilustración interesante del mensaje de solicitud HTTP.

146
00:12:14,470 --> 00:12:19,860
Y lo que está contenido en el encabezado del mensaje de solicitud que vino aquí.

147
00:12:19,860 --> 00:12:24,700
Tan interesante observar lo que su servidor está

148
00:12:24,700 --> 00:12:28,690
imprimiendo en la pantalla aquí.

149
00:12:28,690 --> 00:12:32,935
Con esto, completamos la primera mitad de este ejercicio.

150
00:12:32,935 --> 00:12:38,895
Ahora podemos inicializar esta aplicación en un repositorio de Git,

151
00:12:38,895 --> 00:12:41,505
y luego guardar los cambios en el repositorio de Git.

152
00:12:41,505 --> 00:12:44,695
Así que sigamos adelante y hagamos eso a continuación.

153
00:12:44,695 --> 00:12:51,435
En el tipo de símbolo, get init, y eso inicializó el repositorio.

154
00:12:51,435 --> 00:12:57,420
Y luego diremos estado de git y verás que estos dos archivos son nuevos.

155
00:12:57,420 --> 00:12:59,502
Entonces diremos git add.

156
00:12:59,502 --> 00:13:04,702
Y hacer git commit

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

158
00:13:15,260 --> 00:13:19,260
Y luego verifique esto en nuestro repositorio de Git.

159
00:13:19,260 --> 00:13:22,640
Ahora otra herramienta que es muy útil

160
00:13:22,640 --> 00:13:28,370
cuando estamos mirando aplicaciones del lado del servidor se llama Postman.

161
00:13:28,370 --> 00:13:33,330
Ahora Postman viene en forma de una extensión del navegador Chrome o

162
00:13:33,330 --> 00:13:38,430
una herramienta independiente que puede descargar e instalar en su computadora.

163
00:13:38,430 --> 00:13:43,998
Entonces, para hacer eso, en nuestro navegador vamos a escribir http.

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

165
00:13:47,425 --> 00:13:52,550
Y aquí es donde puede obtener la

166
00:13:52,550 --> 00:13:57,660
herramienta Postman para su sistema operativo específico e instalarlo.

167
00:13:57,660 --> 00:14:04,360
La herramienta Postman le permite crear solicitudes HTTP y luego enviarlas.

168
00:14:04,360 --> 00:14:09,960
Y también le da la flexibilidad de configurar los encabezados para

169
00:14:09,960 --> 00:14:12,520
su solicitud HTTP antes de enviarla.

170
00:14:12,520 --> 00:14:16,140
Y luego, cuando la respuesta regrese, puede examinar la respuesta,

171
00:14:16,140 --> 00:14:20,500
incluidos los encabezados de la respuesta que regresa desde el lado del servidor.

172
00:14:20,500 --> 00:14:23,160
Así que me parece que el cartero es muy útil.

173
00:14:23,160 --> 00:14:25,410
Hay algunas otras herramientas como esta,

174
00:14:25,410 --> 00:14:30,040
pero Postman parece ser el mejor del mercado en este momento.

175
00:14:30,040 --> 00:14:35,010
Así que voy a hacer uso de Cartero durante el resto de este curso.

176
00:14:35,010 --> 00:14:36,830
Si no desea instalarlo,

177
00:14:36,830 --> 00:14:41,720
también puede instalar la extensión del navegador Chrome de Postman y luego usarla.

178
00:14:41,720 --> 00:14:45,260
Voy a descargar la versión de macOS de Postman y

179
00:14:45,260 --> 00:14:49,130
luego instalarla en mi máquina y luego hacer uso de ella.

180
00:14:50,230 --> 00:14:54,280
Una vez que tenga

181
00:14:54,280 --> 00:14:57,880
instalado el Postman, ya sea la versión independiente o la extensión del navegador Chrome, puede iniciarlo.

182
00:14:57,880 --> 00:15:02,210
Y verá que la interfaz de usuario es más o menos la misma

183
00:15:02,210 --> 00:15:07,060
tanto para la versión estándar como para la extensión del navegador Chrome.

184
00:15:07,060 --> 00:15:10,955
Y una vez que tenga el Cartero en funcionamiento,

185
00:15:10,955 --> 00:15:18,105
escriba en el cuadro URL de solicitud,

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

187
00:15:21,510 --> 00:15:24,090
Y envíate la solicitud a ti mismo.

188
00:15:24,090 --> 00:15:28,990
Asegúrese de que el servidor HTTP de nodo esté activo y en ejecución.

189
00:15:28,990 --> 00:15:30,440
Entonces, cuando envíe la solicitud,

190
00:15:30,440 --> 00:15:36,100
obtendría inmediatamente una respuesta del servidor con el código HTML aquí.

191
00:15:36,100 --> 00:15:38,170
Ahora la ventaja, como puede ver,

192
00:15:38,170 --> 00:15:43,480
con el uso de Postman es que se puede ver el cuerpo real del mensaje.

193
00:15:43,480 --> 00:15:49,380
También puede mirar los encabezados para ver lo que se ha enviado desde el servidor.

194
00:15:49,380 --> 00:15:54,890
También puedes configurar una gran cantidad de detalles en Postman cuando estás enviando.

195
00:15:54,890 --> 00:15:57,600
Solicitud del servidor.

196
00:15:57,600 --> 00:16:02,930
Ahora muchos de estos pueden no ser muy fáciles de hacer usando una ventana estándar del navegador.

197
00:16:02,930 --> 00:16:07,092
Entonces, esa es la razón por la que prefiero usar [INAUDIBLE] para

198
00:16:07,092 --> 00:16:10,780
generar las solicitudes HTTP a mi servidor.

199
00:16:10,780 --> 00:16:14,630
Y luego observando la respuesta que regresa desde el lado del servidor.

200
00:16:14,630 --> 00:16:20,490
También tenga en cuenta que muestra el código de estado aquí y otra información sobre

201
00:16:21,650 --> 00:16:26,140
la solicitud y el tiempo de respuesta desde el lado del servidor.

202
00:16:26,140 --> 00:16:31,760
Ahora que hemos creado su servidor HTTP basado en nodo simple,

203
00:16:31,760 --> 00:16:39,380
vamos a ampliarlo más, vamos a crear un par de archivos HTML en la carpeta pública.

204
00:16:39,380 --> 00:16:43,632
Lo llamaremos así como index.html.

205
00:16:43,632 --> 00:16:49,657
Y luego también aboutus.html,

206
00:16:49,657 --> 00:16:55,160
y luego simplemente incluya algo de información de huesos desnudos aquí.

207
00:16:55,160 --> 00:17:00,809
Así que diremos html, y

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

209
00:17:08,160 --> 00:17:15,790
Y luego escribiremos el cuerpo de la página html.

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

211
00:17:21,044 --> 00:17:26,298
el cuerpo y entonces este es

212
00:17:26,298 --> 00:17:32,346
el contenido de este archivo.

213
00:17:32,346 --> 00:17:36,187
Algún código html básico aquí, permítanme copiar esto y

214
00:17:36,187 --> 00:17:40,040
luego pegar también en la página aboutus.html.

215
00:17:58,607 --> 00:18:02,560
Y el contenido del archivo aboutus.html, eso es todo.

216
00:18:02,560 --> 00:18:05,310
Acabamos de crear dos páginas HTML, y

217
00:18:05,310 --> 00:18:09,840
estas son páginas HTML estáticas que hemos creado en la carpeta pública.

218
00:18:09,840 --> 00:18:16,800
Ahora, ¿podemos configurar nuestro servidor HTTP de nodo para poder servir páginas estáticas?

219
00:18:16,800 --> 00:18:24,030
Así que esto es lo que vamos a configurar en la segunda parte de este ejercicio.

220
00:18:24,030 --> 00:18:27,928
Así que volviendo al archivo index.js,

221
00:18:27,928 --> 00:18:32,244
además del módulo de código HTTP,

222
00:18:32,244 --> 00:18:38,660
también voy a importar el módulo de código del sistema de archivos.

223
00:18:45,192 --> 00:18:49,920
Y ese módulo de código de ruta.

224
00:18:51,230 --> 00:18:56,560
La ruta permite especificar la parte de un archivo en el sistema de archivos local.

225
00:18:56,560 --> 00:18:59,430
El módulo del sistema de archivos le permite leer y

226
00:18:59,430 --> 00:19:02,330
escribir archivos desde su sistema de archivos local.

227
00:19:02,330 --> 00:19:08,880
Entonces, con esto, dirán servidor constante, http.CreateServer.

228
00:19:08,880 --> 00:19:13,583
Para el registro de la consola, en lugar de escribir encabezados de solicitud completos,

229
00:19:13,583 --> 00:19:17,378
simplemente

230
00:19:17,378 --> 00:19:24,212
escribiré información suficiente, así que diré, Solicitar,

231
00:19:29,291 --> 00:19:32,329
Solo la URL de esa solicitud.

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

233
00:19:46,917 --> 00:19:51,218
Entonces, el método sería obtener la publicación del puerto o eliminar los métodos.

234
00:19:51,218 --> 00:19:56,450
Así que esto registrará esta información.

235
00:19:56,450 --> 00:20:01,478
Ahora, lo que vamos a hacer es en lugar de enviar

236
00:20:01,478 --> 00:20:06,440
esta respuesta, la respuesta estándar hola world.

237
00:20:06,440 --> 00:20:11,176
Aquí, vamos a examinar el método y

238
00:20:11,176 --> 00:20:16,600
luego vamos a decir si req.method es igual a GET.

239
00:20:16,600 --> 00:20:21,689
Por lo tanto, solo serviremos las solicitudes GET en este ejemplo.

240
00:20:25,904 --> 00:20:28,750
De lo contrario, diremos que hay un si.

241
00:20:28,750 --> 00:20:34,035
Entonces, si hay una solicitud GET que entra,

242
00:20:34,035 --> 00:20:36,911
entonces examinaremos,

243
00:20:42,139 --> 00:20:47,577
La URL que viene,

244
00:20:47,577 --> 00:20:55,304
así que diremos si req.url es/,

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

246
00:21:03,615 --> 00:21:06,645
Entonces, si no obtiene un nombre de archivo específico, pero

247
00:21:06,645 --> 00:21:10,380
simplemente envía la solicitud al código de host local 3000.

248
00:21:10,380 --> 00:21:15,371
Se establecerá por defecto en index.html, de

249
00:21:15,371 --> 00:21:22,460
lo contrario dirá FileURL es igual a req.url.

250
00:21:24,650 --> 00:21:28,148
Así que de esta manera, ha construido qué archivo al servidor.

251
00:21:28,148 --> 00:21:35,929
Ahora, diremos que encontraremos la ruta del archivo,

252
00:21:35,929 --> 00:21:41,279
diremos ruta, Resolver,

253
00:21:41,279 --> 00:21:48,404
por lo que el módulo de ruta admite este método de resolución, por lo que

254
00:21:52,013 --> 00:21:57,331
esto traducirá esto en el archivo completo de carpetas de ruta,

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

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

257
00:22:05,620 --> 00:22:10,480
Así que esto nos dará la ruta completa para el archivo, y

258
00:22:10,480 --> 00:22:17,000
luego diremos constante FileExtension.

259
00:22:17,000 --> 00:22:21,524
Así que si desea asegurarse de que

260
00:22:21,524 --> 00:22:26,808
la extensión del nombre de archivo es HTML.

261
00:22:30,003 --> 00:22:32,904
Así que desde FilePath,

262
00:22:32,904 --> 00:22:38,402
examinaremos la extensión del nombre de archivo y

263
00:22:38,402 --> 00:22:42,710
luego diremos si FileExt ==.

264
00:22:42,710 --> 00:22:47,270
Entonces, si se trata de un archivo HTML, entonces sabemos cómo servirlo desde esta

265
00:22:48,410 --> 00:22:51,830
relación particular del servidor HTTP nodo.

266
00:22:51,830 --> 00:22:57,025
Así que diremos si la extensión de archivo es HTML, entonces sabemos que

267
00:22:57,025 --> 00:23:02,835
el archivo es un archivo HTML y tenemos los dos archivos, índice y aboutus.html.

268
00:23:02,835 --> 00:23:06,986
Así que vamos a comprobar si este archivo existe, así que

269
00:23:06,986 --> 00:23:11,435
vamos a decir si el archivo existe, FilePath.

270
00:23:11,435 --> 00:23:17,915
Entonces, el método existe comprobará si el archivo existe,

271
00:23:17,915 --> 00:23:24,180
así que diremos fs.exists (FilePath),

272
00:23:24,180 --> 00:23:26,860
y este tomará

273
00:23:29,780 --> 00:23:34,170
como segundo parámetro, una función de devolución de llamada.

274
00:23:34,170 --> 00:23:39,180
Así que observe el uso de la primera función de devolución de llamada en nuestro ejemplo.

275
00:23:39,180 --> 00:23:46,430
Así que esta función de devolución de llamada se llamará con este parámetro existe allí.

276
00:23:46,430 --> 00:23:50,740
Entonces, dentro de este parámetro de devolución de llamada, esto existe será verdadero o falso.

277
00:23:50,740 --> 00:23:54,160
Así que este es el parámetro de retorno para esta función de devolución de llamada.

278
00:23:54,160 --> 00:23:58,336
Así que aquí, Vamos a comprobar, y

279
00:23:58,336 --> 00:24:02,584
vamos a decir si (! existe), por lo

280
00:24:02,584 --> 00:24:08,248
que significa que el archivo no existe,

281
00:24:08,248 --> 00:24:14,241
entonces diremos Res.statusCode = 404.

282
00:24:14,241 --> 00:24:19,107
Recuerde que si el archivo no existe, enviará un código de estado de 404 diciendo que

283
00:24:19,107 --> 00:24:20,608
no puede encontrar el archivo.

284
00:24:20,608 --> 00:24:26,393
Y luego diremos Res.setHeader,

285
00:24:26,393 --> 00:24:33,996
y estableceremos el encabezado en 'Content-Type',

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

287
00:24:42,729 --> 00:24:51,940
Y luego tenemos que enviar el, archivo HTML aquí, o el código HTML.

288
00:24:51,940 --> 00:24:59,150
Así que voy a hacer el código HTML básico, html body h1.

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

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

291
00:25:17,421 --> 00:25:20,668
'no encontrado'.

292
00:25:24,185 --> 00:25:31,670
Y cerrar, La página HTML.

293
00:25:31,670 --> 00:25:36,560
Así que aquí, como notará, está usando la función existente

294
00:25:36,560 --> 00:25:41,350
del módulo del sistema de archivos para verificar si el archivo existe.

295
00:25:41,350 --> 00:25:43,670
Entonces da la ruta del archivo como el primer parámetro, y

296
00:25:43,670 --> 00:25:45,970
el segundo es la función de devolución de llamada.

297
00:25:45,970 --> 00:25:51,380
Dentro de esta función de devolución de llamada, si dice que existe es falso, entonces va a

298
00:25:51,380 --> 00:25:58,010
enviar de vuelta el mensaje de error 404 estándar, diciendo que no puede encontrar el archivo.

299
00:25:58,010 --> 00:26:01,420
Y después de hacer esto, simplemente,

300
00:26:04,918 --> 00:26:08,088
devolveremos, de lo contrario,

301
00:26:10,507 --> 00:26:16,151
Diremos 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
Ahora, tenemos que leer el archivo y luego enviar el archivo.

305
00:26:41,950 --> 00:26:44,950
Así que aquí es donde, desde el módulo del sistema de archivos,

306
00:26:44,950 --> 00:26:50,510
usaremos el CreateReadStream,

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

308
00:26:54,770 --> 00:27:00,810
Por lo tanto, este método CreateReadStream leerá en el archivo de esta FilePath.

309
00:27:00,810 --> 00:27:05,930
Y luego convertirlo en flujo de bytes,

310
00:27:05,930 --> 00:27:10,530
y luego canalizarán esto a través de la respuesta.

311
00:27:10,530 --> 00:27:15,300
Así que eso se incluirá en la respuesta, en el cuerpo de la respuesta.

312
00:27:15,300 --> 00:27:17,978
Así que de esa manera acabamos de tomar el archivo y

313
00:27:17,978 --> 00:27:22,274
luego lo construimos en la respuesta aquí.

314
00:27:22,274 --> 00:27:26,640
Y eso es todo, el archivo está listo para ser enviado, ¿de acuerdo?

315
00:27:26,640 --> 00:27:29,875
Así que esto es si la extensión del archivo es html,

316
00:27:29,875 --> 00:27:34,740
estamos comprobando para asegurarnos de que maneja esto correctamente.

317
00:27:34,740 --> 00:27:38,770
Así que aquí es donde leerás en el archivo y luego lo enviarás.

318
00:27:38,770 --> 00:27:46,560
Si la extensión del archivo no es html, entonces, por supuesto, necesitamos enviar un mensaje de error.

319
00:27:46,560 --> 00:27:51,481
Así que ahí mismo veremos, vamos a copiar este

320
00:27:51,481 --> 00:27:56,890
código en particular, desde aquí.

321
00:27:58,774 --> 00:28:03,364
Y luego pégalo ahí.

322
00:28:03,364 --> 00:28:10,553
Diremos, de lo contrario StatusCode = 404, Texto/html de contexto,

323
00:28:10,553 --> 00:28:16,685
y el mensaje de error dice, Error 404, FileURL.

324
00:28:16,685 --> 00:28:20,849
No se encuentra, pero

325
00:28:20,849 --> 00:28:25,250
no es un archivo HTML.

326
00:28:25,250 --> 00:28:28,648
Así que ese es el error que vamos a enviar de vuelta en este caso.

327
00:28:28,648 --> 00:28:34,384
Y, por último, para el último caso,

328
00:28:34,384 --> 00:28:39,650
así que aquí estamos diciendo el método.

329
00:28:39,650 --> 00:28:44,910
Entonces, esto más corresponde al método de solicitud.

330
00:28:44,910 --> 00:28:48,230
Entonces, si el método de solicitud no es GET, sino algún otro método de solicitud,

331
00:28:48,230 --> 00:28:54,380
entonces no manejaremos eso en esta versión nuestra aplicación Node.

332
00:28:54,380 --> 00:28:58,333
Así que enviaremos de vuelta StatusCode 404,

333
00:28:58,333 --> 00:29:02,759
Content html, y diremos Error 404.

334
00:29:04,100 --> 00:29:09,117
Y vamos a decir, método req,

335
00:29:11,763 --> 00:29:16,394
No, Soportado,

336
00:29:16,394 --> 00:29:21,800
no soportado por este servidor HTML nodo aquí, eso es todo.

337
00:29:21,800 --> 00:29:28,667
Con estos cambios, ahora estamos listos para reiniciar nuestro navegador.

338
00:29:28,667 --> 00:29:33,850
Y luego dejar que sirva los archivos HTML aquí.

339
00:29:35,800 --> 00:29:42,351
Así que vamos a guardar los cambios, y luego ir y reiniciar nuestro servidor, y

340
00:29:42,351 --> 00:29:48,018
luego examinar lo que envía cuando enviamos varias solicitudes al servidor. Al

341
00:29:48,018 --> 00:29:51,974
ir al terminal, si el servidor se está ejecutando,

342
00:29:51,974 --> 00:29:56,398
deténgalo escribiendo Ctrl+C y, a continuación, reinicie el servidor.

343
00:29:56,398 --> 00:30:00,490
Y cuando el servidor esté en funcionamiento, le enviemos algunas solicitudes.

344
00:30:00,490 --> 00:30:05,722
Primero, desde un navegador, y luego desde Postman.

345
00:30:05,722 --> 00:30:10,340
Vaya a la ventana de su navegador, escriba localhost: 3000, y

346
00:30:10,340 --> 00:30:16,320
vea que esto devuelve el archivo index.html como esperamos.

347
00:30:16,320 --> 00:30:21,073
Y luego diremos localhost: 3000/index.html,

348
00:30:21,073 --> 00:30:24,974
y esto también devolverá el archivo index.html.

349
00:30:24,974 --> 00:30:32,530
Ahora, si enviamos aboutus.html, dice Aboutus.html, y lo devuelve correctamente.

350
00:30:32,530 --> 00:30:38,390
Ahora enviemos una solicitud para aboutus.txt, y veamos qué hace.

351
00:30:38,390 --> 00:30:43,365
Entonces dice que /aboutus.txt no es un archivo HTML.

352
00:30:43,365 --> 00:30:49,992
Entonces enviemos una solicitud a test.html.

353
00:30:49,992 --> 00:30:56,005
Y sabemos que test.html no existe, por lo que dice /test.html no encontrado.

354
00:30:56,005 --> 00:31:01,185
Así que vemos que mediante el uso del navegador, somos capaces de buscar

355
00:31:01,185 --> 00:31:06,620
los archivos que existen, y el servidor es capaz de enviar los archivos al navegador.

356
00:31:06,620 --> 00:31:10,420
Vamos ahora a Postman y tratar de generar las mismas solicitudes,

357
00:31:10,420 --> 00:31:13,400
y ver la respuesta del servidor.

358
00:31:13,400 --> 00:31:20,280
A continuación, yendo a Postman, enviemos una solicitud GET a localhost: 3000/.

359
00:31:20,280 --> 00:31:25,150
Y ves que esto devuelve el archivo index.html.

360
00:31:25,150 --> 00:31:30,530
Vamos a enviar una solicitud a aboutus.html.

361
00:31:30,530 --> 00:31:35,159
Y luego ves que devuelve el archivo aboutus.html.

362
00:31:35,159 --> 00:31:38,650
Y luego enviaremos una solicitud al archivo de texto,

363
00:31:38,650 --> 00:31:42,240
y luego dice error 404, no un archivo HTML.

364
00:31:42,240 --> 00:31:46,920
Y verá que el estado aquí dice, 404 no encontrado.

365
00:31:46,920 --> 00:31:51,400
Y luego, en lugar de enviar una solicitud GET,

366
00:31:51,400 --> 00:31:56,730
veremos que esta es la ventaja de usar Postman, enviaré una solicitud PUT.

367
00:31:56,730 --> 00:32:01,040
Y notará que esto dice, Error: PUT no compatible, y

368
00:32:01,040 --> 00:32:04,800
así con el estado 404 aquí, y así sucesivamente.

369
00:32:04,800 --> 00:32:11,010
Así es como se puede configurar un servidor HTTP de nodo

370
00:32:11,010 --> 00:32:16,600
para poder servir archivos, archivos HTTP en este caso particular.

371
00:32:16,600 --> 00:32:19,420
Ahora puede imaginar fácilmente extender

372
00:32:19,420 --> 00:32:23,900
este servidor HTTP para manejar muchos tipos diferentes de archivos y así sucesivamente.

373
00:32:23,900 --> 00:32:25,630
Pero, por supuesto, correspondientemente,

374
00:32:25,630 --> 00:32:30,350
el código también se complicará más que lo que tenemos en este momento.

375
00:32:30,350 --> 00:32:33,140
Con esto, completamos este ejercicio.

376
00:32:33,140 --> 00:32:38,589
En este ejercicio, hemos visto cómo podemos configurar un

377
00:32:38,589 --> 00:32:45,356
servidor HTTP basado en nodo simple que sirve archivos de nuestro sitio de servidor.

378
00:32:45,356 --> 00:32:48,260
[ MÚSICA]