1
00:00:03,950 --> 00:00:09,370
Neste exercício, vamos continuar com o exercício anterior onde

2
00:00:09,370 --> 00:00:14,650
desenvolvemos a interação entre o aplicativo nó e o servidor MongoDB.

3
00:00:14,650 --> 00:00:18,120
Neste exercício, vou encapsular algumas

4
00:00:18,120 --> 00:00:21,750
das operações de banco de dados em um módulo de nó próprio,

5
00:00:21,750 --> 00:00:23,540
um módulo de nó baseado em arquivo

6
00:00:23,540 --> 00:00:29,345
e, em seguida, fazer uso dele dentro do meu aplicativo de nó para interagir com o servidor.

7
00:00:29,345 --> 00:00:31,940
Ao mesmo tempo, realizaremos várias operações

8
00:00:31,940 --> 00:00:35,630
no servidor para demonstrar que seremos capazes de

9
00:00:35,630 --> 00:00:43,040
interagir com o servidor usando nosso aplicativo de nó e o driver MongoDB nó.

10
00:00:43,040 --> 00:00:47,605
Para começar, vamos para o nosso projeto

11
00:00:47,605 --> 00:00:53,975
e, em seguida, criar um novo arquivo chamado operations.js.

12
00:00:53,975 --> 00:00:57,720
Este arquivo irá encapsular todas as operações de banco de dados,

13
00:00:57,720 --> 00:01:00,705
as quatro operações que eu vou executar inserir,

14
00:01:00,705 --> 00:01:05,855
localizar, remover e atualizar um documento no meu banco de dados.

15
00:01:05,855 --> 00:01:09,980
Agora, isso será organizado como um módulo de nó baseado em arquivo,

16
00:01:09,980 --> 00:01:15,070
que então eu vou fazer uso dele no meu aplicativo nó para acessar o servidor.

17
00:01:15,070 --> 00:01:16,330
Então, para começar,

18
00:01:16,330 --> 00:01:25,780
deixe-me primeiro exigir assert,

19
00:01:25,780 --> 00:01:27,565
neste módulo de nó,

20
00:01:27,565 --> 00:01:30,225
e como isso acontece a ser um módulo de nó,

21
00:01:30,225 --> 00:01:35,055
estaremos exportando vários métodos do módulo de nó.

22
00:01:35,055 --> 00:01:41,705
O primeiro método seria inserir documento obviamente como você esperaria,

23
00:01:41,705 --> 00:01:44,520
e isso levará quatro parâmetros DB,

24
00:01:44,520 --> 00:01:49,555
o MongoDB, conexão de banco de dados dentro do meu aplicativo nó,

25
00:01:49,555 --> 00:01:54,240
que eu obterei dentro do aplicativo nó.

26
00:01:54,240 --> 00:01:57,785
Em seguida, o segundo é o documento que eu quero inserir.

27
00:01:57,785 --> 00:02:02,800
O terceiro parâmetro é a coleção na qual eu quero inserir o documento.

28
00:02:02,800 --> 00:02:05,675
A última é uma função de retorno de chamada,

29
00:02:05,675 --> 00:02:10,425
que será chamada de volta assim que a operação for concluída.

30
00:02:10,425 --> 00:02:14,800
Então vamos fechar a função aqui,

31
00:02:14,800 --> 00:02:20,100
e isso essencialmente encapsula o método de inserção de documento aqui.

32
00:02:20,100 --> 00:02:27,415
Então, esta é uma função que é exportada por este módulo nó aqui.

33
00:02:27,415 --> 00:02:34,250
Agora, eu também vou incorporar mais alguns métodos aqui.

34
00:02:34,250 --> 00:02:42,870
O segundo seria encontrar documentos.

35
00:02:42,870 --> 00:02:46,025
Não apenas um, mas vários documentos.

36
00:02:46,025 --> 00:02:54,390
Isto eu iria procurar a coleção e encontrar todos os documentos que estão na coleção.

37
00:02:54,390 --> 00:02:58,130
Então, é por isso que eu só estou tomando o banco de dados

38
00:02:58,130 --> 00:03:02,090
e a coleção como os dois parâmetros junto com o retorno de chamada.

39
00:03:02,090 --> 00:03:11,550
A terceira função que vou implementar uma exportação daqui é o removedocument.

40
00:03:12,290 --> 00:03:15,590
Isso suporta a operação de exclusão,

41
00:03:15,590 --> 00:03:19,855
e assim o nome do documento levará o banco de dados,

42
00:03:19,855 --> 00:03:23,775
o documento, a coleção e o retorno de chamada como os quatro parâmetros,

43
00:03:23,775 --> 00:03:30,595
e vamos chamar o retorno de chamada quando a operação for concluída.

44
00:03:30,595 --> 00:03:34,445
O último é, naturalmente, actualizar o documento.

45
00:03:34,445 --> 00:03:38,120
Agora, é claro, você não precisa necessariamente fazer isso dessa maneira.

46
00:03:38,120 --> 00:03:42,830
Eu só senti que esta seria outra maneira de ilustrar como você pode

47
00:03:42,830 --> 00:03:49,110
encapsular essas funções em seu próprio módulo de nó.

48
00:03:49,110 --> 00:03:55,395
Isso é apenas reorganizar o código de uma forma que é mais fácil de usar.

49
00:03:55,395 --> 00:03:57,205
Assim, para as exportações,

50
00:03:57,205 --> 00:04:00,070
para o documento de atualização leva o DB,

51
00:04:00,070 --> 00:04:03,750
alguma forma de identificar o documento como um segundo parâmetro.

52
00:04:03,750 --> 00:04:06,205
O terceiro parâmetro é a atualização,

53
00:04:06,205 --> 00:04:08,750
e o quarto parâmetro é a coleção na qual

54
00:04:08,750 --> 00:04:11,505
este documento existe e o retorno de chamada.

55
00:04:11,505 --> 00:04:18,160
Então, quatro funções a serem exportadas pelo arquivo operations.js.

56
00:04:18,160 --> 00:04:20,380
Agora, dentro dessas funções,

57
00:04:20,380 --> 00:04:21,735
vamos implementar um por um.

58
00:04:21,735 --> 00:04:23,420
No documento inserir,

59
00:04:23,420 --> 00:04:27,680
a primeira coisa que eu vou fazer é dizer

60
00:04:27,680 --> 00:04:36,000
coleção const e ele vai dizer coleção DB,

61
00:04:38,930 --> 00:04:44,710
eo parâmetro é a coleção.

62
00:04:45,350 --> 00:04:50,190
Então, vamos procurar a coleção lá.

63
00:04:50,190 --> 00:04:54,640
Agora, isso tem que ser realizado em todos os quatro métodos.

64
00:04:54,640 --> 00:04:59,990
Então, eu vou ir e colar este código em todos os quatro métodos aqui,

65
00:05:01,140 --> 00:05:05,390
porque essa é uma função que eu preciso em todos eles.

66
00:05:05,390 --> 00:05:07,820
Então, assim que eu conseguir a coleção,

67
00:05:07,820 --> 00:05:11,680
então como você se lembra do exercício anterior,

68
00:05:11,680 --> 00:05:13,895
eu posso realizar operações na coleção.

69
00:05:13,895 --> 00:05:19,160
Então, eu vou dizer coleção, inserir,

70
00:05:21,300 --> 00:05:27,610
e isso leva como o primeiro parâmetro o documento a ser inserido,

71
00:05:27,610 --> 00:05:35,695
e o segundo parâmetro é o retorno de chamada com o erro e esse resultado.

72
00:05:35,695 --> 00:05:40,990
Então, agora quando este documento

73
00:05:40,990 --> 00:05:46,780
é inserido chamando o método de inserção na coleção de banco de dados,

74
00:05:46,780 --> 00:05:49,180
o método de inserção deixe-me lembrá-lo,

75
00:05:49,180 --> 00:05:52,090
é suportado pelo driver MongoDB.

76
00:05:52,090 --> 00:05:53,980
Então, esse é o método que estamos usando aqui,

77
00:05:53,980 --> 00:05:56,420
ou essa é a função que estamos usando aqui.

78
00:05:56,420 --> 00:06:05,060
Agora, a primeira coisa que eu vou verificar para isso, assertequal err, nulo.

79
00:06:05,060 --> 00:06:09,185
Então, eu quero ter certeza de que eu não tenho um erro.

80
00:06:09,185 --> 00:06:11,225
Então eu quero ter certeza de que o erro é nulo.

81
00:06:11,225 --> 00:06:12,470
Se não for nulo,

82
00:06:12,470 --> 00:06:15,930
isso irá imprimir as informações e, em seguida, sair do aplicativo.

83
00:06:15,930 --> 00:06:19,760
Neste momento, eu sinto que isso é bom para lidar com isso que mais tarde,

84
00:06:19,760 --> 00:06:24,680
vamos ver como podemos ter uma maneira global de lidar com todos os erros quando

85
00:06:24,680 --> 00:06:34,390
implementamos na próxima lição outra maneira de acessar o banco de dados MongoDB.

86
00:06:34,390 --> 00:06:36,640
Agora, depois que eu fizer isso,

87
00:06:36,640 --> 00:06:38,050
eu vou implementar,

88
00:06:38,050 --> 00:06:40,075
eu vou simplesmente registrar essa informação.

89
00:06:40,075 --> 00:06:48,570
Então eu vou dizer, log do console e inseri-lo.

90
00:06:48,570 --> 00:06:55,375
Então, esta informação será impressa na tela aqui, inserida.

91
00:06:55,375 --> 00:07:00,440
Agora, novamente, lembre-se dos ponto-e-vírgula e todos os que são

92
00:07:00,440 --> 00:07:05,120
importantes, não se esqueça deles quando você estiver digitando seu código.

93
00:07:05,120 --> 00:07:07,930
Então, eu vou dizer resultado inserido.

94
00:07:07,930 --> 00:07:12,165
Este objeto de resultado que é retornado,

95
00:07:12,165 --> 00:07:15,785
terá sobre ele uma propriedade chamada de propriedade result,

96
00:07:15,785 --> 00:07:20,270
e esta propriedade conterá um valor.

97
00:07:20,270 --> 00:07:23,600
Esta propriedade de resultado também é um objeto JavaScript,

98
00:07:23,600 --> 00:07:31,395
e isso irá conter uma propriedade n que nos diz quantos documentos foram inseridos.

99
00:07:31,395 --> 00:07:36,875
Então essa é a informação que eu vou imprimir aqui,

100
00:07:36,875 --> 00:07:39,540
e então vamos para a próxima linha e

101
00:07:39,540 --> 00:07:50,750
dizer “documentos para a coleção”.

102
00:07:53,070 --> 00:08:02,040
Agora, esta é apenas uma maneira de informar o usuário que esta operação ocorreu corretamente,

103
00:08:02,040 --> 00:08:10,135
e então eles vão passar esse resultado de volta para a nossa função de chamada.

104
00:08:10,135 --> 00:08:15,330
Então, vamos chamar o retorno de chamada e, em seguida, o resultado será o parâmetro para o retorno de chamada.

105
00:08:15,330 --> 00:08:21,595
Então, quando implementamos o uso desta função em nosso arquivo index.js,

106
00:08:21,595 --> 00:08:23,930
estaremos fornecendo o retorno de chamada lá que

107
00:08:23,930 --> 00:08:26,880
receberá o resultado como o parâmetro de entrada.

108
00:08:26,880 --> 00:08:30,670
Então, isso é para o “InsertDocument”.

109
00:08:30,670 --> 00:08:33,010
Agora, para o “FindDocument

110
00:08:33,010 --> 00:08:36,750
”, o que eu vou fazer é dizer,

111
00:08:37,010 --> 00:08:41,640
“col.find” e eu vou encontrar todos os documentos.

112
00:08:41,640 --> 00:08:44,810
Então, é por isso que eu vou dar um objeto JavaScript vazio aqui,

113
00:08:44,810 --> 00:08:51,040
que irá coincidir com todos os documentos na coleção e então eu vou dizer,

114
00:08:51,040 --> 00:09:01,820
“toArray” e isso vai tomar como parâmetro uma função de callback,

115
00:09:02,220 --> 00:09:06,505
e dentro dessa função de callback, é claro,

116
00:09:06,505 --> 00:09:11,710
eu vou afirmar que isso não é nulo,

117
00:09:11,710 --> 00:09:20,590
e então diremos, “docs de retorno de chamada.”

118
00:09:20,590 --> 00:09:27,440
Vamos simplesmente passar de volta os documentos recuperados de volta para a função de chamada.

119
00:09:28,200 --> 00:09:37,750
Agora, para o “RemoveDocument”, eu vou dizer, “coleção DeleteOne”.

120
00:09:37,750 --> 00:09:40,270
Então, vou tentar encontrar o primeiro documento que

121
00:09:40,270 --> 00:09:45,130
corresponde ao que especificamos e, em seguida, excluí-lo.

122
00:09:45,130 --> 00:09:47,070
E então isso levará, novamente,

123
00:09:47,070 --> 00:09:50,380
uma função de retorno de chamada como um segundo parâmetro,

124
00:09:50,380 --> 00:09:52,685
e dentro dessa função de retorno de chamada,

125
00:09:52,685 --> 00:09:58,160
a primeira coisa que eu verifico é certificar-se de que o erro não é nulo.

126
00:09:58,160 --> 00:10:01,820
E depois disso, diremos:

127
00:10:02,130 --> 00:10:20,890
“O registro do console removeu o documento vírgula do documento.”

128
00:10:20,890 --> 00:10:24,840
Nós usamos a vírgula aqui porque este é um objeto JavaScript então,

129
00:10:24,840 --> 00:10:26,890
se você especificar log console como este,

130
00:10:26,890 --> 00:10:30,360
o documento será impresso e, em seguida, vamos passar

131
00:10:30,360 --> 00:10:36,705
esse resultado de volta através da função callback.

132
00:10:36,705 --> 00:10:47,550
E, finalmente, para a atualização, vamos colar.UpdateOne.

133
00:10:47,670 --> 00:10:52,255
Este é um método que o driver MongoDB suporta.

134
00:10:52,255 --> 00:10:56,560
Então, eu vou dizer, “Update.one document

135
00:10:56,560 --> 00:11:01,480
”, e o segundo parâmetro é onde

136
00:11:01,480 --> 00:11:06,960
vamos passar nos campos que precisam ser atualizados.

137
00:11:06,960 --> 00:11:08,915
E do jeito que é feito,

138
00:11:08,915 --> 00:11:12,810
vamos dizer, “atualização de dois pontos do dólar.”

139
00:11:12,810 --> 00:11:16,100
Então, isso levará as informações de atualização que

140
00:11:16,100 --> 00:11:19,120
estou enviando e, em seguida, passará para o Update.One.

141
00:11:19,120 --> 00:11:21,620
O primeiro é o documento que precisa ser atualizado.

142
00:11:21,620 --> 00:11:25,425
O segundo é quais campos do documento precisam ser atualizados aqui.

143
00:11:25,425 --> 00:11:28,660
E o terceiro parâmetro é nulo,

144
00:11:28,770 --> 00:11:36,305
e esse último parâmetro é uma função de retorno de chamada,

145
00:11:36,305 --> 00:11:45,660
que obviamente nos dará o resultado da operação.

146
00:11:45,660 --> 00:11:51,125
Então, a primeira coisa que eu vou verificar para ter certeza de que o erro não é nulo.

147
00:11:51,125 --> 00:11:59,535
Em seguida, eu vou fazer um “log do console atualizado o documento com.”

148
00:11:59,535 --> 00:12:03,195
Agora, novamente, os logs do console são puramente para nós para

149
00:12:03,195 --> 00:12:07,920
garantir que o código está fazendo o que está fazendo.

150
00:12:07,920 --> 00:12:09,690
Não ajuda de forma alguma.

151
00:12:09,690 --> 00:12:11,995
Isto é só para nossa própria informação.

152
00:12:11,995 --> 00:12:15,070
Em um servidor de produção,

153
00:12:15,070 --> 00:12:18,570
você não estaria tendo esses logs de console, talvez.

154
00:12:18,570 --> 00:12:24,220
Você pode desativá-los. Então, é isso.

155
00:12:24,220 --> 00:12:32,370
Portanto, quatro métodos que estão sendo suportados neste módulo de nó baseado em arquivo específico inserir,

156
00:12:32,370 --> 00:12:35,040
localizar, remover e atualizar.

157
00:12:35,040 --> 00:12:38,490
Então, agora que implementamos este módulo de nó baseado em arquivo,

158
00:12:38,490 --> 00:12:41,185
vamos para o arquivo index.js

159
00:12:41,185 --> 00:12:45,985
e, em seguida, para fazer uso desse módulo de nó baseado em arquivo,

160
00:12:45,985 --> 00:12:48,010
eu preciso exigir isso aqui.

161
00:12:48,010 --> 00:12:53,969
Então, eu vou dizer, “Const dboper requer.”

162
00:12:53,969 --> 00:13:00,155
Uma vez que este é um módulo de nó baseado em arquivo, você obtém o caminho completo para o módulo de nó,

163
00:13:00,155 --> 00:13:03,865
e que neste caso acontece a ser. /operações

164
00:13:03,865 --> 00:13:09,760
porque ele está na mesma pasta que o meu arquivo index.js.

165
00:13:09,760 --> 00:13:12,400
Agora, uma vez que tenhamos feito isso,

166
00:13:12,400 --> 00:13:19,570
então bem aqui, esta função,

167
00:13:19,570 --> 00:13:24,355
este código que estávamos fazendo para acessar o banco de dados agora inserir,

168
00:13:24,355 --> 00:13:32,430
estaremos usando o dboper que acabamos de implementar para acessar esse banco de dados.

169
00:13:32,430 --> 00:13:36,280
Então, vamos dizer, “dboper insert document,

170
00:13:36,280 --> 00:13:40,345
" e este “insert document” leva o db como o primeiro parâmetro.

171
00:13:40,345 --> 00:13:45,015
O banco de dados aqui, é este banco de dados que veio quando chamamos MongoClient connect.

172
00:13:45,015 --> 00:13:48,010
Assim que o banco de dados será passado, assim,

173
00:13:48,010 --> 00:13:53,805
meu módulo de nó de operações sabe onde acessar o banco de dados.

174
00:13:53,805 --> 00:13:59,325
Em seguida, o segundo parâmetro é o,

175
00:13:59,325 --> 00:14:03,950
então se você olhar para o “inserir documento” você verá

176
00:14:03,950 --> 00:14:08,055
que o segundo parâmetro é o documento a ser inserido.

177
00:14:08,055 --> 00:14:10,850
Então, eu vou dizer, “nome. “

178
00:14:11,640 --> 00:14:21,680
Eu estou indo apenas para construir um objeto JSON ou JavaScript objeto aqui,

179
00:14:21,680 --> 00:14:27,315
que será automaticamente mapeado em objeto adjacente quando ele está sendo inserido.

180
00:14:27,315 --> 00:14:30,135
E o terceiro parâmetro, como você vê,

181
00:14:30,135 --> 00:14:32,790
“coleção de documentos de banco de dados e retorno de chamada.”

182
00:14:32,790 --> 00:14:36,690
Então o terceiro parâmetro é a coleção e a coleção é

183
00:14:36,690 --> 00:14:42,855
a coleção de pratos e o final é o callback.

184
00:14:42,855 --> 00:14:48,605
A chamada de volta novamente quando você se lembra recebe o resultado.

185
00:14:48,605 --> 00:14:52,710
Se você olhar para trás para o bebê implementou o documento de inserção,

186
00:14:52,710 --> 00:14:55,245
o retorno de chamada recebeu o resultado como o parâmetro.

187
00:14:55,245 --> 00:15:00,305
Então, dentro deste callback, vamos lidar com esse valor de resultado aqui.

188
00:15:00,305 --> 00:15:07,000
Então, quando o valor do resultado vem em nós vamos fazer um console.log.

189
00:15:07,390 --> 00:15:12,750
Vamos dizer inserir

190
00:15:13,240 --> 00:15:20,565
barra invertida do documento N e vamos dizer resultado OPS.

191
00:15:20,565 --> 00:15:24,760
O OPS informa o número de operações de inserção que foram realizadas.

192
00:15:24,760 --> 00:15:28,680
Então este é outro objeto que vai estar no

193
00:15:28,680 --> 00:15:31,790
objeto JavaScript resultado que é passado de volta como

194
00:15:31,790 --> 00:15:34,650
o parâmetro e então eu vou apenas imprimir esse valor.

195
00:15:34,650 --> 00:15:38,260
Então isso nos dará algumas informações sobre o que aconteceu.

196
00:15:38,260 --> 00:15:40,610
Agora, uma vez que isto seja concluído,

197
00:15:40,610 --> 00:15:45,880
dentro desta função de retorno eu vou chamar a próxima operação de banco de dados.

198
00:15:45,880 --> 00:15:50,730
Então eu vou dizer dboper e depois encontrar os documentos.

199
00:15:50,730 --> 00:16:00,260
Então eu vou dizer dbmeals e o terceiro parâmetro é docs,

200
00:16:00,260 --> 00:16:03,090
que é a função callback.

201
00:16:03,090 --> 00:16:06,100
Quando eu receber os documentos, vou fazer um

202
00:16:06,100 --> 00:16:15,170
console.log dizendo documentos encontrados,

203
00:16:16,170 --> 00:16:22,140
e simplesmente bloquearemos os documentos na tela.

204
00:16:22,140 --> 00:16:25,075
Então, isso imprimirá os documentos encontrados.

205
00:16:25,075 --> 00:16:28,470
Observe que esta chamada está dentro

206
00:16:28,470 --> 00:16:37,480
da função de retorno que é aplicada para a chamada de função anterior, de

207
00:16:37,480 --> 00:16:41,225
modo que é algo que eu quero que você observe especificamente.

208
00:16:41,225 --> 00:16:46,290
Agora, novamente dentro desta chamada de função eles precisam fazê-lo desta maneira porque até que

209
00:16:46,290 --> 00:16:52,185
este callback seja chamado não podemos fazer a próxima operação.

210
00:16:52,185 --> 00:16:58,855
Então, nessa próxima operação, vou atualizar o documento que acabei de inserir.

211
00:16:58,855 --> 00:17:03,990
Então eu vou dizer atualizar o documento e eu vou dizer Atualizar Documento DB,

212
00:17:03,990 --> 00:17:07,880
e, em seguida, o próximo parâmetro é o documento

213
00:17:07,880 --> 00:17:11,800
e eu não preciso especificar o documento inteiro Eu só posso especificar um campo e, em

214
00:17:11,800 --> 00:17:20,740
seguida, que vai encontrar o documento que corresponde a este campo particular.

215
00:17:21,960 --> 00:17:27,690
O que eu vou fazer é o próximo parâmetro é a atualização que precisa ser fornecida.

216
00:17:27,690 --> 00:17:30,770
Então, a atualização é qual campo eu quero atualizar,

217
00:17:30,770 --> 00:17:35,350
então eu vou atualizar

218
00:17:35,350 --> 00:17:42,050
o campo de descrição dizendo Updated Test,

219
00:17:43,030 --> 00:17:48,475
e então o quarto é a coleção que é Dates,

220
00:17:48,475 --> 00:17:53,820
e o final é a função callback que obtém

221
00:17:53,820 --> 00:18:01,110
os documentos como o valor de retorno ou

222
00:18:01,110 --> 00:18:08,705
melhor resultado da operação de atualização que acabamos de realizar.

223
00:18:08,705 --> 00:18:11,890
Em seguida, dentro desta função de retorno de chamada,

224
00:18:11,890 --> 00:18:20,845
eu vou fazer novamente um console.log dizendo

225
00:18:20,845 --> 00:18:31,050
atualizado documento barra invertida N. O documento atualizado será passado de

226
00:18:31,050 --> 00:18:38,125
volta em result.result

227
00:18:38,125 --> 00:18:43,115
nesta propriedade do objeto de resultado que é passado rastreamento.

228
00:18:43,115 --> 00:18:49,044
Novamente, observe como as chamadas estão sendo aninhadas

229
00:18:49,044 --> 00:18:54,585
dentro das funções de retorno de chamada aqui.

230
00:18:54,585 --> 00:18:57,880
Quero que notem esta estrutura do código

231
00:18:57,880 --> 00:19:03,130
especificamente porque é para isso que vou voltar no próximo exercício.

232
00:19:03,130 --> 00:19:05,760
Agora depois que eu fizer isso,

233
00:19:05,760 --> 00:19:07,529
eu vou encontrar os documentos,

234
00:19:07,529 --> 00:19:12,930
então deixe-me apenas copiar isso e então eu vou usar o mesmo código aqui.

235
00:19:13,840 --> 00:19:19,530
Então eu vou dizer, encontrar documentos.

236
00:19:20,000 --> 00:19:27,695
Dentro aqui eu vou novamente dizer, encontrado documento atualizado.

237
00:19:27,695 --> 00:19:30,375
Então, finalmente, quando eu terminar com isso,

238
00:19:30,375 --> 00:19:35,855
eu vou simplesmente chamar coleção drop db.

239
00:19:35,855 --> 00:19:38,760
Então eu vou excluir esta coleção de pratos para que eu

240
00:19:38,760 --> 00:19:41,630
vou limpar meu banco de dados para que eu não tenha

241
00:19:41,630 --> 00:19:44,350
mais nada porque para o próximo exercício eu quero limpar

242
00:19:44,350 --> 00:19:47,230
o banco de dados e, em seguida, começar com um banco de dados mais limpo.

243
00:19:47,230 --> 00:19:48,835
Então, eu vou limpar

244
00:19:48,835 --> 00:19:57,770
a coleção de pratos e, em seguida, isso resultaria em um retorno de chamada.

245
00:19:59,110 --> 00:20:07,410
Então, dentro aqui eu vou fazer um ditado console.log,

246
00:20:07,410 --> 00:20:17,000
coleção caiu, e então eu vou apenas imprimir o resultado que entrou.

247
00:20:17,820 --> 00:20:25,250
Então, finalmente, feche o banco de dados.

248
00:20:25,650 --> 00:20:28,895
Observe que a estrutura do código,

249
00:20:28,895 --> 00:20:34,580
DB inserir documento e dentro da função callback eu vou chamar

250
00:20:34,580 --> 00:20:37,690
a próxima função e dentro

251
00:20:37,690 --> 00:20:39,660
do callback off que eu vou chamar

252
00:20:39,660 --> 00:20:42,270
a próxima função e dentro da próxima função de callback e assim por diante.

253
00:20:42,270 --> 00:20:46,990
Então, você vê um conjunto aninhado de retornos de chamada aqui e

254
00:20:46,990 --> 00:20:52,665
um conjunto estruturado de árvore aninhado de retorno de chamada aqui.

255
00:20:52,665 --> 00:20:56,505
Isso é algo que eu quero que você preste atenção.

256
00:20:56,505 --> 00:21:02,680
Vamos salvar as alterações e ir e olhar para esta versão do nosso aplicativo.

257
00:21:02,680 --> 00:21:04,725
Voltando ao terminal,

258
00:21:04,725 --> 00:21:08,045
deixe-me executar o aplicativo.

259
00:21:08,045 --> 00:21:13,035
Então deixe-me digitar NPM start e veremos esse resultado.

260
00:21:13,035 --> 00:21:19,060
Agora, a partir deste resultado você pode ver que o documento está

261
00:21:19,060 --> 00:21:25,330
inserido na coleção e que é o documento que foi encontrado.

262
00:21:25,330 --> 00:21:26,990
Na segunda etapa,

263
00:21:26,990 --> 00:21:31,540
estamos encontrando o documento para quando chamamos o documento DB find,

264
00:21:31,540 --> 00:21:36,175
então este é o documento que é recuperado da minha coleção.

265
00:21:36,175 --> 00:21:39,010
Então eu peço a ele para atualizar o documento com

266
00:21:39,010 --> 00:21:42,915
isso e então você vai notar que ele diz documento atualizado e, em seguida,

267
00:21:42,915 --> 00:21:46,850
aqui ele imprime o resultado ou OPS e ele diz N é igual a

268
00:21:46,850 --> 00:21:51,775
um número modificado como um e estava tudo bem.

269
00:21:51,775 --> 00:21:57,010
Em seguida, ele imprime o documento atualizado,

270
00:21:57,010 --> 00:22:02,020
encontramos o documento atualizado aqui e isso é o que é impresso aqui,

271
00:22:02,020 --> 00:22:05,770
e note em particular que a descrição foi atualizada.

272
00:22:05,770 --> 00:22:09,390
Então, finalmente, ele deixou cair a coleção.

273
00:22:09,990 --> 00:22:16,690
Então, vemos como este aplicativo é executado e é capaz de fazer uso

274
00:22:16,690 --> 00:22:23,410
do módulo nó que implementamos e, em seguida, executou várias operações de banco de dados.

275
00:22:23,410 --> 00:22:26,560
Com isso, completamos este exercício.

276
00:22:26,560 --> 00:22:31,520
Neste exercício eu tenho demonstrado a você como você iria interagir com

277
00:22:31,520 --> 00:22:37,085
o seu servidor MongoDB a partir de seu aplicativo nó.

278
00:22:37,085 --> 00:22:43,455
Nós implementamos nosso próprio módulo de nó aqui e, em seguida, usá-lo

279
00:22:43,455 --> 00:22:46,810
dentro da nossa aplicação nó, encapsulando

280
00:22:46,810 --> 00:22:50,965
certas operações de banco de dados nesse módulo nó.

281
00:22:50,965 --> 00:22:54,020
Este é um bom momento para você fazer um commit Git com

282
00:22:54,020 --> 00:22:58,860
o nó de mensagem MongoDB exemplo parte dois.