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

2
00:00:04,946 --> 00:00:09,700
В этом упражнении мы рассмотрим некоторые из модулей кода Node.

3
00:00:09,700 --> 00:00:15,326
В частности, мы рассмотрим модуль HTTP, который встроен в Node и

4
00:00:15,326 --> 00:00:20,411
использовать HTTP-модуль для настройки и запуска простого веб-сервера.

5
00:00:20,411 --> 00:00:28,090
Мы также рассмотрим, как мы можем обслуживать статические файлы с нашего сервера Node HTTP.

6
00:00:28,090 --> 00:00:32,510
Мы также рассмотрим этот модуль файловой системы и модуль пути и

7
00:00:32,510 --> 00:00:39,640
как они могут помочь нам обслуживать статические файлы на нашем сервере HTTP на основе узла.

8
00:00:39,640 --> 00:00:43,790
Итак, давайте рассмотрим некоторые из модулей кода Node в этом упражнении.

9
00:00:45,710 --> 00:00:51,050
Чтобы начать работу с этим упражнением, перейдите в удобное место на компьютере.

10
00:00:51,050 --> 00:00:54,820
Поэтому мы перейдем в папку NodeJS, которую мы уже создали в одном из

11
00:00:54,820 --> 00:00:56,400
предыдущих упражнений.

12
00:00:56,400 --> 00:01:02,663
И в папке NodeJS я собираюсь создать новую папку с именем node-http.

13
00:01:02,663 --> 00:01:07,370
И затем, мы установим это как приложение Node.

14
00:01:07,370 --> 00:01:11,440
Кроме того, перейдя в папку node-http,

15
00:01:11,440 --> 00:01:16,770
давайте создадим подпапку там с именем public, которая будет продолжать

16
00:01:16,770 --> 00:01:23,080
некоторые из html-файлов, которые мы будем сервера из нашего приложения Node HTTP.

17
00:01:23,080 --> 00:01:28,072
Теперь перейдем к терминалу, перейдите к узлу,

18
00:01:32,012 --> 00:01:33,478
-http папка.

19
00:01:38,222 --> 00:01:43,320
И давайте инициализируем эту папку, чтобы быть в нашем приложении.

20
00:01:43,320 --> 00:01:45,901
Поэтому мы начнем с npm init и

21
00:01:45,901 --> 00:01:49,734
инициализируем этот пакет в наш JSON-файл здесь.

22
00:01:49,734 --> 00:01:56,450
И тогда мы дадим имя пакета как node-http и

23
00:01:56,450 --> 00:02:00,684
принимаем стандартную версию, а

24
00:02:00,684 --> 00:02:06,390
описание - Node HTTP Module Example.

25
00:02:06,390 --> 00:02:10,830
И отправной точкой является index.js, без тестовой команды,

26
00:02:10,830 --> 00:02:14,890
без репозитория git на данный момент и автор,

27
00:02:15,960 --> 00:02:21,460
введите свое имя и принимайте остальное как есть.

28
00:02:23,360 --> 00:02:27,240
И это должно создать пакет для файла манифеста JSON.

29
00:02:27,240 --> 00:02:32,310
Теперь давайте откроем этот проект в нашем любимом редакторе.

30
00:02:32,310 --> 00:02:40,860
Поэтому позвольте мне запустить мой код Visual Studio в этой папке.

31
00:02:40,860 --> 00:02:44,919
И в коде Visual Studio, давайте перейдем к пакету в наш JSON-файл.

32
00:02:44,919 --> 00:02:51,179
И тогда мы добавим в другой скрипт к пакету, в

33
00:02:51,179 --> 00:02:54,936
наш JSON-файл под названием start и

34
00:02:54,936 --> 00:02:58,850
который будет выполнять индекс узла.

35
00:02:58,850 --> 00:03:02,710
И не забудьте поставить запятую после тестовой зацепки.

36
00:03:04,300 --> 00:03:08,797
И сохраните изменения в файле package.json.

37
00:03:08,797 --> 00:03:11,805
Теперь, где Project,

38
00:03:11,805 --> 00:03:16,720
создайте новый файл с именем index.js.

39
00:03:16,720 --> 00:03:24,920
Мы собираемся настроить этот index.js для использования модуля Node HTTP.

40
00:03:24,920 --> 00:03:29,825
Поэтому в этом файле, давайте напечатаем const

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

42
00:03:34,160 --> 00:03:38,485
Таким образом, вы можете видеть, что мы используем модуль кода HTTP, и

43
00:03:38,485 --> 00:03:44,484
мы требуем его, просто указав имя модуля кода HTTP там.

44
00:03:46,647 --> 00:03:48,994
Кроме того, давайте объявим,

45
00:03:52,843 --> 00:03:57,551
Пара констант здесь и затем,

46
00:03:59,779 --> 00:04:02,931
Мы будем называть имя хоста и

47
00:04:02,931 --> 00:04:08,580
номер порта как 3000 по умолчанию.

48
00:04:08,580 --> 00:04:10,990
Теперь давайте настроим сервер.

49
00:04:10,990 --> 00:04:18,330
Чтобы настроить сервер, мы скажем const server = http.

50
00:04:18,330 --> 00:04:24,210
Модуль HTTP поддерживает метод CreateServer,

51
00:04:24,210 --> 00:04:28,312
поэтому они будут использовать метод CreateServer для этого.

52
00:04:28,312 --> 00:04:36,670
Этот метод CreateServer будет принимать функцию в качестве параметра, и

53
00:04:36,670 --> 00:04:40,683
эта функция принимает два

54
00:04:40,683 --> 00:04:46,560
значения в качестве параметров, запрос и ответ.

55
00:04:46,560 --> 00:04:49,960
И, как вы можете видеть, я пишу функцию стрелки здесь.

56
00:04:49,960 --> 00:04:54,770
Таким образом, запрос и ответ являются двумя параметрами функции, которую мы предоставляем

57
00:04:54,770 --> 00:04:59,290
в качестве параметра для метода CreateServer здесь.

58
00:04:59,290 --> 00:05:04,224
И внутри этого мы скажем

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

60
00:05:10,580 --> 00:05:18,892
Итак, здесь req и res являются входящим HTTP-запросом на сервер.

61
00:05:18,892 --> 00:05:22,548
И они своего рода нерест объект ответа, который

62
00:05:22,548 --> 00:05:26,443
будет построен этим сервером и возвращен клиенту,

63
00:05:26,443 --> 00:05:30,820
который подключается к этому HTTP-серверу, который мы создаем здесь.

64
00:05:30,820 --> 00:05:35,120
Таким образом, запрос является входящий запрос из любого браузера или

65
00:05:35,120 --> 00:05:39,700
из любого места, которое пытается получить доступ к этому серверу, который мы собираемся запустить

66
00:05:39,700 --> 00:05:45,590
с помощью этого приложения HTTP Node, которое мы разрабатываем здесь.

67
00:05:45,590 --> 00:05:47,500
Таким образом, из запроса

68
00:05:47,500 --> 00:05:53,190
объект запроса дает нам доступ к заголовкам во входящем HTTP-запросе.

69
00:05:53,190 --> 00:05:55,690
Поэтому я собираюсь записать входящие

70
00:05:55,690 --> 00:06:00,420
заголовки HTTP-запроса, поступающие с помощью этого console.log.

71
00:06:00,420 --> 00:06:05,920
Просто для моей информации, просто чтобы знать, откуда исходит этот запрос.

72
00:06:05,920 --> 00:06:11,948
После этого мы можем построить ответ, используя res, и

73
00:06:11,948 --> 00:06:16,739
это предоставит нам метод под названием StatusCode.

74
00:06:16,739 --> 00:06:24,315
StatusCode позволит нам настроить StatusCode для ответного сообщения.

75
00:06:24,315 --> 00:06:28,026
Поэтому в этом случае я настрою StatusCode как 200.

76
00:06:28,026 --> 00:06:32,259
Если вы вспомните о предыдущих обсуждениях необходимости создания сетей,

77
00:06:32,259 --> 00:06:36,576
вы будете знать, что StatusCode 200 означает, что все в порядке.

78
00:06:36,576 --> 00:06:41,856
Итак, мы настроим код состояния здесь для ответного сообщения, а

79
00:06:41,856 --> 00:06:46,763
затем мы также настроим заголовок для ответного сообщения.

80
00:06:46,763 --> 00:06:51,984
И один из заголовков опасается, что мы

81
00:06:51,984 --> 00:06:56,344
собираемся настроить называется Content-Type.

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

83
00:06:59,447 --> 00:07:04,928
мы будем указывать это как «text/html».

84
00:07:04,928 --> 00:07:13,360
Таким образом, тело ответа будет содержать данные в виде html здесь.

85
00:07:13,360 --> 00:07:18,740
Таким образом, заголовок настраивается, чтобы информировать клиента о том, что вы отправляете

86
00:07:18,740 --> 00:07:25,160
ответ, а тело отформатировано в формате html.

87
00:07:25,160 --> 00:07:27,840
И тогда, наконец, мы скажем res.end (').

88
00:07:27,840 --> 00:07:32,500
Таким образом, это заканчивается ответ здесь, и когда это будет сделано,

89
00:07:32,500 --> 00:07:37,620
эта информация будет отправлена обратно клиенту.

90
00:07:37,620 --> 00:07:45,992
Поэтому здесь, позвольте мне просто построить встраиваемую html-страницу здесь,

91
00:07:45,992 --> 00:07:52,754
поэтому я скажу <html><body><h1><Hello,

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

93
00:07:58,328 --> 00:08:04,211
И закройте тег h1, тег body

94
00:08:04,211 --> 00:08:09,270
и html-тег прямо там.

95
00:08:09,270 --> 00:08:13,850
И это действительный HTML-ответ, который

96
00:08:13,850 --> 00:08:18,100
можно отправить обратно с нашего сервера здесь.

97
00:08:18,100 --> 00:08:23,730
Таким образом, этот сервер, как вы ожидаете, просто собирается отправить привет мир клиенту.

98
00:08:23,730 --> 00:08:28,320
Так что теперь, когда мы настроили сервер, нам нужно запустить этот сервер.

99
00:08:28,320 --> 00:08:32,350
Чтобы запустить этот сервер в примечании,

100
00:08:32,350 --> 00:08:37,930
мы должны сказать server.listen.

101
00:08:37,930 --> 00:08:43,330
И это запустит прослушивающий порт, на котором сервер будет прослушивать

102
00:08:43,330 --> 00:08:45,030
входящие запросы.

103
00:08:45,030 --> 00:08:50,050
И это будет начато с номера порта, заданного моим портом,

104
00:08:50,050 --> 00:08:53,910
который мы установили уже здесь, в константном порту.

105
00:08:53,910 --> 00:08:59,990
И второй параметр - это имя хоста, которое мы уже установили ранее.

106
00:08:59,990 --> 00:09:03,560
И третий параметр - это функция, которая будет

107
00:09:04,720 --> 00:09:07,520
выполняться при запуске сервера.

108
00:09:07,520 --> 00:09:13,560
В этой функции мы просто идем, чтобы распечатать информацию о сервере.

109
00:09:13,560 --> 00:09:18,505
Поэтому здесь я просто скажу console.log.

110
00:09:19,560 --> 00:09:22,110
И в console.log

111
00:09:22,110 --> 00:09:26,640
я собираюсь распечатать информацию, поэтому я буду использовать обратную цитату.

112
00:09:26,640 --> 00:09:30,876
Поэтому обратите внимание на использование обратной цитаты, а не обычной цитаты.

113
00:09:30,876 --> 00:09:35,103
Причина, по которой мы используем это, заключается в том, что мы будем использовать

114
00:09:35,103 --> 00:09:39,830
некоторые переменные внутри строки, которую мы собираемся построить здесь.

115
00:09:39,830 --> 00:09:45,608
Итак, скажем, сервер работает на http://.

116
00:09:45,608 --> 00:09:50,965
И тогда мы скажем $, а

117
00:09:50,965 --> 00:09:55,780
затем имя Хоста.

118
00:09:55,780 --> 00:09:59,582
Напомним, что это имя хоста, вы уже объявили ранее.

119
00:09:59,582 --> 00:10:04,187
А потом вторая часть,

120
00:10:04,187 --> 00:10:08,800
скажем: $ и порт.

121
00:10:08,800 --> 00:10:14,130
Таким образом, эти два значения будут заменены соответствующими значениями.

122
00:10:14,130 --> 00:10:17,370
И так как мы вкладываем это в задние цитаты.

123
00:10:17,370 --> 00:10:21,070
И если вы включите что-то внутри доллара поднимает,

124
00:10:21,070 --> 00:10:26,150
это будет заменено на его значение в этой строке здесь.

125
00:10:28,230 --> 00:10:29,150
Вот оно.

126
00:10:29,150 --> 00:10:33,990
У нас есть простой HTTP-сервер и работает.

127
00:10:33,990 --> 00:10:37,480
Так что давайте сохраним изменения в этом.

128
00:10:37,480 --> 00:10:42,920
И мы пойдем и запустим наше приложение и посмотрим, что оно служит.

129
00:10:42,920 --> 00:10:47,010
Перейдя к терминалу, давайте напечатаем npm start, и

130
00:10:47,010 --> 00:10:50,820
это должно запустить наше приложение.

131
00:10:50,820 --> 00:10:54,020
И мы заметили, что он печатает нашу поговорку, что сервер работает

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

133
00:10:57,420 --> 00:11:05,950
Теперь вы можете получить доступ к этому URL-адресу, введя его в адресную строку любого браузера.

134
00:11:05,950 --> 00:11:09,490
Поэтому позвольте мне запустить окно браузера Chrome, а затем ввести это и

135
00:11:09,490 --> 00:11:11,340
посмотреть, что вернет сервер.

136
00:11:19,160 --> 00:11:20,848
Запуск нового окна.

137
00:11:20,848 --> 00:11:27,260
Позвольте мне просто ввести http://

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

139
00:11:34,400 --> 00:11:39,490
И это должно вернуть Hello World, как мы ожидаем.

140
00:11:39,490 --> 00:11:47,020
Теперь, когда мы идем на консоль, вы видите, что на консоли

141
00:11:48,820 --> 00:11:54,530
здесь печатаются детали заголовка входящих запросов.

142
00:11:54,530 --> 00:11:56,650
Некоторые вещи очень легко найти здесь.

143
00:11:56,650 --> 00:12:02,290
Таким образом, это хост, локальный хост: 3000, и вы также видите, что «user-agent»

144
00:12:02,290 --> 00:12:08,200
установлен на «Chrome» здесь, версия Chrome, которую я использую здесь.

145
00:12:08,200 --> 00:12:14,470
Так что это интересная иллюстрация сообщения HTTP-запроса.

146
00:12:14,470 --> 00:12:19,860
И то, что содержится в заголовке сообщения запроса, которое пришло сюда.

147
00:12:19,860 --> 00:12:24,700
Так интересно наблюдать, что ваш север

148
00:12:24,700 --> 00:12:28,690
распечатывает на экране здесь.

149
00:12:28,690 --> 00:12:32,935
Этим мы завершаем первую половину этого упражнения.

150
00:12:32,935 --> 00:12:38,895
Теперь мы можем инициализировать это приложение в репозиторий Git,

151
00:12:38,895 --> 00:12:41,505
а затем сохранить изменения в репозитории Git.

152
00:12:41,505 --> 00:12:44,695
Так что давайте продолжим и сделаем это дальше.

153
00:12:44,695 --> 00:12:51,435
При типе подсказки получить init, и это инициализировало репозиторий.

154
00:12:51,435 --> 00:12:57,420
И тогда мы скажем статус git, и вы увидите, что эти два файла являются новыми.

155
00:12:57,420 --> 00:12:59,502
Поэтому мы скажем git add.

156
00:12:59,502 --> 00:13:04,702
И сделайте git commit

157
00:13:04,702 --> 00:13:15,260
-m «Узел HTTP Пример 1".

158
00:13:15,260 --> 00:13:19,260
А затем проверьте это в нашем репозитории Git.

159
00:13:19,260 --> 00:13:22,640
Теперь еще один инструмент, который очень полезен,

160
00:13:22,640 --> 00:13:28,370
когда мы смотрим на серверные приложения называется Postman.

161
00:13:28,370 --> 00:13:33,330
Теперь Postman поставляется в виде расширения браузера Chrome или

162
00:13:33,330 --> 00:13:38,430
автономного инструмента, который вы можете скачать и установить на вашем компьютере.

163
00:13:38,430 --> 00:13:43,998
Поэтому, чтобы сделать это, в нашем браузере напечатаем http.

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

165
00:13:47,425 --> 00:13:52,550
И тогда вы можете получить

166
00:13:52,550 --> 00:13:57,660
инструмент Postman для вашей конкретной ОС и установить его.

167
00:13:57,660 --> 00:14:04,360
Инструмент Почтальон позволяет создавать HTTP-запросы, а затем отправлять их.

168
00:14:04,360 --> 00:14:09,960
И это также дает вам гибкость настройки заголовков для

169
00:14:09,960 --> 00:14:12,520
вашего HTTP-запроса перед отправкой его.

170
00:14:12,520 --> 00:14:16,140
И затем, когда ответ возвращается, вы можете проверить ответ,

171
00:14:16,140 --> 00:14:20,500
включая заголовки ответа, который возвращается со стороны сервера.

172
00:14:20,500 --> 00:14:23,160
Так что я нахожу почтальона очень полезным.

173
00:14:23,160 --> 00:14:25,410
Есть несколько других инструментов, как это,

174
00:14:25,410 --> 00:14:30,040
но Почтальон, кажется, лучший на рынке на данный момент.

175
00:14:30,040 --> 00:14:35,010
Так что я собираюсь использовать почтальона на протяжении остальной части этого курса.

176
00:14:35,010 --> 00:14:36,830
Если вы не хотите устанавливать его,

177
00:14:36,830 --> 00:14:41,720
вы также можете установить расширение браузера Chrome Postman, а затем использовать его.

178
00:14:41,720 --> 00:14:45,260
Я собираюсь загрузить версию MacOS Postman, а

179
00:14:45,260 --> 00:14:49,130
затем установить ее на свою машину, а затем использовать ее.

180
00:14:50,230 --> 00:14:54,280
После установки Postman, либо автономной версии, либо

181
00:14:54,280 --> 00:14:57,880
расширения браузера Chrome, вы можете запустить его.

182
00:14:57,880 --> 00:15:02,210
И вы увидите, что пользовательский интерфейс более или менее одинаков

183
00:15:02,210 --> 00:15:07,060
как для стандартной версии, так и для расширения браузера Chrome.

184
00:15:07,060 --> 00:15:10,955
И как только у вас есть Почтальон и работает,

185
00:15:10,955 --> 00:15:18,105
затем введите в поле URL-адрес запроса,

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

187
00:15:21,510 --> 00:15:24,090
И отправьте запрос себе.

188
00:15:24,090 --> 00:15:28,990
Убедитесь, что ваш сервер Node HTTP запущен и запущен.

189
00:15:28,990 --> 00:15:30,440
Поэтому, когда вы отправляете запрос,

190
00:15:30,440 --> 00:15:36,100
вы немедленно получите ответ от сервера с HTML-кодом здесь.

191
00:15:36,100 --> 00:15:38,170
Теперь преимущество, как вы видите,

192
00:15:38,170 --> 00:15:43,480
с использованием Почтальона заключается в том, что вы можете увидеть фактическое тело сообщения.

193
00:15:43,480 --> 00:15:49,380
Вы также можете посмотреть заголовки, чтобы увидеть, что было отправлено обратно с сервера.

194
00:15:49,380 --> 00:15:54,890
Вы также можете настроить много деталей в Postman при отправке.

195
00:15:54,890 --> 00:15:57,600
Запрос с сервера.

196
00:15:57,600 --> 00:16:02,930
Теперь многие из них могут быть не очень просто сделать с помощью стандартного окна браузера.

197
00:16:02,930 --> 00:16:07,092
Поэтому я предпочитаю использовать [INAUDIBLE] для

198
00:16:07,092 --> 00:16:10,780
генерации HTTP-запросов на мой сервер.

199
00:16:10,780 --> 00:16:14,630
А затем наблюдая за ответом, который возвращается со стороны сервера.

200
00:16:14,630 --> 00:16:20,490
Также обратите внимание, что он показывает код состояния здесь и некоторую другую информацию

201
00:16:21,650 --> 00:16:26,140
о запросе и времени ответа со стороны сервера.

202
00:16:26,140 --> 00:16:31,760
Теперь, когда мы создали его простой узел на основе HTTP сервер,

203
00:16:31,760 --> 00:16:39,380
давайте расширим его дальше, давайте создадим пару HTML-файлов в общей папке.

204
00:16:39,380 --> 00:16:43,632
Мы назовем это как index.html.

205
00:16:43,632 --> 00:16:49,657
А затем также aboutus.html,

206
00:16:49,657 --> 00:16:55,160
а затем просто включите информацию о голой кости здесь.

207
00:16:55,160 --> 00:17:00,809
Таким образом, мы скажем html, и

208
00:17:00,809 --> 00:17:08,160
заголовок, как это index.html.

209
00:17:08,160 --> 00:17:15,790
И тогда мы напечатаем тело html-страницы.

210
00:17:15,790 --> 00:17:21,044
Скажем h1 Index.html

211
00:17:21,044 --> 00:17:26,298
и тело, а затем это

212
00:17:26,298 --> 00:17:32,346
содержимое этого файла.

213
00:17:32,346 --> 00:17:36,187
Некоторый базовый html-код здесь, позвольте мне скопировать это, а

214
00:17:36,187 --> 00:17:40,040
затем вставить также на страницу aboutus.html.

215
00:17:58,607 --> 00:18:02,560
И содержимое файла aboutus.html, вот и все.

216
00:18:02,560 --> 00:18:05,310
Мы только что создали две HTML-страницы, и

217
00:18:05,310 --> 00:18:09,840
это статические HTML-страницы, которые мы создали в общей папке.

218
00:18:09,840 --> 00:18:16,800
Теперь, можем ли мы настроить наш сервер HTTP, чтобы иметь возможность обслуживать статические страницы?

219
00:18:16,800 --> 00:18:24,030
Это то, что мы собираемся настроить во второй части этого упражнения.

220
00:18:24,030 --> 00:18:27,928
Поэтому возвращаясь к файлу index.js,

221
00:18:27,928 --> 00:18:32,244
в дополнение к модулю кода HTTP,

222
00:18:32,244 --> 00:18:38,660
я также импортирую модуль кода файловой системы.

223
00:18:45,192 --> 00:18:49,920
И этот модуль кода пути.

224
00:18:51,230 --> 00:18:56,560
Путь позволяет указать часть файла в локальной файловой системе.

225
00:18:56,560 --> 00:18:59,430
Модуль файловой системы позволяет читать и

226
00:18:59,430 --> 00:19:02,330
записывать файлы из локальной файловой системы.

227
00:19:02,330 --> 00:19:08,880
Таким образом, с этим они скажут постоянный сервер, HTTP.CreateServer.

228
00:19:08,880 --> 00:19:13,583
Для журнала консоли вместо ввода в заголовки всех запросов

229
00:19:13,583 --> 00:19:17,378
я просто введу достаточно информации, поэтому

230
00:19:17,378 --> 00:19:24,212
я скажу, Request for,

231
00:19:29,291 --> 00:19:32,329
Просто URL-адрес этого запроса.

232
00:19:39,786 --> 00:19:41,195
По методу.

233
00:19:46,917 --> 00:19:51,218
Таким образом, метод будет либо получать сообщение порта, либо удалять методы.

234
00:19:51,218 --> 00:19:56,450
Таким образом, эта информация будет регистрироваться.

235
00:19:56,450 --> 00:20:01,478
Теперь, то, что мы собираемся сделать, это вместо того, чтобы отправить

236
00:20:01,478 --> 00:20:06,440
этот ответ, стандартный ответ мира приветствия.

237
00:20:06,440 --> 00:20:11,176
Здесь мы собираемся изучить метод, а

238
00:20:11,176 --> 00:20:16,600
затем мы скажем, если req.method равен GET.

239
00:20:16,600 --> 00:20:21,689
Таким образом, мы будем обслуживать только GET запросы в этом примере.

240
00:20:25,904 --> 00:20:28,750
В противном случае мы скажем, что есть if.

241
00:20:28,750 --> 00:20:34,035
Поэтому, если есть запрос GET, который приходит,

242
00:20:34,035 --> 00:20:36,911
то мы рассмотрим,

243
00:20:42,139 --> 00:20:47,577
URL, который приходит,

244
00:20:47,577 --> 00:20:55,304
поэтому мы скажем, если req.url/,

245
00:20:55,304 --> 00:21:03,615
мы скажем, FileUrl равен html.

246
00:21:03,615 --> 00:21:06,645
Поэтому, если вы не получаете конкретное имя файла, но

247
00:21:06,645 --> 00:21:10,380
вы просто отправляете запрос на локальный код хоста 3000.

248
00:21:10,380 --> 00:21:15,371
Он будет по умолчанию index.html,

249
00:21:15,371 --> 00:21:22,460
иначе он скажет, что FileUrl равен req.url.

250
00:21:24,650 --> 00:21:28,148
Таким образом, вы построили какой файл на сервер.

251
00:21:28,148 --> 00:21:35,929
Теперь мы скажем, мы найдем путь к файлу,

252
00:21:35,929 --> 00:21:41,279
мы скажем путь, Resolve,

253
00:21:41,279 --> 00:21:48,404
поэтому модуль пути поддерживает этот метод разрешения, так что это

254
00:21:52,013 --> 00:21:57,331
переведет это в полноценный файл папок пути, файл,

255
00:21:57,331 --> 00:22:01,096
который мы только что построили,

256
00:22:01,096 --> 00:22:05,620
FileUrl, который мы только что построили.

257
00:22:05,620 --> 00:22:10,480
Таким образом, это даст нам полный путь к файлу, а

258
00:22:10,480 --> 00:22:17,000
затем мы скажем константу FileExtension.

259
00:22:17,000 --> 00:22:21,524
Поэтому, если вы хотите убедиться, что

260
00:22:21,524 --> 00:22:26,808
расширение имени файла - HTML.

261
00:22:30,003 --> 00:22:32,904
Таким образом, из FilePath,

262
00:22:32,904 --> 00:22:38,402
мы рассмотрим расширение имени файла, а

263
00:22:38,402 --> 00:22:42,710
затем мы скажем, если FileExt ==.

264
00:22:42,710 --> 00:22:47,270
Поэтому, если это HTML-файл, то мы знаем, как обслуживать его из этого конкретного

265
00:22:48,410 --> 00:22:51,830
отношения узла HTTP-сервера.

266
00:22:51,830 --> 00:22:57,025
Таким образом, мы скажем, если расширение файла HTML, то мы знаем, что

267
00:22:57,025 --> 00:23:02,835
файл является HTML-файлом, и у нас есть два файла, индекс и aboutus.html.

268
00:23:02,835 --> 00:23:06,986
Таким образом, мы проверим, существует ли этот файл, поэтому

269
00:23:06,986 --> 00:23:11,435
мы скажем, если файл существует, FilePath.

270
00:23:11,435 --> 00:23:17,915
Таким образом, метод exists будет проверять, существует ли файл,

271
00:23:17,915 --> 00:23:24,180
поэтому мы скажем fs.exists (FilePath),

272
00:23:24,180 --> 00:23:26,860
и это будет принимать в

273
00:23:29,780 --> 00:23:34,170
качестве второго параметра, функцию обратного вызова.

274
00:23:34,170 --> 00:23:39,180
Поэтому обратите внимание на использование функции первого обратного вызова в нашем примере.

275
00:23:39,180 --> 00:23:46,430
Таким образом, эта функция обратного вызова будет вызываться с этим параметром существует там.

276
00:23:46,430 --> 00:23:50,740
Таким образом, внутри этого параметра обратного вызова это будет либо true, либо false.

277
00:23:50,740 --> 00:23:54,160
Таким образом, это возвращаемый параметр для этой функции обратного вызова.

278
00:23:54,160 --> 00:23:58,336
Так что здесь, Мы проверим, и

279
00:23:58,336 --> 00:24:02,584
мы скажем, если (! ), так

280
00:24:02,584 --> 00:24:08,248
что это означает, что файл не существует,

281
00:24:08,248 --> 00:24:14,241
тогда мы скажем res.statusCode = 404.

282
00:24:14,241 --> 00:24:19,107
Напомним, что если файл не существует, вы отправите код состояния 404, сказав, что

283
00:24:19,107 --> 00:24:20,608
вы не можете найти файл.

284
00:24:20,608 --> 00:24:26,393
И тогда мы скажем res.setHeader,

285
00:24:26,393 --> 00:24:33,996
и мы установим заголовок в 'Content-Type',

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

287
00:24:42,729 --> 00:24:51,940
И тогда нам нужно отправить, HTML файл здесь, или HTML-код.

288
00:24:51,940 --> 00:24:59,150
Поэтому я сделаю основной HTML-код, html body h1.

289
00:25:01,582 --> 00:25:05,590
Ошибка 404,

290
00:25:05,590 --> 00:25:12,378
скажем, + FileUrl +

291
00:25:17,421 --> 00:25:20,668
'не найден'.

292
00:25:24,185 --> 00:25:31,670
И закрыть, HTML-страницу.

293
00:25:31,670 --> 00:25:36,560
Итак, здесь, как вы заметили, вы используете функцию exists

294
00:25:36,560 --> 00:25:41,350
модуля файловой системы, чтобы проверить, существует ли файл.

295
00:25:41,350 --> 00:25:43,670
Таким образом, вы указываете путь к файлу в качестве первого параметра, а

296
00:25:43,670 --> 00:25:45,970
второй - функция обратного вызова.

297
00:25:45,970 --> 00:25:51,380
Внутри этой функции обратного вызова, если он говорит, что существует ложь, вы собираетесь

298
00:25:51,380 --> 00:25:58,010
отправить обратно стандартное сообщение об ошибке 404, заявив, что вы не можете найти файл.

299
00:25:58,010 --> 00:26:01,420
И после того, как мы это сделаем, мы просто,

300
00:26:04,918 --> 00:26:08,088
вернем, в противном случае,

301
00:26:10,507 --> 00:26:16,151
Мы скажем 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
Теперь нам нужно прочитать файл, а затем отправить файл.

305
00:26:41,950 --> 00:26:44,950
Так вот где, из модуля файловой системы,

306
00:26:44,950 --> 00:26:50,510
мы будем использовать CreateReadStream,

307
00:26:50,510 --> 00:26:54,770
который будет принимать FilePath в качестве параметра.

308
00:26:54,770 --> 00:27:00,810
Таким образом, этот метод CreateReadStream будет читать в файле из этого FilePath.

309
00:27:00,810 --> 00:27:05,930
А затем преобразуйте это в поток байтов,

310
00:27:05,930 --> 00:27:10,530
а затем они передадут это в ответ.

311
00:27:10,530 --> 00:27:15,300
Таким образом, это будет включено в ответ, в теле ответа.

312
00:27:15,300 --> 00:27:17,978
Таким образом, мы просто взяли файл, а

313
00:27:17,978 --> 00:27:22,274
затем построили его в ответ здесь.

314
00:27:22,274 --> 00:27:26,640
И все, файл готов к отправке, ясно?

315
00:27:26,640 --> 00:27:29,875
Таким образом, это если расширение файла - html,

316
00:27:29,875 --> 00:27:34,740
мы проверяем, чтобы убедиться, что вы справляетесь с этим правильно.

317
00:27:34,740 --> 00:27:38,770
Так вот где вы прочитаете файл, а затем отправите его.

318
00:27:38,770 --> 00:27:46,560
Если расширение файла не html, то, конечно, нам нужно отправить сообщение об ошибке.

319
00:27:46,560 --> 00:27:51,481
Так что прямо там мы увидим, мы скопируем этот

320
00:27:51,481 --> 00:27:56,890
конкретный, Код отсюда.

321
00:27:58,774 --> 00:28:03,364
А потом вставьте его туда.

322
00:28:03,364 --> 00:28:10,553
Скажем, иначе StatusCode = 404, контекстный текст/html,

323
00:28:10,553 --> 00:28:16,685
и сообщение об ошибке говорит: Ошибка 404, FileUrl.

324
00:28:16,685 --> 00:28:20,849
Он не найден, но

325
00:28:20,849 --> 00:28:25,250
это не HTML-файл.

326
00:28:25,250 --> 00:28:28,648
Так что это ошибка, которую мы собираемся отправить обратно в этом случае.

327
00:28:28,648 --> 00:28:34,384
И, наконец, для последнего другого случая,

328
00:28:34,384 --> 00:28:39,650
поэтому здесь мы говорим метод.

329
00:28:39,650 --> 00:28:44,910
Таким образом, это еще соответствует методу запроса.

330
00:28:44,910 --> 00:28:48,230
Поэтому, если метод запроса не GET, но какой-то другой метод запроса,

331
00:28:48,230 --> 00:28:54,380
то мы не будем обрабатывать это в этой версии наше приложение Node.

332
00:28:54,380 --> 00:28:58,333
Таким образом, мы отправим обратно StatusCode 404

333
00:28:58,333 --> 00:29:02,759
, Content html, и мы скажем об ошибке 404.

334
00:29:04,100 --> 00:29:09,117
И мы скажем, req метод,

335
00:29:11,763 --> 00:29:16,394
Не, Поддерживается,

336
00:29:16,394 --> 00:29:21,800
не поддерживается этим сервером Node HTML здесь, вот и все.

337
00:29:21,800 --> 00:29:28,667
С этими изменениями мы готовы перезапустить наш браузер.

338
00:29:28,667 --> 00:29:33,850
А затем пусть он обслуживает HTML-файлы здесь.

339
00:29:35,800 --> 00:29:42,351
Так что давайте сохраним изменения, а затем перезапустите наш сервер, а

340
00:29:42,351 --> 00:29:48,018
затем изучим, что он отправляет, когда мы отправляем различные запросы на сервер.

341
00:29:48,018 --> 00:29:51,974
Переходя к терминалу, если ваш сервер запущен,

342
00:29:51,974 --> 00:29:56,398
остановите его, введя Ctrl+C, а затем перезапустите сервер.

343
00:29:56,398 --> 00:30:00,490
И когда сервер работает, давайте отправим на него несколько запросов.

344
00:30:00,490 --> 00:30:05,722
Сначала из браузера, а затем из Почтальона.

345
00:30:05,722 --> 00:30:10,340
Зайдите в окно браузера, давайте напечатаем localhost: 3000 и

346
00:30:10,340 --> 00:30:16,320
посмотрим, что это возвращает файл index.html, как мы ожидаем.

347
00:30:16,320 --> 00:30:21,073
И тогда мы скажем localhost: 3000/index.html,

348
00:30:21,073 --> 00:30:24,974
и это также вернет файл index.html.

349
00:30:24,974 --> 00:30:32,530
Теперь, если мы отправим aboutus.html, он говорит Aboutus.html, и он возвращает его правильно.

350
00:30:32,530 --> 00:30:38,390
Давайте теперь отправим запрос на aboutus.txt и посмотрим, что он делает.

351
00:30:38,390 --> 00:30:43,365
Таким образом, он говорит, что /aboutus.txt не является HTML-файлом.

352
00:30:43,365 --> 00:30:49,992
Тогда давайте отправим запрос на test.html.

353
00:30:49,992 --> 00:30:56,005
И мы знаем, что test.html не существует, поэтому он говорит, что /test.html не найден.

354
00:30:56,005 --> 00:31:01,185
Таким образом, мы видим, что с помощью браузера, мы можем получить

355
00:31:01,185 --> 00:31:06,620
те файлы, которые существуют, и сервер может отправлять файлы в браузер.

356
00:31:06,620 --> 00:31:10,420
Давайте теперь перейдем к Postman и попробуем сгенерировать те же запросы,

357
00:31:10,420 --> 00:31:13,400
и посмотрим ответ от сервера.

358
00:31:13,400 --> 00:31:20,280
Далее, перейдя на Почтальон, давайте отправим запрос GET локальному хосту: 3000/.

359
00:31:20,280 --> 00:31:25,150
И вы видите, что это возвращает файл index.html.

360
00:31:25,150 --> 00:31:30,530
Отправим запрос на aboutus.html.

361
00:31:30,530 --> 00:31:35,159
И тогда вы видите, что он возвращает файл aboutus.html.

362
00:31:35,159 --> 00:31:38,650
И тогда мы отправим запрос в текстовый файл,

363
00:31:38,650 --> 00:31:42,240
а затем он говорит об ошибке 404, а не HTML-файл.

364
00:31:42,240 --> 00:31:46,920
И вы увидите, что статус здесь говорит, 404 не найден.

365
00:31:46,920 --> 00:31:51,400
И тогда мы, вместо отправки запроса GET,

366
00:31:51,400 --> 00:31:56,730
посмотрим, что это преимущество использования Postman, я отправлю запрос PUT.

367
00:31:56,730 --> 00:32:01,040
И вы заметите, что это говорит: Ошибка: PUT не поддерживается, и

368
00:32:01,040 --> 00:32:04,800
поэтому со статусом 404 здесь и так далее.

369
00:32:04,800 --> 00:32:11,010
Так вот как вы можете настроить сервер Node HTTP,

370
00:32:11,010 --> 00:32:16,600
чтобы иметь возможность обслуживать файлы, HTTP-файлы в этом конкретном случае.

371
00:32:16,600 --> 00:32:19,420
Теперь вы можете легко представить, что расширение

372
00:32:19,420 --> 00:32:23,900
этого HTTP-сервера для обработки многих различных типов файлов и так далее.

373
00:32:23,900 --> 00:32:25,630
Но, конечно, соответственно,

374
00:32:25,630 --> 00:32:30,350
код также усложнится, чем то, что мы имеем в данный момент.

375
00:32:30,350 --> 00:32:33,140
С этим мы завершаем это упражнение.

376
00:32:33,140 --> 00:32:38,589
В этом упражнении мы видели, как мы можем настроить простой

377
00:32:38,589 --> 00:32:45,356
сервер HTTP на основе узла, который обслуживает файлы с нашего сайта сервера.

378
00:32:45,356 --> 00:32:48,260
[ МУЗЫКА]