1
00:00:03,950 --> 00:00:09,370
В этом упражнении мы продолжим предыдущее упражнение, где мы

2
00:00:09,370 --> 00:00:14,650
разработали взаимодействие между приложением узла и сервером MongoDB.

3
00:00:14,650 --> 00:00:18,120
В этом упражнении я собираюсь инкапсулировать несколько

4
00:00:18,120 --> 00:00:21,750
операций с базой данных в собственный модуль узла,

5
00:00:21,750 --> 00:00:23,540
файловый модуль узла,

6
00:00:23,540 --> 00:00:29,345
а затем использовать его в моем приложении узла для взаимодействия с сервером.

7
00:00:29,345 --> 00:00:31,940
В то же время, мы выполним несколько операций

8
00:00:31,940 --> 00:00:35,630
на сервере, чтобы продемонстрировать, что мы сможем

9
00:00:35,630 --> 00:00:43,040
взаимодействовать с сервером, используя наше приложение узла и драйвер узла MongoDB.

10
00:00:43,040 --> 00:00:47,605
Чтобы начать работу, давайте перейдем к нашему проекту,

11
00:00:47,605 --> 00:00:53,975
а затем создадим новый файл с именем operations.js.

12
00:00:53,975 --> 00:00:57,720
Этот файл инкапсулирует все операции с базой данных,

13
00:00:57,720 --> 00:01:00,705
четыре операции, которые я собираюсь выполнить вставку,

14
00:01:00,705 --> 00:01:05,855
поиск, удаление и обновление документа в моей базе данных.

15
00:01:05,855 --> 00:01:09,980
Теперь это будет организовано как файловый модуль узла,

16
00:01:09,980 --> 00:01:15,070
который затем я буду использовать его в моем узловом приложении для доступа к серверу.

17
00:01:15,070 --> 00:01:16,330
Итак, чтобы начать, позвольте

18
00:01:16,330 --> 00:01:25,780
мне сначала потребовать assert,

19
00:01:25,780 --> 00:01:27,565
в этом модуле узла,

20
00:01:27,565 --> 00:01:30,225
и так как это происходит, чтобы быть модулем узла,

21
00:01:30,225 --> 00:01:35,055
мы будем экспортировать несколько методов из модуля узла.

22
00:01:35,055 --> 00:01:41,705
Первый метод будет вставлять документ, очевидно, как вы ожидали,

23
00:01:41,705 --> 00:01:44,520
и это займет четыре параметра DB,

24
00:01:44,520 --> 00:01:49,555
MongoDB, соединение с базой данных в моем приложении узла,

25
00:01:49,555 --> 00:01:54,240
которое я получу в приложении узла.

26
00:01:54,240 --> 00:01:57,785
Затем второй - это документ, который я хочу вставить.

27
00:01:57,785 --> 00:02:02,800
Третий параметр - это коллекция, в которую я хочу вставить документ.

28
00:02:02,800 --> 00:02:05,675
Последняя - это функция обратного вызова,

29
00:02:05,675 --> 00:02:10,425
которая будет вызвана после завершения этой операции.

30
00:02:10,425 --> 00:02:14,800
Затем давайте закроем функцию здесь,

31
00:02:14,800 --> 00:02:20,100
и это по существу инкапсулирует метод вставки документа здесь.

32
00:02:20,100 --> 00:02:27,415
Таким образом, это функция, которая экспортируется этим модулем узла здесь.

33
00:02:27,415 --> 00:02:34,250
Теперь я также собираюсь включить несколько других методов здесь.

34
00:02:34,250 --> 00:02:42,870
Вторым будет поиск документов.

35
00:02:42,870 --> 00:02:46,025
Не один, а несколько документов.

36
00:02:46,025 --> 00:02:54,390
Это я бы искал коллекцию и нашел все документы, которые находятся в коллекции.

37
00:02:54,390 --> 00:02:58,130
Поэтому я принимаю только базу данных

38
00:02:58,130 --> 00:03:02,090
и коллекцию в качестве двух параметров вместе с обратным вызовом.

39
00:03:02,090 --> 00:03:11,550
Третья функция, которую я собираюсь реализовать экспорт отсюда, - это removedocument.

40
00:03:12,290 --> 00:03:15,590
Это поддерживает операцию удаления,

41
00:03:15,590 --> 00:03:19,855
и поэтому имя документа будет принимать базу данных, документ,

42
00:03:19,855 --> 00:03:23,775
коллекцию и обратный вызов в качестве четырех параметров,

43
00:03:23,775 --> 00:03:30,595
и мы будем вызывать обратный вызов после завершения операции.

44
00:03:30,595 --> 00:03:34,445
Последним, конечно, является обновление документа.

45
00:03:34,445 --> 00:03:38,120
Конечно, вы не обязательно должны делать это таким образом.

46
00:03:38,120 --> 00:03:42,830
Я просто чувствовал, что это будет еще один способ иллюстрации того, как вы можете

47
00:03:42,830 --> 00:03:49,110
инкапсулировать эти функции в свой собственный модуль узла.

48
00:03:49,110 --> 00:03:55,395
Это просто реорганизация кода таким образом, который более удобен в использовании.

49
00:03:55,395 --> 00:03:57,205
Таким образом, для экспорта,

50
00:03:57,205 --> 00:04:00,070
для документа обновления он принимает БД,

51
00:04:00,070 --> 00:04:03,750
некоторый способ идентификации документа в качестве второго параметра.

52
00:04:03,750 --> 00:04:06,205
Третьим параметром является обновление,

53
00:04:06,205 --> 00:04:08,750
а четвертым параметром является коллекция, в которой

54
00:04:08,750 --> 00:04:11,505
существует этот документ, и обратный вызов.

55
00:04:11,505 --> 00:04:18,160
Таким образом, четыре функции, которые будут экспортированы файлом operations.js.

56
00:04:18,160 --> 00:04:20,380
Теперь, в рамках этих функций,

57
00:04:20,380 --> 00:04:21,735
давайте реализовываем один за другим.

58
00:04:21,735 --> 00:04:23,420
В документе вставки

59
00:04:23,420 --> 00:04:27,680
первое, что я собираюсь сделать, это сказать

60
00:04:27,680 --> 00:04:36,000
const collection, и он скажет коллекцию DB,

61
00:04:38,930 --> 00:04:44,710
а параметр - это коллекция.

62
00:04:45,350 --> 00:04:50,190
Итак, мы поищем там коллекцию.

63
00:04:50,190 --> 00:04:54,640
Теперь это должно быть выполнено во всех четырех методах.

64
00:04:54,640 --> 00:04:59,990
Итак, я собираюсь пойти и вставить этот код во все четыре метода здесь,

65
00:05:01,140 --> 00:05:05,390
потому что это функция, которая мне нужна во всех них.

66
00:05:05,390 --> 00:05:07,820
Итак, как только я получу коллекцию,

67
00:05:07,820 --> 00:05:11,680
то, как вы помните из предыдущего упражнения,

68
00:05:11,680 --> 00:05:13,895
я могу выполнять операции над коллекцией.

69
00:05:13,895 --> 00:05:19,160
Итак, я скажу, что коллекция, вставка,

70
00:05:21,300 --> 00:05:27,610
и это принимает в качестве первого параметра документ, который должен быть вставлен,

71
00:05:27,610 --> 00:05:35,695
а второй параметр - обратный вызов с ошибкой и этим результатом.

72
00:05:35,695 --> 00:05:40,990
Итак, теперь, когда этот документ

73
00:05:40,990 --> 00:05:46,780
вставляется путем вызова метода вставки в коллекции базы данных,

74
00:05:46,780 --> 00:05:49,180
метод вставки позвольте мне напомнить вам,

75
00:05:49,180 --> 00:05:52,090
поддерживается драйвером MongoDB.

76
00:05:52,090 --> 00:05:53,980
Итак, это метод, который мы используем здесь,

77
00:05:53,980 --> 00:05:56,420
или это функция, которую мы используем здесь.

78
00:05:56,420 --> 00:06:05,060
Итак, первое, что я собираюсь проверить на это, assertequal err, null.

79
00:06:05,060 --> 00:06:09,185
Итак, я хочу убедиться, что у меня нет ошибки.

80
00:06:09,185 --> 00:06:11,225
Поэтому я хочу убедиться, что ошибка равна нулю.

81
00:06:11,225 --> 00:06:12,470
Если он не равен нулю,

82
00:06:12,470 --> 00:06:15,930
то это будет распечатывать информацию, а затем выйти из приложения.

83
00:06:15,930 --> 00:06:19,760
В этот момент я чувствую, что это нормально, чтобы справиться с этим, что позже,

84
00:06:19,760 --> 00:06:24,680
мы увидим, как мы можем иметь глобальный способ обработки всех ошибок, когда мы

85
00:06:24,680 --> 00:06:34,390
реализуем в следующем уроке другой способ доступа к базе данных MongoDB.

86
00:06:34,390 --> 00:06:36,640
Теперь, после того, как

87
00:06:36,640 --> 00:06:38,050
я сделаю это, я собираюсь реализовать,

88
00:06:38,050 --> 00:06:40,075
я просто записать эту информацию.

89
00:06:40,075 --> 00:06:48,570
Так что я скажу, консольный журнал и вставьте его.

90
00:06:48,570 --> 00:06:55,375
Таким образом, эта информация будет распечатана на экране здесь, вставлен.

91
00:06:55,375 --> 00:07:00,440
Теперь снова помните точки с запятой и все, что

92
00:07:00,440 --> 00:07:05,120
важно, не забывайте их при вводе кода.

93
00:07:05,120 --> 00:07:07,930
Итак, я скажу вставленный результат.

94
00:07:07,930 --> 00:07:12,165
Этот объект результата, который возвращается,

95
00:07:12,165 --> 00:07:15,785
будет иметь на нем свойство, называемое свойством результата,

96
00:07:15,785 --> 00:07:20,270
и это свойство будет содержать значение.

97
00:07:20,270 --> 00:07:23,600
Это свойство результата также является объектом JavaScript,

98
00:07:23,600 --> 00:07:31,395
и это будет содержать свойство n, которое сообщает нам, сколько документов было вставлено.

99
00:07:31,395 --> 00:07:36,875
Вот информация, которую я собираюсь распечатать здесь,

100
00:07:36,875 --> 00:07:39,540
а потом мы перейдем к следующей строке и

101
00:07:39,540 --> 00:07:50,750
скажем «документы в коллекцию».

102
00:07:53,070 --> 00:08:02,040
Теперь это просто способ информировать пользователя о том, что эта операция прошла правильно,

103
00:08:02,040 --> 00:08:10,135
а затем они передадут этот результат обратно в нашу вызывающую функцию.

104
00:08:10,135 --> 00:08:15,330
Итак, мы вызовем обратный вызов, а затем результат будет параметром обратного вызова.

105
00:08:15,330 --> 00:08:21,595
Таким образом, когда мы реализуем использование этой функции в нашем файле index.js,

106
00:08:21,595 --> 00:08:23,930
мы будем предоставлять обратный вызов там, который

107
00:08:23,930 --> 00:08:26,880
получит результат в качестве входящего параметра.

108
00:08:26,880 --> 00:08:30,670
Итак, это для «InsertDocument».

109
00:08:30,670 --> 00:08:33,010
Теперь, для «FindDocument

110
00:08:33,010 --> 00:08:36,750
», что я собираюсь сделать, это сказать

111
00:08:37,010 --> 00:08:41,640
«coll.find», и я собираюсь найти все документы.

112
00:08:41,640 --> 00:08:44,810
Поэтому я дам здесь пустой объект JavaScript,

113
00:08:44,810 --> 00:08:51,040
который будет соответствовать всем документам в коллекции, а затем я скажу:

114
00:08:51,040 --> 00:09:01,820
«toArray», и это будет принимать в качестве параметра функцию обратного вызова,

115
00:09:02,220 --> 00:09:06,505
и внутри этой функции обратного вызова, конечно,

116
00:09:06,505 --> 00:09:11,710
я буду утверждать, что это не null,

117
00:09:11,710 --> 00:09:20,590
и тогда мы скажем: «обратный вызов документов».

118
00:09:20,590 --> 00:09:27,440
Мы просто передадим обратно извлеченные документы обратно в вызывающую функцию.

119
00:09:28,200 --> 00:09:37,750
Теперь, для «RemoveDocument», я собираюсь сказать, «коллекция DeleteOne».

120
00:09:37,750 --> 00:09:40,270
Итак, я попытаюсь найти первый документ, который

121
00:09:40,270 --> 00:09:45,130
соответствует тому, что мы указали, а затем удалить его.

122
00:09:45,130 --> 00:09:47,070
И тогда это займет, опять же,

123
00:09:47,070 --> 00:09:50,380
функцию обратного вызова в качестве второго параметра,

124
00:09:50,380 --> 00:09:52,685
и внутри этой функции обратного вызова

125
00:09:52,685 --> 00:09:58,160
первое, что я проверяю, - убедиться, что ошибка не равна нулю.

126
00:09:58,160 --> 00:10:01,820
А потом, скажем,

127
00:10:02,130 --> 00:10:20,890
«консольный журнал удалил документ с запятой».

128
00:10:20,890 --> 00:10:24,840
Мы использовали запятую здесь, потому что это объект JavaScript, поэтому,

129
00:10:24,840 --> 00:10:26,890
если вы укажете консольный журнал, как это,

130
00:10:26,890 --> 00:10:30,360
документ будет распечатан, а затем мы передадим

131
00:10:30,360 --> 00:10:36,705
этот результат обратно через функцию обратного вызова.

132
00:10:36,705 --> 00:10:47,550
И затем, наконец, для обновления мы собрать.UpdateOne.

133
00:10:47,670 --> 00:10:52,255
Это метод, который поддерживает драйвер MongoDB.

134
00:10:52,255 --> 00:10:56,560
Итак, я скажу: «Update.One document

135
00:10:56,560 --> 00:11:01,480
», и второй параметр - это то, где мы

136
00:11:01,480 --> 00:11:06,960
будем передавать в поля, которые нужно обновить.

137
00:11:06,960 --> 00:11:08,915
И как это делается,

138
00:11:08,915 --> 00:11:12,810
мы скажем: «Обновление двоеточия в долларах».

139
00:11:12,810 --> 00:11:16,100
Таким образом, это займет информацию об обновлении, которую

140
00:11:16,100 --> 00:11:19,120
я отправляю, а затем передаст ее в Update.One.

141
00:11:19,120 --> 00:11:21,620
Первый — это документ, который необходимо обновить.

142
00:11:21,620 --> 00:11:25,425
Второй — то, какие поля документа должны быть обновлены здесь.

143
00:11:25,425 --> 00:11:28,660
И третий параметр равен нулю

144
00:11:28,770 --> 00:11:36,305
, и последний параметр является функцией обратного вызова,

145
00:11:36,305 --> 00:11:45,660
которая, очевидно, даст нам результат операции.

146
00:11:45,660 --> 00:11:51,125
Итак, первое, что я собираюсь проверить, чтобы убедиться, что ошибка не равна нулю.

147
00:11:51,125 --> 00:11:59,535
Затем я сделаю «журнал консоли обновил документ с помощью».

148
00:11:59,535 --> 00:12:03,195
Теперь снова, консольные журналы исключительно для нас, чтобы

149
00:12:03,195 --> 00:12:07,920
убедиться, что код делает то, что он делает.

150
00:12:07,920 --> 00:12:09,690
Это никак не помогает.

151
00:12:09,690 --> 00:12:11,995
Это только для нашей собственной информации.

152
00:12:11,995 --> 00:12:15,070
На производственном сервере у

153
00:12:15,070 --> 00:12:18,570
вас не было бы этих консольных журналов, возможно.

154
00:12:18,570 --> 00:12:24,220
Вы можете отключить их. Так вот и всё.

155
00:12:24,220 --> 00:12:32,370
Таким образом, четыре метода, поддерживаемые в этом конкретном модуле на основе файла узла вставки,

156
00:12:32,370 --> 00:12:35,040
поиска, удаления и обновления.

157
00:12:35,040 --> 00:12:38,490
Итак, теперь, когда мы реализовали этот файловый модуль узла,

158
00:12:38,490 --> 00:12:41,185
давайте перейдем к файлу index.js,

159
00:12:41,185 --> 00:12:45,985
а затем, чтобы использовать этот файловый модуль узла,

160
00:12:45,985 --> 00:12:48,010
мне нужно потребовать это здесь.

161
00:12:48,010 --> 00:12:53,969
Так что, я скажу: «Конст Дбопер требует».

162
00:12:53,969 --> 00:13:00,155
Поскольку это файловый модуль узла, вы получаете полный путь к модулю узла,

163
00:13:00,155 --> 00:13:03,865
и который в этом случае случается. /operations

164
00:13:03,865 --> 00:13:09,760
, потому что он находится в той же папке, что и мой файл index.js.

165
00:13:09,760 --> 00:13:12,400
Теперь, как только мы сделали это,

166
00:13:12,400 --> 00:13:19,570
затем прямо здесь, эта функция,

167
00:13:19,570 --> 00:13:24,355
этот код, который мы делали, чтобы получить доступ к базе данных теперь вставить,

168
00:13:24,355 --> 00:13:32,430
мы будем использовать dboper, который мы только что реализовали для доступа к этой базе данных.

169
00:13:32,430 --> 00:13:36,280
Итак, скажем, «dboper insert document

170
00:13:36,280 --> 00:13:40,345
», и этот «insert document» принимает db в качестве первого параметра.

171
00:13:40,345 --> 00:13:45,015
db здесь, это этот db, который пришел, когда мы вызываем соединение MongoClient.

172
00:13:45,015 --> 00:13:48,010
Таким образом, db будет передан, так что

173
00:13:48,010 --> 00:13:53,805
мой модуль узла операций знает, где получить доступ к базе данных.

174
00:13:53,805 --> 00:13:59,325
Затем второй параметр является,

175
00:13:59,325 --> 00:14:03,950
поэтому, если вы посмотрите на «вставить документ», вы увидите

176
00:14:03,950 --> 00:14:08,055
, что второй параметр является документ, который будет вставлен.

177
00:14:08,055 --> 00:14:10,850
Итак, я скажу: «Имя. «

178
00:14:11,640 --> 00:14:21,680
Я просто собираюсь построить объект JSON или объект JavaScript здесь,

179
00:14:21,680 --> 00:14:27,315
который будет автоматически сопоставляться с смежным объектом при его вставке.

180
00:14:27,315 --> 00:14:30,135
И третий параметр, как вы видите,

181
00:14:30,135 --> 00:14:32,790
«сбор документов db и обратный вызов».

182
00:14:32,790 --> 00:14:36,690
Таким образом, третий параметр - это коллекция, а коллекция -

183
00:14:36,690 --> 00:14:42,855
коллекция блюд, а последний - обратный вызов.

184
00:14:42,855 --> 00:14:48,605
Вызов снова, как вы помните, получает результат.

185
00:14:48,605 --> 00:14:52,710
Если оглянуться назад на ребенка реализован документ вставки,

186
00:14:52,710 --> 00:14:55,245
то обратный вызов получил результат в качестве параметра.

187
00:14:55,245 --> 00:15:00,305
Поэтому внутри этого обратного вызова мы будем обрабатывать это значение результата здесь.

188
00:15:00,305 --> 00:15:07,000
Таким образом, когда придет значение результата, мы сделаем console.log.

189
00:15:07,390 --> 00:15:12,750
Мы скажем вставить документ

190
00:15:13,240 --> 00:15:20,565
обратной косой чертой N, и мы скажем результат OPS.

191
00:15:20,565 --> 00:15:24,760
В OPS указывается количество операций вставки, которые были выполнены.

192
00:15:24,760 --> 00:15:28,680
Таким образом, это еще один объект, который будет находиться на

193
00:15:28,680 --> 00:15:31,790
объекте JavaScript результата, который передается обратно

194
00:15:31,790 --> 00:15:34,650
в качестве параметра, и поэтому я просто собираюсь распечатать это значение.

195
00:15:34,650 --> 00:15:38,260
Это даст нам некоторую информацию о том, что произошло.

196
00:15:38,260 --> 00:15:40,610
Теперь, как только это будет завершено,

197
00:15:40,610 --> 00:15:45,880
внутри этой функции обратного вызова я собираюсь вызвать следующую операцию базы данных.

198
00:15:45,880 --> 00:15:50,730
Так что я скажу «dboper», а потом найду документы.

199
00:15:50,730 --> 00:16:00,260
Затем я скажу dbdiss, а третий параметр - docs,

200
00:16:00,260 --> 00:16:03,090
который является функцией обратного вызова.

201
00:16:03,090 --> 00:16:06,100
Когда я получу документы, я собираюсь сделать

202
00:16:06,100 --> 00:16:15,170
console.log, говорящий о найденных документах,

203
00:16:16,170 --> 00:16:22,140
и мы просто заблокируем документы на экране.

204
00:16:22,140 --> 00:16:25,075
Таким образом, это распечатает найденные документы.

205
00:16:25,075 --> 00:16:28,470
Обратите внимание, что этот вызов находится внутри

206
00:16:28,470 --> 00:16:37,480
функции обратного вызова, которая применяется для более раннего вызова функции,

207
00:16:37,480 --> 00:16:41,225
так что это то, что я хочу, чтобы вы заметили конкретно.

208
00:16:41,225 --> 00:16:46,290
Теперь, снова внутри этого вызова функции, они должны сделать это так, потому что до тех пор, пока

209
00:16:46,290 --> 00:16:52,185
этот обратный вызов не будет вызван, мы не можем выполнить следующую операцию.

210
00:16:52,185 --> 00:16:58,855
Итак, в этой следующей операции я собираюсь обновить документ, который я только что вставил.

211
00:16:58,855 --> 00:17:03,990
Поэтому я скажу, что обновите документ, и я скажу Update Document DB,

212
00:17:03,990 --> 00:17:07,880
а затем следующим параметром является документ,

213
00:17:07,880 --> 00:17:11,800
и мне не нужно указывать весь документ, я могу указать только одно поле, а

214
00:17:11,800 --> 00:17:20,740
затем найти документ, который соответствует этому конкретному полю.

215
00:17:21,960 --> 00:17:27,690
То, что я собираюсь сделать, это следующий параметр - это обновление, которое должно быть предоставлено.

216
00:17:27,690 --> 00:17:30,770
Итак, обновление - это то, какое поле я хочу обновить,

217
00:17:30,770 --> 00:17:35,350
поэтому я собираюсь обновить

218
00:17:35,350 --> 00:17:42,050
поле описания, сказав Updated Test,

219
00:17:43,030 --> 00:17:48,475
а затем четвертый - это коллекция, которая является Блюдами,

220
00:17:48,475 --> 00:17:53,820
а последний - функция обратного вызова, которая получает

221
00:17:53,820 --> 00:18:01,110
документы в качестве возвращаемого значения или,

222
00:18:01,110 --> 00:18:08,705
скорее, результата операции обновления, которую мы только что провели.

223
00:18:08,705 --> 00:18:11,890
Затем внутри этой функции обратного вызова

224
00:18:11,890 --> 00:18:20,845
я снова сделаю console.log, говорящий

225
00:18:20,845 --> 00:18:31,050
обновленный документ обратной косой черты N. Обновленный документ будет передан

226
00:18:31,050 --> 00:18:38,125
обратно в result.result в

227
00:18:38,125 --> 00:18:43,115
этом свойстве объекта результата, который передается отслеживание.

228
00:18:43,115 --> 00:18:49,044
Опять же обратите внимание, как вызовы становятся

229
00:18:49,044 --> 00:18:54,585
вложенными внутри функций обратного вызова здесь.

230
00:18:54,585 --> 00:18:57,880
Я хочу, чтобы вы заметили эту структуру

231
00:18:57,880 --> 00:19:03,130
кода, потому что это то, к чему я вернусь в следующем упражнении.

232
00:19:03,130 --> 00:19:05,760
Теперь после того, как

233
00:19:05,760 --> 00:19:07,529
я это сделаю, я собираюсь найти документы,

234
00:19:07,529 --> 00:19:12,930
поэтому позвольте мне просто скопировать это, а затем я собираюсь использовать тот же код здесь.

235
00:19:13,840 --> 00:19:19,530
Так что скажу, найди документы.

236
00:19:20,000 --> 00:19:27,695
Внутри здесь я снова собираюсь сказать, нашел обновленный документ.

237
00:19:27,695 --> 00:19:30,375
Затем, наконец, когда я закончу с этим,

238
00:19:30,375 --> 00:19:35,855
я просто вызову коллекцию db drop.

239
00:19:35,855 --> 00:19:38,760
Поэтому я собираюсь удалить эту коллекцию посуды, чтобы я

240
00:19:38,760 --> 00:19:41,630
очистил свою базу данных, чтобы у меня

241
00:19:41,630 --> 00:19:44,350
больше ничего не было, потому что для следующего упражнения я хочу очистить

242
00:19:44,350 --> 00:19:47,230
базу данных, а затем начать с более чистой базы данных.

243
00:19:47,230 --> 00:19:48,835
Итак, я собираюсь очистить

244
00:19:48,835 --> 00:19:57,770
коллекцию посуды, а затем это приведет к обратному вызову.

245
00:19:59,110 --> 00:20:07,410
Поэтому внутри здесь я собираюсь сделать console.log, сказав,

246
00:20:07,410 --> 00:20:17,000
сбросил коллекцию, а затем я просто распечатаю результат, который пришел.

247
00:20:17,820 --> 00:20:25,250
Затем, наконец, закройте базу данных.

248
00:20:25,650 --> 00:20:28,895
Обратите внимание, что структура кода,

249
00:20:28,895 --> 00:20:34,580
документ вставки БД и внутри функции обратного вызова я собираюсь вызвать

250
00:20:34,580 --> 00:20:37,690
следующую функцию и внутри

251
00:20:37,690 --> 00:20:39,660
обратного вызова, который я собираюсь вызвать

252
00:20:39,660 --> 00:20:42,270
следующую функцию и внутри следующей функции обратного вызова и так далее.

253
00:20:42,270 --> 00:20:46,990
Итак, вы видите вложенный набор обратных вызовов здесь и

254
00:20:46,990 --> 00:20:52,665
дерево структурированный вложенный набор обратных вызовов здесь.

255
00:20:52,665 --> 00:20:56,505
Это то, на что я хочу, чтобы вы обратили внимание.

256
00:20:56,505 --> 00:21:02,680
Давайте сохраним изменения и посмотрим на эту версию нашего приложения.

257
00:21:02,680 --> 00:21:04,725
Возвращаясь к терминалу,

258
00:21:04,725 --> 00:21:08,045
позвольте мне выполнить приложение.

259
00:21:08,045 --> 00:21:13,035
Поэтому позвольте мне ввести NPM начало, и мы увидим этот результат.

260
00:21:13,035 --> 00:21:19,060
Теперь из этого результата вы можете увидеть, что документ

261
00:21:19,060 --> 00:21:25,330
вставляется в коллекцию, и это документ, который был найден.

262
00:21:25,330 --> 00:21:26,990
На втором этапе

263
00:21:26,990 --> 00:21:31,540
мы находим документ, поэтому, когда мы вызываем документ поиска БД,

264
00:21:31,540 --> 00:21:36,175
так что это документ, который извлекается из моей коллекции.

265
00:21:36,175 --> 00:21:39,010
Затем я прошу его обновить документ с

266
00:21:39,010 --> 00:21:42,915
этим, а затем вы заметите, что он говорит обновленный документ, а затем

267
00:21:42,915 --> 00:21:46,850
здесь он печатает результат или OPS, и он говорит, что N равен

268
00:21:46,850 --> 00:21:51,775
одному числу, измененному как один, и это было в порядке.

269
00:21:51,775 --> 00:21:57,010
Затем он распечатывает обновленный документ,

270
00:21:57,010 --> 00:22:02,020
мы находим обновленный документ здесь, и это то, что печатается здесь,

271
00:22:02,020 --> 00:22:05,770
и обратите внимание, в частности, что описание было обновлено.

272
00:22:05,770 --> 00:22:09,390
Затем, наконец, он уронил коллекцию.

273
00:22:09,990 --> 00:22:16,690
Таким образом, мы видим, как это приложение работает и может использовать

274
00:22:16,690 --> 00:22:23,410
модуль узла, который мы реализовали, а затем выполняли различные операции базы данных.

275
00:22:23,410 --> 00:22:26,560
Этим мы завершаем это упражнение.

276
00:22:26,560 --> 00:22:31,520
В этом упражнении я продемонстрировал вам, как вы будете взаимодействовать с

277
00:22:31,520 --> 00:22:37,085
вашим сервером MongoDB из вашего приложения узла.

278
00:22:37,085 --> 00:22:43,455
Мы реализовали наш собственный модуль узла здесь, а затем использовали его

279
00:22:43,455 --> 00:22:46,810
в нашем приложении узла, инкапсулируя

280
00:22:46,810 --> 00:22:50,965
некоторые операции базы данных в этот модуль узла.

281
00:22:50,965 --> 00:22:54,020
Это хорошее время для вас, чтобы сделать фиксацию Git с

282
00:22:54,020 --> 00:22:58,860
узлом сообщения MongoDB пример части второй.