1
00:00:03,920 --> 00:00:10,025
Теперь, когда мы узнали о ноде MongoDB драйвер, модуль узла,

2
00:00:10,025 --> 00:00:14,205
который позволяет нашему узловому приложению иметь возможность взаимодействовать

3
00:00:14,205 --> 00:00:18,475
с сервером MongoDB, в этом упражнении

4
00:00:18,475 --> 00:00:23,430
мы будем использовать модуль узла и использовать различные методы, которые

5
00:00:23,430 --> 00:00:29,840
поддерживаются модулем узла, чтобы обеспечить введение с нашего сервера MongoDB.

6
00:00:29,840 --> 00:00:33,030
Чтобы начать работу, перейдите

7
00:00:33,030 --> 00:00:38,135
в папку NodeJS, которую вы использовали для хранения всех ваших примеров,

8
00:00:38,135 --> 00:00:45,310
а затем создайте там новую папку с именем node-mongo.

9
00:00:45,320 --> 00:00:48,125
В этой папке мы разработаем

10
00:00:48,125 --> 00:00:52,715
приложение NodeJS, которое взаимодействует с нашим сервером MongoDB.

11
00:00:52,715 --> 00:00:57,140
Теперь убедитесь, что ваш сервер MongoDB запущен и работает,

12
00:00:57,140 --> 00:01:02,675
поэтому в предыдущем упражнении мы уже видели, как наш сервер MongoDB может быть запущен.

13
00:01:02,675 --> 00:01:07,370
Таким образом, поддерживайте сервер MongoDB и в

14
00:01:07,370 --> 00:01:12,060
другом окне терминала или вкладке терминала или командном окне

15
00:01:12,060 --> 00:01:15,020
перейдите в папку node-mongo, которую вы только что

16
00:01:15,020 --> 00:01:18,135
создали, и инициализируйте приложение узла здесь.

17
00:01:18,135 --> 00:01:22,910
Итак, позвольте мне ввести npm init, и мы

18
00:01:22,910 --> 00:01:29,765
назовем приложение как Node-Mongo и версия,

19
00:01:29,765 --> 00:01:36,895
описание Node MongoDB Пример,

20
00:01:36,895 --> 00:01:39,295
и точка входа,

21
00:01:39,295 --> 00:01:48,980
и автор, так же, как мы заполняли в предыдущих упражнениях.

22
00:01:48,980 --> 00:01:53,255
Затем, как только файл package.json инициализирован,

23
00:01:53,255 --> 00:01:59,610
откройте его в редакторе по вашему выбору.

24
00:01:59,610 --> 00:02:02,635
Теперь, войдя в файл package.json,

25
00:02:02,635 --> 00:02:09,370
позвольте мне представить другой скрипт здесь, как мы делали ранее, поэтому

26
00:02:09,370 --> 00:02:16,350
мы скажем «start»: «node index» и сохраним изменения.

27
00:02:16,350 --> 00:02:18,010
Возвращаясь к терминалу,

28
00:02:18,010 --> 00:02:22,350
давайте установим модуль узла MongoDB.

29
00:02:22,350 --> 00:02:30,080
Итак, введите npm install mongodb @3 .0.10 —save.

30
00:02:30,080 --> 00:02:33,590
Мы также установим модуль узла assert, так что,

31
00:02:33,590 --> 00:02:39,460
скажем, npm install assert @1 .4.1 —save.

32
00:02:39,460 --> 00:02:42,710
Модуль assert позволяет нам использовать assert

33
00:02:42,710 --> 00:02:46,720
для проверки истинных или ложных значений в нашем приложении,

34
00:02:46,720 --> 00:02:49,535
и вы увидите, что я использую его позже.

35
00:02:49,535 --> 00:02:52,645
Теперь, когда мы установили эти модули узла,

36
00:02:52,645 --> 00:02:58,355
давайте создадим наше приложение узла, которое взаимодействует с сервером MongoDB.

37
00:02:58,355 --> 00:03:00,455
Возвращаясь к редактору,

38
00:03:00,455 --> 00:03:01,915
в папке проекта,

39
00:03:01,915 --> 00:03:05,465
создайте файл с именем index.js,

40
00:03:05,465 --> 00:03:07,684
и именно здесь мы создадим

41
00:03:07,684 --> 00:03:12,030
приложение узла, которое взаимодействует с нашим сервером MongoDB.

42
00:03:12,030 --> 00:03:14,425
Итак, в этом приложении,

43
00:03:14,425 --> 00:03:18,630
давайте напечатаем const MongoClient,

44
00:03:18,800 --> 00:03:21,555
а затем они скажут,

45
00:03:21,555 --> 00:03:28,160
require (`mongoDB), модуль узла MongoDB, который мы уже установили,

46
00:03:28,160 --> 00:03:30,335
и тогда это предоставит нам

47
00:03:30,335 --> 00:03:38,045
MongoClient, который позволяет нам подключиться к серверу MongoDB.

48
00:03:38,045 --> 00:03:47,160
Кроме того, требуется модуль assert.

49
00:03:48,830 --> 00:03:53,870
Теперь, чтобы запустить соединение с сервером MongoDB,

50
00:03:53,870 --> 00:04:03,590
давайте создадим постоянный URL-адрес имени, который будет URL-адрес, где сервер MongoDB может быть

51
00:04:03,590 --> 00:04:08,030
доступен и доступ ребенка это,

52
00:04:08,030 --> 00:04:14,950
сказав mongodb: //localhost: 27017/.

53
00:04:14,950 --> 00:04:19,360
Напомним, что это номер порта, на котором ваш сервер MongoDB работает

54
00:04:19,360 --> 00:04:25,025
под управлением 27017 const dbname=,

55
00:04:25,025 --> 00:04:27,205
а затем мы скажем, UniGate.

56
00:04:27,205 --> 00:04:28,820
Напомним, что

57
00:04:28,820 --> 00:04:34,060
в предыдущем упражнении мы создали базу данных MuniCT на нашем сервере MongoDB

58
00:04:34,060 --> 00:04:39,310
, так что мы собираемся получить доступ к этой базе данных MuniCT, которую мы создали ранее.

59
00:04:39,310 --> 00:04:46,240
Теперь, чтобы получить доступ к серверу, мы скажем MongoClient.connect.

60
00:04:48,690 --> 00:04:54,790
Таким образом, метод connect позволяет нам подключиться к MongoClient с нашего сервера MongoDB,

61
00:04:54,790 --> 00:04:59,230
а затем мы скажем, что это принимает URL в качестве первого параметра,

62
00:04:59,230 --> 00:05:02,485
URL сервера MongoDB в качестве первого параметра.

63
00:05:02,485 --> 00:05:06,590
Второй параметр - функция обратного вызова.

64
00:05:06,590 --> 00:05:14,275
Таким образом, функция обратного вызова имеет два параметра, значение ошибки

65
00:05:14,275 --> 00:05:17,915
и клиент, который мы затем можем использовать

66
00:05:17,915 --> 00:05:22,405
для подключения к нашей базе данных, а затем выполнять различные операции.

67
00:05:22,405 --> 00:05:27,040
Итак, внутри этой функции обратного вызова

68
00:05:27,040 --> 00:05:36,400
первое, что мы сделаем, это проверить, чтобы убедиться, что ошибка не равна нулю.

69
00:05:36,400 --> 00:05:39,740
Таким образом, assert будет проверять, равна ли ошибка нулю,

70
00:05:39,740 --> 00:05:45,640
поэтому функция assert позволяет нам выполнять различные проверки значений.

71
00:05:45,640 --> 00:05:48,010
Итак, мы проверяем, чтобы убедиться, что ошибка не является,

72
00:05:48,010 --> 00:05:49,785
если она не равна нулю,

73
00:05:49,785 --> 00:05:55,660
то это означает, что есть ошибка, и поэтому мы покажем ошибку на экране.

74
00:05:55,660 --> 00:05:59,650
Итак, это использование функции assert здесь.

75
00:05:59,650 --> 00:06:03,025
Теперь, если этого не произойдет,

76
00:06:03,025 --> 00:06:07,430
то это означает, что мы правильно подключены к серверу,

77
00:06:07,430 --> 00:06:15,170
поэтому мы скажем «правильно подключены к серверу`

78
00:06:15,170 --> 00:06:25,120
const db= client.db (dbname) для подключения к базе данных,

79
00:06:25,120 --> 00:06:33,570
тогда мы можем сказать const collection db. ,

80
00:06:33,570 --> 00:06:38,810
поэтому db предоставит нам различные методы, которые позволяют нам

81
00:06:38,810 --> 00:06:44,380
взаимодействовать с сервером, поэтому мы скажем db.collection (`dishes`) Таким образом,

82
00:06:44,380 --> 00:06:49,765
мы попытаемся получить доступ к коллекции блюд в этой базе данных.

83
00:06:49,765 --> 00:06:55,175
Теперь следующее, что мы попытаемся сделать, это

84
00:06:55,175 --> 00:07:04,414
collection.insertone, поэтому мы попытаемся вставить один объект в коллекцию,

85
00:07:04,414 --> 00:07:08,360
и этот объект будет с

86
00:07:08,360 --> 00:07:28,510
именем и описанием, «тест».

87
00:07:28,510 --> 00:07:32,520
Таким образом, эта коллекция предоставляет этот метод под названием InserTone,

88
00:07:32,520 --> 00:07:36,825
который позволяет нам вставить один документ в эту коллекцию,

89
00:07:36,825 --> 00:07:42,825
и документ является первым аргументом этого метода здесь.

90
00:07:42,825 --> 00:07:49,780
Вторым аргументом метода является функция обратного вызова,

91
00:07:49,780 --> 00:07:56,720
и функция обратного вызова принимает два параметра: ошибку и результат.

92
00:07:58,260 --> 00:08:01,000
Таким образом, в рамках этой функции обратного вызова,

93
00:08:01,000 --> 00:08:03,180
если результат получен,

94
00:08:03,180 --> 00:08:08,610
то мы можем получить доступ к коллекции, а затем выполнить дальнейшие операции.

95
00:08:08,610 --> 00:08:16,645
Итак, здесь первое, что мы сделаем, это проверить, чтобы убедиться, что ошибка не равна нулю.

96
00:08:16,645 --> 00:08:19,450
Итак, мы сделаем утверждение там,

97
00:08:19,450 --> 00:08:33,470
а затем здесь мы можем сказать: «После вставки».

98
00:08:37,770 --> 00:08:45,145
Итак, после вставки, то мы видим, что мы

99
00:08:45,145 --> 00:08:51,490
получаем значение результата, которое возвращается там, поэтому этот результат.

100
00:08:51,490 --> 00:08:56,070
Этот результат также предоставит

101
00:08:56,070 --> 00:09:00,805
это свойство OPS, в котором указано, сколько операций только что было выполнено успешно.

102
00:09:00,805 --> 00:09:02,715
Так вот, что я собираюсь распечатать.

103
00:09:02,715 --> 00:09:05,140
Таким образом, он скажет, что число вставлено - это один.

104
00:09:05,140 --> 00:09:12,030
Таким образом, это означает, что этот конкретный документ был вставлен в базу данных.

105
00:09:12,070 --> 00:09:15,440
Так вот, что мы подтвердим здесь.

106
00:09:15,440 --> 00:09:19,810
Затем, после этого, мы выполним другой вариант,

107
00:09:19,810 --> 00:09:22,415
операцию над коллекцией, и скажем

108
00:09:22,415 --> 00:09:30,200
, коллекцию найти, и мы попытаемся найти все записи в коллекции.

109
00:09:30,200 --> 00:09:37,420
Итак, здесь мы предоставим пустую строку JSON или соответствующий объект JavaScript уровня.

110
00:09:37,420 --> 00:09:40,895
Таким образом, он будет искать все, что есть в коллекции,

111
00:09:40,895 --> 00:09:43,750
а затем, предоставлять это нам.

112
00:09:43,750 --> 00:09:48,640
Затем это может быть преобразовано в массив объектов JSON.

113
00:09:48,640 --> 00:09:52,215
Итак, вот почему мы вызываем toArray,

114
00:09:52,215 --> 00:09:59,365
и это принимает функцию обратного вызова в качестве параметра.

115
00:09:59,365 --> 00:10:07,065
Первый параметр, конечно, это значение ошибки, поэтому снова

116
00:10:07,065 --> 00:10:16,365
мы проверяем, чтобы убедиться, что ошибка не равна нулю.

117
00:10:16,365 --> 00:10:25,990
Тогда мы скажем, console.log найден,

118
00:10:25,990 --> 00:10:29,140
а затем распечатаем все, что было найдено,

119
00:10:29,140 --> 00:10:32,505
и мы скажем console.log.

120
00:10:32,505 --> 00:10:35,080
Итак, второй параметр здесь, docs,

121
00:10:35,080 --> 00:10:38,370
вернет все документы из этой коллекции,

122
00:10:38,370 --> 00:10:42,380
которые соответствуют любым критериям, которые вы указываете здесь.

123
00:10:42,380 --> 00:10:43,970
Так как это пусто,

124
00:10:43,970 --> 00:10:47,535
то это означает, что все документы в коллекции будут возвращены нам.

125
00:10:47,535 --> 00:10:49,500
Здесь можно указать фильтр,

126
00:10:49,500 --> 00:10:54,030
сказав, что имя равно значению,

127
00:10:54,030 --> 00:10:57,325
и затем будут извлечены только те документы, которые соответствуют этому значению.

128
00:10:57,325 --> 00:11:04,040
Итак, позвольте мне просто распечатать документы здесь,

129
00:11:04,040 --> 00:11:07,660
чтобы указать, что этот элемент

130
00:11:07,660 --> 00:11:11,990
был вставлен в коллекцию, а затем будет извлечен,

131
00:11:11,990 --> 00:11:15,950
а затем мы просто распечатаем его, чтобы убедиться, что документ, который мы только что

132
00:11:15,950 --> 00:11:20,590
вставили в предыдущей операции, действительно в коллекции,

133
00:11:20,590 --> 00:11:22,420
и мы распечатаем это здесь.

134
00:11:22,420 --> 00:11:28,060
Теперь после этого мы будем использовать

135
00:11:28,060 --> 00:11:35,880
метод DropCollection здесь.

136
00:11:35,880 --> 00:11:40,560
Таким образом, DropCollection удалит указанную коллекцию здесь.

137
00:11:40,560 --> 00:11:42,410
Итак, мы скажем блюда DropCollection,

138
00:11:42,410 --> 00:11:45,820
поэтому я просто собираюсь удалить коллекцию блюд из моей базы данных.

139
00:11:45,820 --> 00:11:48,180
Итак, я просто собираюсь очистить базу данных, а затем оставить

140
00:11:48,180 --> 00:11:51,090
ее с пустой базой данных, чтобы мы могли перейти

141
00:11:51,090 --> 00:11:53,610
на следующее упражнение, где мы можем снова

142
00:11:53,610 --> 00:11:57,115
выполнить аналогичные операции, чтобы проверить это.

143
00:11:57,115 --> 00:12:00,455
Это принимает в качестве второго параметра

144
00:12:00,455 --> 00:12:06,815
функцию обратного вызова, которая возвращает либо ошибку, либо результат.

145
00:12:06,815 --> 00:12:16,040
Внутри этого мы проверим и убедитесь, что утверждение не является нулевым,

146
00:12:16,440 --> 00:12:20,780
а затем мы скажем, client.close.

147
00:12:20,780 --> 00:12:25,425
Таким образом, мы закроем соединение с базой данных на месте.

148
00:12:25,425 --> 00:12:34,465
Таким образом, этот простой набор методов позволяет нам взаимодействовать с нашим сервером,

149
00:12:34,465 --> 00:12:41,150
а также он демонстрирует нам, как мы можем общаться с сервером, используя

150
00:12:41,150 --> 00:12:48,185
методы, которые доступны через этот модуль узла MongoDB или драйвер MongoDB.

151
00:12:48,185 --> 00:12:51,900
Итак, здесь вы видите, что сначала мы выполняем операцию вставки.

152
00:12:51,900 --> 00:12:54,875
Затем после операции вставки обратите внимание, что

153
00:12:54,875 --> 00:12:59,715
мы выполняем вторую операцию внутри функции обратного вызова.

154
00:12:59,715 --> 00:13:07,490
Таким образом, это гарантирует, что эта операция была завершена перед выполнением следующей операции.

155
00:13:07,490 --> 00:13:15,680
Итак, это второй вызов, который заключен внутри первой функции обратного вызова,

156
00:13:15,680 --> 00:13:19,470
а затем, соответственно, внутри этого.

157
00:13:19,470 --> 00:13:24,370
Мы снова вызываем методы здесь и внутри.

158
00:13:24,370 --> 00:13:28,080
Итак, вы видите, что есть вложенность этих вызовов,

159
00:13:28,080 --> 00:13:29,435
один внутри другого.

160
00:13:29,435 --> 00:13:32,200
Обратите внимание на структуру, потому что я собираюсь вернуться, чтобы

161
00:13:32,200 --> 00:13:35,755
объяснить что-то об этом в одном из последующих упражнений.

162
00:13:35,755 --> 00:13:40,235
Итак, обратите внимание, что вложенность этих вызовов один внутри другого.

163
00:13:40,235 --> 00:13:43,020
Давайте сохраним изменения,

164
00:13:43,210 --> 00:13:49,330
а затем посмотрим, что это приложение делает, когда мы его выполняем.

165
00:13:49,330 --> 00:13:51,685
Возвращаясь к терминалу, снова

166
00:13:51,685 --> 00:13:55,170
убедитесь, что ваш сервер MongoDB работает и работает, и поэтому,

167
00:13:55,170 --> 00:14:00,560
когда он работает, он собирается распечатать много сообщений журнала на консоли.

168
00:14:00,560 --> 00:14:04,230
Мы можем просто игнорировать эти сообщения журнала пока.

169
00:14:04,230 --> 00:14:06,710
Давайте запустим приложение узла.

170
00:14:06,710 --> 00:14:09,330
Итак, скажем, npm start,

171
00:14:09,330 --> 00:14:12,095
и когда приложение узла запускается,

172
00:14:12,095 --> 00:14:14,875
вы замечаете, что делает приложение узла.

173
00:14:14,875 --> 00:14:19,705
Так что он говорит, правильно подключен к серверу, После вставки,

174
00:14:19,705 --> 00:14:22,260
то он показывает, что

175
00:14:22,260 --> 00:14:28,375
этот конкретный документ был вставлен в наш MongoDB и узел в частности,

176
00:14:28,375 --> 00:14:29,540
идентификатор, указанный здесь.

177
00:14:29,540 --> 00:14:32,570
Итак, обратите внимание, что это не говорит, что это идентификатор объекта.

178
00:14:32,570 --> 00:14:35,995
Этот идентификатор автоматически вставляется

179
00:14:35,995 --> 00:14:39,730
узлом Mongo драйвер в их документ, когда

180
00:14:39,730 --> 00:14:43,745
вы пытаетесь вставить его в сервер MongoDB здесь.

181
00:14:43,745 --> 00:14:48,950
Этот формат точно такой же, как идентификатор объекта, который мы видели.

182
00:14:48,950 --> 00:14:53,910
После этого мы провели операцию поиска.

183
00:14:53,910 --> 00:14:55,560
Итак, это найдено,

184
00:14:55,560 --> 00:14:58,710
а затем распечатывает этот предмет здесь.

185
00:14:58,710 --> 00:15:01,550
Обратите внимание, что из предыдущего упражнения

186
00:15:01,550 --> 00:15:08,470
мы оставили в предыдущем документе, который мы включили в предыдущем упражнении.

187
00:15:08,470 --> 00:15:11,005
Таким образом, это все еще видно в коллекции здесь,

188
00:15:11,005 --> 00:15:13,500
и новый документ, который мы только что вставили здесь.

189
00:15:13,500 --> 00:15:17,179
Этот документ виден прямо ниже этого,

190
00:15:17,179 --> 00:15:20,510
но обратите внимание, что эти два имеют два разных идентификатора.

191
00:15:20,510 --> 00:15:25,030
Этот идентификатор соответствует идентификатору документа, который мы только что вставили.

192
00:15:25,030 --> 00:15:28,455
Итак, это остаётся от предыдущего упражнения.

193
00:15:28,455 --> 00:15:32,765
После этого, конечно, мы отбрасываем коллекцию, так что

194
00:15:32,765 --> 00:15:38,060
весь набор документов и коллекция блюд будут удалены из нашей базы данных.

195
00:15:38,060 --> 00:15:41,060
Итак, теперь наша база данных будет чистой и пустой.

196
00:15:41,060 --> 00:15:44,930
Таким образом, это демонстрирует вам, как мы можем использовать

197
00:15:44,930 --> 00:15:52,900
драйвер MongoDB для связи из нашего приложения узла с сервером.

198
00:15:52,900 --> 00:15:55,330
Теперь, когда у нас есть наше приложение,

199
00:15:55,330 --> 00:16:01,000
позвольте мне представить

200
00:16:01,000 --> 00:16:06,720
здесь a.gitignore, а затем поместить модули узлов в.gitignore,

201
00:16:06,720 --> 00:16:10,540
и вы быстро понимаете, почему я это делаю.

202
00:16:10,540 --> 00:16:16,595
Затем мы вернемся и инициализируем репозиторий Git, а затем выполним git фиксацию.

203
00:16:16,595 --> 00:16:18,590
Возвращаясь к терминалу,

204
00:16:18,590 --> 00:16:21,505
позвольте мне инициализировать репозиторий Git,

205
00:16:21,505 --> 00:16:31,460
а затем, давайте проверим статус Git, и вы увидите, что есть некоторые незафиксированные файлы.

206
00:16:31,460 --> 00:16:37,204
Поэтому позвольте мне проверить их, а затем выполнить git фиксацию с сообщением,

207
00:16:37,204 --> 00:16:46,450
Node MongoDB Пример один.

208
00:16:46,450 --> 00:16:49,305
Это первая часть упражнения,

209
00:16:49,305 --> 00:16:54,020
поэтому мы просто проверим элементы в нашем репозитории git.

210
00:16:54,020 --> 00:16:56,900
Это упражнение завершается.

211
00:16:56,900 --> 00:17:01,760
В этом упражнении мы видели, как мы устанавливаем модуль узла,

212
00:17:01,760 --> 00:17:04,365
драйвер MongoDB, затем,

213
00:17:04,365 --> 00:17:07,835
мы смогли связаться с нашим сервером MongoDB из

214
00:17:07,835 --> 00:17:12,740
нашего приложения узла, используя методы, которые предоставляются драйвером MongoDB.

215
00:17:12,740 --> 00:17:17,840
Мы продолжим это упражнение в следующей части

216
00:17:17,840 --> 00:17:24,380
упражнения, где мы рассмотрим еще несколько методов драйвера MongoDB.