1
00:00:03,680 --> 00:00:06,035
В предыдущем уроке

2
00:00:06,035 --> 00:00:08,550
мы узнали о драйвере MongoDB.

3
00:00:08,550 --> 00:00:14,250
Это позволяет нашему узловому приложению взаимодействовать с сервером MongoDB,

4
00:00:14,250 --> 00:00:19,660
а также хранить и извлекать документы с сервера MongoDB.

5
00:00:19,660 --> 00:00:23,310
Мы также видели, что драйвер MongoDB предоставляет нам

6
00:00:23,310 --> 00:00:28,770
много методов, которые позволяют нам создавать коллекции в базе данных,

7
00:00:28,770 --> 00:00:30,925
добавлять документы в коллекции,

8
00:00:30,925 --> 00:00:35,695
а затем выполнять различные операции над документами в коллекции.

9
00:00:35,695 --> 00:00:41,060
Теперь, когда документы хранятся в базе данных,

10
00:00:41,060 --> 00:00:46,330
драйвер MongoDB сам не накладывает структуры на документы.

11
00:00:46,330 --> 00:00:52,640
Если нам нужно иметь конкретную структуру для документов и применять эту структуру,

12
00:00:52,640 --> 00:00:58,505
то нам нужно использовать модуль узла Mongoose, который позволяет нам определить

13
00:00:58,505 --> 00:01:05,015
схему и структуру для наших документов, которые хранятся в нашей базе данных MongoDB,

14
00:01:05,015 --> 00:01:08,275
и строго применяет структуру.

15
00:01:08,275 --> 00:01:16,035
Давайте рассмотрим более подробную информацию в этой лекции и упражнения, которые следуют за этой лекцией.

16
00:01:16,035 --> 00:01:18,540
Как мы уже узнали,

17
00:01:18,540 --> 00:01:25,035
MongoDB хранит данные в коллекциях в базе данных.

18
00:01:25,035 --> 00:01:28,695
Эти коллекции состоят из коллекции документов.

19
00:01:28,695 --> 00:01:30,750
Сами документы, хранящиеся в

20
00:01:30,750 --> 00:01:35,405
базе данных MongoDB, не имеют конкретной структуры, наложенной на документ.

21
00:01:35,405 --> 00:01:38,570
Любой документ может быть сохранен в любой коллекции.

22
00:01:38,570 --> 00:01:46,370
MongoDB полагается на разработчика для обеспечения структуры на документах

23
00:01:46,370 --> 00:01:52,295
и дает полную ответственность разработчику, чтобы убедиться, что документы

24
00:01:52,295 --> 00:01:58,670
правильной структуры добавляются и поддерживаются в различных коллекциях.

25
00:01:58,670 --> 00:02:01,960
Теперь это очень легко нарушить.

26
00:02:01,960 --> 00:02:06,260
Например, даже если вы можете начать с предположения

27
00:02:06,260 --> 00:02:11,030
, что конкретное соединение будет иметь документы определенной структуры,

28
00:02:11,030 --> 00:02:17,045
вы можете легко вставить документы, которые не обязательно соответствуют структуре.

29
00:02:17,045 --> 00:02:21,170
Если вы очень уверены, что структура документов в

30
00:02:21,170 --> 00:02:25,550
коллекции всегда имеет указанную структуру,

31
00:02:25,550 --> 00:02:28,550
и всегда будет иметь конкретный набор полей,

32
00:02:28,550 --> 00:02:32,540
то сам MongoDB не навязывает, что ни

33
00:02:32,540 --> 00:02:36,630
драйвер узла MongoDB, который мы видели в предыдущем уроке.

34
00:02:36,630 --> 00:02:40,565
Здесь нам понадобится более формальный способ наложения

35
00:02:40,565 --> 00:02:46,385
структуры на документы, которые хранятся в коллекции в базе данных MongoDB.

36
00:02:46,385 --> 00:02:52,390
Вот где модуль узла Mongoose приходит к нам на помощь.

37
00:02:52,390 --> 00:02:56,405
Модуль узла Mongoose накладывает

38
00:02:56,405 --> 00:03:01,875
стандартизованную структуру для документов, которые хранятся в определенной коллекции.

39
00:03:01,875 --> 00:03:07,175
Поэтому мы часто слышим, как люди называют это Mongoose ODM.

40
00:03:07,175 --> 00:03:10,950
Сама ODM интерпретируется некоторыми людьми

41
00:03:10,950 --> 00:03:16,995
как означающая модель объектных данных или иногда называется сопоставлением объектных документов,

42
00:03:16,995 --> 00:03:22,125
или некоторые люди ссылаются на нее как ORM или объектно-реляционное сопоставление.

43
00:03:22,125 --> 00:03:27,755
Теперь, когда мы говорим о реляционных, которые применяются гораздо больше к реляционным базам данных,

44
00:03:27,755 --> 00:03:33,380
но затем с базами данных SQL нам нужно явно объект

45
00:03:33,380 --> 00:03:41,850
реляционного сопоставления, который должен быть помещен между базой данных и самим нашим приложением.

46
00:03:41,850 --> 00:03:45,245
Потому что в приложении мы будем смотреть на

47
00:03:45,245 --> 00:03:50,245
объекты, но их хранение в базе данных SQL будет в виде записей,

48
00:03:50,245 --> 00:03:52,585
и поэтому вам нужно явное сопоставление.

49
00:03:52,585 --> 00:03:54,870
Как мы видели с базой данных NoSQL,

50
00:03:54,870 --> 00:03:56,685
это явно не требовалось.

51
00:03:56,685 --> 00:04:03,710
Но если вам нужно наложить структуру на ваши документы, которые хранятся в коллекции,

52
00:04:03,710 --> 00:04:10,790
то использование Mongoose для навязывания этой структуры очень, очень полезно.

53
00:04:10,790 --> 00:04:13,880
То, как Mongoose обходит

54
00:04:13,880 --> 00:04:18,275
навязывание структуры на документы, - это использование схемы.

55
00:04:18,275 --> 00:04:21,995
Схема, определяет структуру их документов.

56
00:04:21,995 --> 00:04:24,800
Давайте поговорим об этом чуть более подробно.

57
00:04:24,800 --> 00:04:27,580
Итак, что именно такое схема мангуста,

58
00:04:27,580 --> 00:04:29,700
и что она приносит в таблицу?

59
00:04:29,700 --> 00:04:34,700
Схема Mongoose, подразумевает структуру

60
00:04:34,700 --> 00:04:39,735
на данных, которые хранятся в документе в вашей базе данных.

61
00:04:39,735 --> 00:04:42,770
Таким образом, он определяет все поля вашего документа,

62
00:04:42,770 --> 00:04:45,349
а также определяет типы полей,

63
00:04:45,349 --> 00:04:47,345
а также может предоставить нам

64
00:04:47,345 --> 00:04:51,965
дополнительные функции, которые могут включить проверку на этих полях.

65
00:04:51,965 --> 00:04:59,425
Так, например, различные типы схем, которые поддерживаются в Mongoose включают: String,

66
00:04:59,425 --> 00:05:03,195
Number, Date, Buffer, Boolean,

67
00:05:03,195 --> 00:05:06,295
Mixed, Object ID и Array.

68
00:05:06,295 --> 00:05:09,070
В частности, мы рассмотрим номер строки,

69
00:05:09,070 --> 00:05:14,405
и дату, и логическое в упражнении, которое следует.

70
00:05:14,405 --> 00:05:18,075
Мы рассмотрим некоторые из других в последующих упражнениях.

71
00:05:18,075 --> 00:05:22,125
В частности, обратите внимание на использование типа схемы массива.

72
00:05:22,125 --> 00:05:25,570
Таким образом, тип схемы массива позволит вам

73
00:05:25,570 --> 00:05:31,640
создать массив вложенных документов внутри документа.

74
00:05:31,640 --> 00:05:33,740
Я поговорю об этом через некоторое время.

75
00:05:33,740 --> 00:05:36,940
После определения схемы, схема

76
00:05:36,960 --> 00:05:42,160
затем используется в Mongoose для создания функции модели,

77
00:05:42,160 --> 00:05:49,830
и это то, что позволяет вам определить структуру для ваших документов в базе данных.

78
00:05:49,830 --> 00:05:53,225
Сами схемы могут иметь вложенность.

79
00:05:53,225 --> 00:05:58,490
Таким образом, это означает, что вы можете иметь вложенный документ, который заключен внутри документа.

80
00:05:58,490 --> 00:06:01,519
Поддокументы, как правило, удовлетворяются

81
00:06:01,519 --> 00:06:04,890
либо путем указания дополнительной схемы,

82
00:06:04,890 --> 00:06:11,870
а затем определения одного из полей схемы, чтобы быть вне типа другой схемы.

83
00:06:11,870 --> 00:06:15,215
Или вы даже можете пойти с массивом

84
00:06:15,215 --> 00:06:20,000
другого типа схемы во второй схеме, которую вы определяете.

85
00:06:20,000 --> 00:06:24,930
Давайте посмотрим на пример, чтобы прояснить некоторые из них более подробно.

86
00:06:24,930 --> 00:06:32,010
Этот пример будет из упражнения, которое вы будете делать сразу после этой лекции.

87
00:06:32,010 --> 00:06:37,705
Прежде чем я смогу поговорить о схемах и моделях в Mongoose,

88
00:06:37,705 --> 00:06:41,310
давайте поймем, почему это нужно.

89
00:06:41,310 --> 00:06:43,975
Если вы взяли предыдущий угловой,

90
00:06:43,975 --> 00:06:46,760
ионный, или родной сценарий курса,

91
00:06:46,760 --> 00:06:49,445
вы видели, что мы представляем

92
00:06:49,445 --> 00:06:55,565
различные данные, которые мы используем в наших приложениях в виде строк JSON.

93
00:06:55,565 --> 00:07:02,050
Итак, в нашем приложении мы определяем коллекцию, называемую блюдами.

94
00:07:02,050 --> 00:07:03,770
В коллекции блюд,

95
00:07:03,770 --> 00:07:09,700
каждое блюдо будет содержать определенный набор свойств, определенных в виде строки JSON,

96
00:07:09,700 --> 00:07:11,665
как вы видите в этом примере.

97
00:07:11,665 --> 00:07:15,830
Таким образом, блюда представляют собой массив типа блюда,

98
00:07:15,830 --> 00:07:18,605
и каждое блюдо само будет содержать имя,

99
00:07:18,605 --> 00:07:20,290
изображение, категорию

100
00:07:20,290 --> 00:07:22,015
, этикетку и так далее.

101
00:07:22,015 --> 00:07:26,360
Кроме того, внутри самого документа блюда

102
00:07:26,360 --> 00:07:32,830
у вас будут комментарии, которые хранятся как массив снова, -

103
00:07:32,830 --> 00:07:38,240
документы JSON, которые содержат определенные поля шаг.

104
00:07:38,240 --> 00:07:39,750
Таким образом, каждый комментарий, например,

105
00:07:39,750 --> 00:07:45,685
содержит автора комментария рейтинга и поле даты, как вы видите в этом примере.

106
00:07:45,685 --> 00:07:49,215
Таким образом, вы видите, что есть четкая структура для

107
00:07:49,215 --> 00:07:55,230
каждого документа, который определяет блюдо, которое хранится в нашей базе данных.

108
00:07:55,230 --> 00:08:02,545
Несколько блюд, очевидно, будут храниться в виде коллекции в нашей базе данных,

109
00:08:02,545 --> 00:08:06,655
и могут быть сгруппированы вместе и отправлены в виде массива

110
00:08:06,655 --> 00:08:11,165
блюд для нашего клиентского приложения, которое будет использоваться.

111
00:08:11,165 --> 00:08:14,890
Теперь, когда мы поняли, как это определено, теперь,

112
00:08:14,890 --> 00:08:22,000
как это относится к схеме Мангуста и модели, которую мы определяем в Мангусте?

113
00:08:22,000 --> 00:08:27,460
Теперь обратите внимание на структуру типичного документа блюда здесь.

114
00:08:27,460 --> 00:08:34,095
Таким образом, это можно легко отобразить в документе MongoDB в коллекции,

115
00:08:34,095 --> 00:08:37,375
возможно, названном коллекцией блюд.

116
00:08:37,375 --> 00:08:42,605
Таким образом, мы видим, что в самом документе есть четкая структура.

117
00:08:42,605 --> 00:08:50,320
Теперь, как мы зеркалируем это в схеме в нашем приложении Mongoose?

118
00:08:50,320 --> 00:08:54,095
Как вы узнаете в упражнении,

119
00:08:54,095 --> 00:08:57,900
мы увидим, что мы будем определять схемы в Mongoose.

120
00:08:57,900 --> 00:09:03,085
Таким образом, схема определяется как схема Mongoose здесь.

121
00:09:03,085 --> 00:09:08,055
В качестве примера здесь показана схема комментария.

122
00:09:08,055 --> 00:09:09,925
CommentSchema, как вы можете видеть,

123
00:09:09,925 --> 00:09:13,885
содержит три различных поля: рейтинг, комментарий

124
00:09:13,885 --> 00:09:15,445
и поле автора,

125
00:09:15,445 --> 00:09:18,745
а также метки времени здесь.

126
00:09:18,745 --> 00:09:23,560
Отметки времени позволяют иметь два различных поля в

127
00:09:23,560 --> 00:09:28,850
документе: созданные в поле и обновленные в поле,

128
00:09:28,850 --> 00:09:38,200
оба из которых являются временными метками, хранящимися в виде строки даты ISO в документе.

129
00:09:38,200 --> 00:09:43,615
Теперь сам рейтинг будет целочисленным значением.

130
00:09:43,615 --> 00:09:46,400
Таким образом, в терминологии Mongoose,

131
00:09:46,400 --> 00:09:48,755
он будет храниться как число,

132
00:09:48,755 --> 00:09:50,680
тип будет числом.

133
00:09:50,680 --> 00:09:53,660
Можно даже указать минимальное и максимальное значения.

134
00:09:53,660 --> 00:09:57,190
Вы также можете указать, что это конкретное поле является обязательным, а

135
00:09:57,190 --> 00:10:04,460
это означает, что каждый документ типа комментария должен содержать поле оценки.

136
00:10:04,460 --> 00:10:07,370
Аналогично, вы также можете определить поле комментария,

137
00:10:07,370 --> 00:10:08,710
которое имеет тип строки.

138
00:10:08,710 --> 00:10:13,635
Таким образом, очевидно, комментарий - это не что иное, как строка, содержащая некоторую информацию,

139
00:10:13,635 --> 00:10:16,340
и это также может быть определено как обязательное поле,

140
00:10:16,340 --> 00:10:18,805
что означает, что каждый документ должен содержать комментарий,

141
00:10:18,805 --> 00:10:21,060
а также поле автора,

142
00:10:21,060 --> 00:10:22,800
которое также имеет строку типа.

143
00:10:22,800 --> 00:10:28,030
Таким образом, вы видите это, определяя эту схему в этом формате.

144
00:10:28,030 --> 00:10:32,600
Как мы узнали в обсуждении немного ранее,

145
00:10:32,600 --> 00:10:41,890
схема определяется с помощью различных типов, которые мы имеем в нашем приложении Mongoose.

146
00:10:41,890 --> 00:10:43,030
Итак, в схеме, опять же,

147
00:10:43,030 --> 00:10:44,900
вы видите здесь три разных поля:

148
00:10:44,900 --> 00:10:47,135
рейтинг, комментарий и автор,

149
00:10:47,135 --> 00:10:50,665
и каждое из которых имеет определенный тип,

150
00:10:50,665 --> 00:10:53,060
и тогда является ли это обязательным или нет.

151
00:10:53,060 --> 00:10:56,505
Таким образом, вы навязываете строгую структуру

152
00:10:56,505 --> 00:11:01,320
документов комментариев, которые будут храниться в вашем приложении.

153
00:11:01,320 --> 00:11:05,255
Теперь, когда мы определили схему комментария, мы можем тогда,

154
00:11:05,255 --> 00:11:12,254
как вы заметили из примера типа данных, которые мы требуем в нашем приложении,

155
00:11:12,254 --> 00:11:15,000
у нас есть сам документ блюдо.

156
00:11:15,000 --> 00:11:17,620
Документ блюдо содержит различные поля.

157
00:11:17,620 --> 00:11:19,050
Здесь, в упражнении,

158
00:11:19,050 --> 00:11:23,355
мы вначале введем только два поля в документ блюдо

159
00:11:23,355 --> 00:11:25,370
, название и описание.

160
00:11:25,370 --> 00:11:27,010
В следующем уроке

161
00:11:27,010 --> 00:11:32,330
мы представим оставшиеся поля для DishSchema.

162
00:11:32,330 --> 00:11:33,680
Теперь, так имя,

163
00:11:33,680 --> 00:11:35,440
как и в этом случае,

164
00:11:35,440 --> 00:11:36,765
имеет строку типа.

165
00:11:36,765 --> 00:11:39,450
Мы также можем указать, что это обязательное поле,

166
00:11:39,450 --> 00:11:43,360
что означает, что каждый документ должен содержать поле имени.

167
00:11:43,360 --> 00:11:46,385
Мы также можем указать, что поле name является уникальным,

168
00:11:46,385 --> 00:11:53,215
что означает, что ни один документ не может иметь точно такое же значение имени в документе.

169
00:11:53,215 --> 00:11:55,980
Таким образом, это гарантирует, что каждый документ будет иметь

170
00:11:55,980 --> 00:12:01,300
уникальное поле имени в нем и поле описания,

171
00:12:01,300 --> 00:12:03,115
которое снова является строкой типа,

172
00:12:03,115 --> 00:12:06,460
но также указано по мере необходимости.

173
00:12:06,460 --> 00:12:10,010
Теперь, как мы видели в примере,

174
00:12:10,010 --> 00:12:15,750
документ блюдо содержит несколько комментариев, вложенных внутри документа.

175
00:12:15,750 --> 00:12:20,920
Теперь, в Mongoose, это поддерживается путем использования поддокументов.

176
00:12:20,920 --> 00:12:24,230
Таким образом, если вы определяете схему ранее,

177
00:12:24,230 --> 00:12:27,345
например, мы уже определили CommentSchema здесь,

178
00:12:27,345 --> 00:12:33,370
вы также можете определить поле в другой схеме, которую вы определяете, а

179
00:12:33,370 --> 00:12:36,240
затем указать, что это поле будет

180
00:12:36,240 --> 00:12:39,520
иметь тип предыдущей схемы, которую вы определили.

181
00:12:39,520 --> 00:12:40,960
Итак, в этом случае

182
00:12:40,960 --> 00:12:44,360
поле комментариев я определяю его как массив,

183
00:12:44,360 --> 00:12:51,545
поэтому вы видите использование типа массива в вашей схеме, которую вы определяете здесь,

184
00:12:51,545 --> 00:12:55,110
а затем массив типа CommentSchema.

185
00:12:55,110 --> 00:13:00,725
Таким образом, это массив комментариев, которые будут включены в каждый документ блюдо.

186
00:13:00,725 --> 00:13:02,590
Таким образом, вы можете иметь

187
00:13:02,590 --> 00:13:11,640
более чем один вложенный документ комментария, заключенный внутри документа блюдо.

188
00:13:11,640 --> 00:13:16,080
Таким образом, определение структуры, как это позволяет нам поддерживать

189
00:13:16,080 --> 00:13:20,950
соответствующую структуру строки JSON, которую мы определили

190
00:13:20,950 --> 00:13:26,470
для документа блюда или что мы видели в примере ранее.

191
00:13:26,470 --> 00:13:30,145
Теперь, как только мы определим схему,

192
00:13:30,145 --> 00:13:33,695
чтобы использовать это в нашем приложении,

193
00:13:33,695 --> 00:13:38,600
нам нужно создать модель из этой схемы, которую мы только что определили.

194
00:13:38,600 --> 00:13:40,640
Таким образом, в нашем приложении,

195
00:13:40,640 --> 00:13:45,320
мы определим модель Mongoose и укажите,

196
00:13:45,320 --> 00:13:51,085
что модель вне типа DishSchema в этом примере.

197
00:13:51,085 --> 00:13:54,830
Мало того, что вы также дадите название модели здесь.

198
00:13:54,830 --> 00:13:57,100
Итак, когда вы даете имя модели здесь,

199
00:13:57,100 --> 00:14:00,000
мы указываем имя как блюдо.

200
00:14:00,000 --> 00:14:03,860
Теперь, когда вы используете эту модель блюда в

201
00:14:03,860 --> 00:14:07,870
нашем приложении узла, где мы используем Mongoose,

202
00:14:07,870 --> 00:14:15,280
то это будет преобразовано и отображено в коллекцию в моей базе данных MongoDB.

203
00:14:15,280 --> 00:14:18,885
Сама коллекция будет называться блюдами.

204
00:14:18,885 --> 00:14:23,355
Таким образом, Mongoose автоматически знает, что когда вы укажете имя здесь,

205
00:14:23,355 --> 00:14:27,990
он автоматически создаст

206
00:14:27,990 --> 00:14:31,635
множественное число этого имени, а затем даст коллекции имя,

207
00:14:31,635 --> 00:14:37,160
которое является множественным числом имени модели, которое вы указываете в этом примере.

208
00:14:37,160 --> 00:14:39,400
Итак, когда я говорю блюдо здесь,

209
00:14:39,400 --> 00:14:42,620
то Mongoose автоматически сопоставит это

210
00:14:42,620 --> 00:14:46,365
в коллекцию блюд в базе данных MongoDB.

211
00:14:46,365 --> 00:14:53,385
Как он знает, как преобразовать это единственное имя во множественное число?

212
00:14:53,385 --> 00:14:56,750
Mongoose автоматически имеет встроенный механизм, который

213
00:14:56,750 --> 00:15:01,795
позволяет ему построить множество стандартных английских слов.

214
00:15:01,795 --> 00:15:02,965
Так что, если вы скажете блюдо,

215
00:15:02,965 --> 00:15:04,170
он будет строить блюда.

216
00:15:04,170 --> 00:15:08,880
Если вы говорите лидер, он построит множественное число его как лидеров и так далее.

217
00:15:08,880 --> 00:15:13,250
Таким образом, это уже встроено в модуль узла Mongoose.

218
00:15:13,250 --> 00:15:17,585
Поэтому, когда я указываю это как тип модели блюда,

219
00:15:17,585 --> 00:15:24,050
то Mongoose построит коллекцию блюд в моей базе данных MongoDB,

220
00:15:24,050 --> 00:15:27,155
а затем эта коллекция блюд будет хранить

221
00:15:27,155 --> 00:15:33,050
различные документы типа блюда там.

222
00:15:33,050 --> 00:15:35,780
После того, как мы создали, что, как правило,

223
00:15:35,780 --> 00:15:38,150
когда мы объявляем модели в нашем приложении,

224
00:15:38,150 --> 00:15:43,780
мы будем хранить их в подпапке с именем модели, просто для удобства.

225
00:15:43,780 --> 00:15:44,900
Вам не нужно это делать,

226
00:15:44,900 --> 00:15:47,320
но просто для того, чтобы организовать ваше приложение,

227
00:15:47,320 --> 00:15:50,635
мы обычно храним его в папке с именем models.

228
00:15:50,635 --> 00:15:55,010
Затем схема и модель будут

229
00:15:55,010 --> 00:15:59,470
определены в файле, подобном этому, как вы видите в примере здесь,

230
00:15:59,470 --> 00:16:05,230
это называется dishes.js, а затем это будет экспортировано, потому что это модуль узла.

231
00:16:05,230 --> 00:16:10,970
Это будет экспортировано из этого файла, так что он может быть включен в приложение узла,

232
00:16:10,970 --> 00:16:13,100
где мы собираемся использовать

233
00:16:13,100 --> 00:16:16,620
эту схему и модель, которую мы только что определили здесь.

234
00:16:16,620 --> 00:16:20,540
С этим быстрым пониманием схемы и модели и

235
00:16:20,540 --> 00:16:26,370
ее использования в определении структуры для документа, который мы храним в MongoDB,

236
00:16:26,370 --> 00:16:33,510
давайте вернемся и поймем немного больше о том, что Mongoose предоставляет для нас.

237
00:16:33,510 --> 00:16:39,965
Кроме того, Mongoose позволяет установить соединение с сервером MongoDB.

238
00:16:39,965 --> 00:16:43,070
Mongoose внутренне использовать

239
00:16:43,070 --> 00:16:46,495
драйвер MongoDB, который мы использовали в предыдущем упражнении.

240
00:16:46,495 --> 00:16:49,745
Таким образом, Mongoose зависит от драйвера MongoDB, поэтому,

241
00:16:49,745 --> 00:16:53,824
что означает, что из вашего приложения на основе Mongoose

242
00:16:53,824 --> 00:16:56,960
вы можете использовать все методы, которые уже

243
00:16:56,960 --> 00:17:01,040
доступны из драйвера MongoDB, также если вы решите,

244
00:17:01,040 --> 00:17:05,390
но сам Mongoose имеет свою собственную коллекцию методов, которые мы

245
00:17:05,390 --> 00:17:09,940
можем сделать использование для взаимодействия с базой данных MongoDB,

246
00:17:09,940 --> 00:17:13,645
как мы увидим в упражнении, которое следует.

247
00:17:13,645 --> 00:17:19,040
Позвольте мне кратко показать вам, как мы

248
00:17:19,040 --> 00:17:21,590
установим соединение с базой данных, и вы сделаете это в следующем упражнении.

249
00:17:21,590 --> 00:17:25,280
Таким образом, так же, как мы объявили URL в случае

250
00:17:25,280 --> 00:17:29,160
приложения узла MongoDB в предыдущем уроке,

251
00:17:29,160 --> 00:17:32,630
мы все равно объявим URL для нашего приложения.

252
00:17:32,630 --> 00:17:36,965
Затем мы будем использовать метод Mongoose connect

253
00:17:36,965 --> 00:17:40,180
и поставим URL для метода Mongoose connect,

254
00:17:40,180 --> 00:17:44,000
и это установит соединение с базой данных.

255
00:17:44,000 --> 00:17:48,590
С этим быстрым пониманием Mongoose и какую роль Mongoose

256
00:17:48,590 --> 00:17:53,485
играет в поддержке структурированной вставки

257
00:17:53,485 --> 00:17:58,985
, хранения и извлечения документов из нашего Mongoob,

258
00:17:58,985 --> 00:18:02,180
давайте перейдем к упражнению, где мы

259
00:18:02,180 --> 00:18:07,920
получим практический опыт с использованием модуля Mongoose.