1
00:00:03,920 --> 00:00:10,025
Agora que aprendemos sobre o driver MongoDB nó, o módulo nó,

2
00:00:10,025 --> 00:00:14,205
que permite que nosso aplicativo nó seja capaz de interagir

3
00:00:14,205 --> 00:00:18,475
com um servidor MongoDB, neste exercício,

4
00:00:18,475 --> 00:00:23,430
vamos usar o módulo nó e usar os vários métodos que são

5
00:00:23,430 --> 00:00:29,840
suportados pelo módulo nó para fornecer introdução com nosso servidor MongoDB.

6
00:00:29,840 --> 00:00:33,030
Para começar, vá para

7
00:00:33,030 --> 00:00:38,135
a pasta NodeJS que você tem usado para armazenar todos os seus exemplos

8
00:00:38,135 --> 00:00:45,310
e, em seguida, crie uma nova pasta chamada node-mongo.

9
00:00:45,320 --> 00:00:48,125
Nesta pasta, vamos desenvolver

10
00:00:48,125 --> 00:00:52,715
o aplicativo NodeJS que interage com o nosso servidor MongoDB.

11
00:00:52,715 --> 00:00:57,140
Agora, certifique-se de que o seu servidor MongoDB está funcionando,

12
00:00:57,140 --> 00:01:02,675
então, no exercício anterior, já vimos como o nosso servidor MongoDB pode ser iniciado.

13
00:01:02,675 --> 00:01:07,370
Então, mantenha o servidor MongoDB funcionando e em

14
00:01:07,370 --> 00:01:12,060
outra janela de terminal ou guia terminal ou janela de comando,

15
00:01:12,060 --> 00:01:15,020
vá para a pasta node-mongo que você acabou de

16
00:01:15,020 --> 00:01:18,135
criar e inicialize um aplicativo de nó aqui.

17
00:01:18,135 --> 00:01:22,910
Então, deixe-me digitar npm init e

18
00:01:22,910 --> 00:01:29,765
vamos nomear o aplicativo como Node-Mongo e versão,

19
00:01:29,765 --> 00:01:36,895
descrição Node MongoDB Exemplo,

20
00:01:36,895 --> 00:01:39,295
eo ponto de entrada,

21
00:01:39,295 --> 00:01:48,980
eo autor, assim como temos sido preenchendo os exercícios anteriores.

22
00:01:48,980 --> 00:01:53,255
Então, uma vez que o arquivo package.json é inicializado,

23
00:01:53,255 --> 00:01:59,610
abra isso no editor de sua escolha.

24
00:01:59,610 --> 00:02:02,635
Agora indo para o arquivo package.json,

25
00:02:02,635 --> 00:02:09,370
deixe-me introduzir outro script aqui exatamente como fizemos anteriormente, então,

26
00:02:09,370 --> 00:02:16,350
vamos dizer “start”: “node index” e salvar as alterações.

27
00:02:16,350 --> 00:02:18,010
Voltando ao terminal,

28
00:02:18,010 --> 00:02:22,350
vamos instalar o módulo do nó MongoDB.

29
00:02:22,350 --> 00:02:30,080
Então, digite npm install mongodb @3 .0.10 —save.

30
00:02:30,080 --> 00:02:33,590
Nós também instalaremos o módulo do nó assert, então,

31
00:02:33,590 --> 00:02:39,460
vamos dizer npm install assert @1 .4.1 —save.

32
00:02:39,460 --> 00:02:42,710
O módulo assert nos permite usar o assert

33
00:02:42,710 --> 00:02:46,720
para verificar se há valores de verdade ou falsos dentro de nossa aplicação,

34
00:02:46,720 --> 00:02:49,535
e você vai me ver usando-o mais tarde.

35
00:02:49,535 --> 00:02:52,645
Agora que temos instalado esses módulos de nó,

36
00:02:52,645 --> 00:02:58,355
vamos criar nosso aplicativo nó que interage com o servidor MongoDB.

37
00:02:58,355 --> 00:03:00,455
Voltando para o editor,

38
00:03:00,455 --> 00:03:01,915
na pasta do projeto,

39
00:03:01,915 --> 00:03:05,465
criar um arquivo chamado index.js,

40
00:03:05,465 --> 00:03:07,684
e é aqui que vamos criar

41
00:03:07,684 --> 00:03:12,030
o aplicativo nó que interage com o nosso servidor MongoDB.

42
00:03:12,030 --> 00:03:14,425
Então, nesta aplicação,

43
00:03:14,425 --> 00:03:18,630
vamos digitar const Mongoclient,

44
00:03:18,800 --> 00:03:21,555
e então eles vão dizer,

45
00:03:21,555 --> 00:03:28,160
require (`mongodb`), o módulo de nó MongoDB que já instalamos,

46
00:03:28,160 --> 00:03:30,335
e então isso nos forneceria com

47
00:03:30,335 --> 00:03:38,045
o MongoClient que nos permite conectar ao servidor MongoDB.

48
00:03:38,045 --> 00:03:47,160
Além disso, exija o módulo assert.

49
00:03:48,830 --> 00:03:53,870
Agora, para iniciar uma conexão com o servidor MongoDB,

50
00:03:53,870 --> 00:04:03,590
vamos criar uma URL de nome constante que será a URL onde o servidor MongoDB pode ser

51
00:04:03,590 --> 00:04:08,030
acessado e o bebê acessar isso é

52
00:04:08,030 --> 00:04:14,950
dizendo mongodb: //localhost: 27017/.

53
00:04:14,950 --> 00:04:19,360
Lembre-se que este é o número da porta em que seu servidor MongoDB está

54
00:04:19,360 --> 00:04:25,025
executando 27017 const dbname=,

55
00:04:25,025 --> 00:04:27,205
e então eles vamos dizer Confusion.

56
00:04:27,205 --> 00:04:28,820
Lembre-se de que criamos

57
00:04:28,820 --> 00:04:34,060
o banco de dados Confusion em nosso servidor MongoDB no exercício anterior

58
00:04:34,060 --> 00:04:39,310
, então, vamos acessar que o banco de dados Confusion que criamos anteriormente.

59
00:04:39,310 --> 00:04:46,240
Agora, para acessar o servidor, vamos dizer mongoClient.connect.

60
00:04:48,690 --> 00:04:54,790
Então, o método connect nos permite conectar ao MongoClient do nosso servidor MongoDB,

61
00:04:54,790 --> 00:04:59,230
e então vamos dizer que isso leva a URL como o primeiro parâmetro,

62
00:04:59,230 --> 00:05:02,485
a URL do servidor MongoDB como o primeiro parâmetro.

63
00:05:02,485 --> 00:05:06,590
O segundo parâmetro é uma função de retorno de chamada.

64
00:05:06,590 --> 00:05:14,275
Então, a função de retorno de chamada tem dois parâmetros, o valor de erro

65
00:05:14,275 --> 00:05:17,915
e cliente, que podemos então usar

66
00:05:17,915 --> 00:05:22,405
para se conectar ao nosso banco de dados e, em seguida, executar várias operações.

67
00:05:22,405 --> 00:05:27,040
Então, dentro desta função callback, a

68
00:05:27,040 --> 00:05:36,400
primeira coisa que vamos fazer é verificar para se certificar de que o erro não é nulo.

69
00:05:36,400 --> 00:05:39,740
Então, o assert irá verificar para ver se o erro é igual a null,

70
00:05:39,740 --> 00:05:45,640
então a função assert nos permite executar várias verificações em valores.

71
00:05:45,640 --> 00:05:48,010
Então, verificamos para ter certeza de que o erro não

72
00:05:48,010 --> 00:05:49,785
é, se não for nulo,

73
00:05:49,785 --> 00:05:55,660
então isso significa que há um erro e então vamos mostrar o erro na tela.

74
00:05:55,660 --> 00:05:59,650
Então, esse é o uso da função de afirmação aqui.

75
00:05:59,650 --> 00:06:03,025
Agora, se isso não acontecer,

76
00:06:03,025 --> 00:06:07,430
então isso significa que temos conectado corretamente ao servidor,

77
00:06:07,430 --> 00:06:15,170
então vamos dizer `conectado corretamente ao server`

78
00:06:15,170 --> 00:06:25,120
const db= client.db (dbname) para se conectar ao banco de dados,

79
00:06:25,120 --> 00:06:33,570
então podemos dizer const collection db. ,

80
00:06:33,570 --> 00:06:38,810
então o db nos fornecerá vários métodos que nos permitem

81
00:06:38,810 --> 00:06:44,380
interagir com o servidor, então vamos dizer db.collection (`dishes`) Então,

82
00:06:44,380 --> 00:06:49,765
vamos tentar acessar a coleção de pratos dentro deste banco de dados.

83
00:06:49,765 --> 00:06:55,175
Agora, a próxima coisa que vamos tentar fazer é

84
00:06:55,175 --> 00:07:04,414
collection.insertone então vamos tentar inserir um objeto na coleção,

85
00:07:04,414 --> 00:07:08,360
e este objeto seria com

86
00:07:08,360 --> 00:07:28,510
o nome e a descrição, “test”.

87
00:07:28,510 --> 00:07:32,520
Então, esta coleção fornece este método chamado

88
00:07:32,520 --> 00:07:36,825
InsertOne, que nos permite inserir um documento nesta coleção,

89
00:07:36,825 --> 00:07:42,825
eo documento é o primeiro argumento para este método aqui.

90
00:07:42,825 --> 00:07:49,780
O segundo argumento para o método é uma função de retorno de chamada,

91
00:07:49,780 --> 00:07:56,720
e a função de retorno de chamada leva dois parâmetros, erro e resultado.

92
00:07:58,260 --> 00:08:01,000
Então, dentro desta função de retorno de chamada,

93
00:08:01,000 --> 00:08:03,180
se o resultado for obtido,

94
00:08:03,180 --> 00:08:08,610
então somos capazes de acessar a coleção e, em seguida, executar outras operações.

95
00:08:08,610 --> 00:08:16,645
Então, aqui, a primeira coisa que vamos fazer é verificar se o erro não é nulo.

96
00:08:16,645 --> 00:08:19,450
Então, vamos fazer uma afirmação lá,

97
00:08:19,450 --> 00:08:33,470
e então aqui podemos dizer, “Após Inserir”.

98
00:08:37,770 --> 00:08:45,145
Então, depois de inserir, então vemos que

99
00:08:45,145 --> 00:08:51,490
obtemos o valor do resultado que é retornado lá, então este resultado.

100
00:08:51,490 --> 00:08:56,070
Este resultado também irá fornecer

101
00:08:56,070 --> 00:09:00,805
esta propriedade OPS que diz quantas operações acabaram de ser realizadas com sucesso.

102
00:09:00,805 --> 00:09:02,715
Então, é isso que vou imprimir.

103
00:09:02,715 --> 00:09:05,140
Então, ele vai dizer número inserido é um.

104
00:09:05,140 --> 00:09:12,030
Então, o que significa que este documento em particular foi inserido no banco de dados.

105
00:09:12,070 --> 00:09:15,440
Então, isso é o que vamos confirmar aqui.

106
00:09:15,440 --> 00:09:19,810
Então, depois disso, vamos executar outra opção,

107
00:09:19,810 --> 00:09:22,415
uma operação na coleção, e dizer,

108
00:09:22,415 --> 00:09:30,200
coleção encontrar, e vamos tentar procurar por todos os registros na coleção.

109
00:09:30,200 --> 00:09:37,420
Então, aqui, vamos fornecer uma string JSON vazia ou objeto JavaScript nível correspondente.

110
00:09:37,420 --> 00:09:40,895
Então, ele vai procurar por tudo o que está lá na coleção,

111
00:09:40,895 --> 00:09:43,750
e então, fornecer isso para nós.

112
00:09:43,750 --> 00:09:48,640
Em seguida, isso pode ser convertido em uma matriz de objetos JSON.

113
00:09:48,640 --> 00:09:52,215
Então, é por isso que chamamos o ToArray,

114
00:09:52,215 --> 00:09:59,365
e isso leva uma função de retorno de chamada como parâmetro.

115
00:09:59,365 --> 00:10:07,065
O primeiro parâmetro, é claro, é o valor do erro, então, novamente,

116
00:10:07,065 --> 00:10:16,365
verificamos se o erro não é nulo.

117
00:10:16,365 --> 00:10:25,990
Então vamos dizer, console.log encontrado

118
00:10:25,990 --> 00:10:29,140
e, em seguida, imprimir o que quer que tenha sido encontrado,

119
00:10:29,140 --> 00:10:32,505
e diremos console.log.

120
00:10:32,505 --> 00:10:35,080
Então, o segundo parâmetro aqui, docs,

121
00:10:35,080 --> 00:10:38,370
retornará todos os documentos desta coleção

122
00:10:38,370 --> 00:10:42,380
que correspondam a qualquer critério que você especificar aqui.

123
00:10:42,380 --> 00:10:43,970
Como isso está vazio,

124
00:10:43,970 --> 00:10:47,535
então isso significa que todos os documentos da coleção serão devolvidos para nós.

125
00:10:47,535 --> 00:10:49,500
Você pode especificar um filtro aqui,

126
00:10:49,500 --> 00:10:54,030
dizendo que o nome é igual a um valor

127
00:10:54,030 --> 00:10:57,325
e, em seguida, somente os documentos que correspondem a esse valor serão recuperados.

128
00:10:57,325 --> 00:11:04,040
Então aqui, deixe-me apenas imprimir os documentos aqui,

129
00:11:04,040 --> 00:11:07,660
para indicar que este item

130
00:11:07,660 --> 00:11:11,990
foi inserido na coleção e, em seguida, será recuperado,

131
00:11:11,990 --> 00:11:15,950
e então vamos apenas imprimi-lo apenas para ter certeza de que o documento que acabamos de

132
00:11:15,950 --> 00:11:20,590
inserir na operação anterior está de fato na coleção,

133
00:11:20,590 --> 00:11:22,420
e então vamos imprimir isso aqui.

134
00:11:22,420 --> 00:11:28,060
Agora depois disso, então vamos usar

135
00:11:28,060 --> 00:11:35,880
o método DropCollection aqui.

136
00:11:35,880 --> 00:11:40,560
Então, o DropCollection irá soltar a coleção especificada aqui.

137
00:11:40,560 --> 00:11:42,410
Então, vamos dizer pratos DropCollection,

138
00:11:42,410 --> 00:11:45,820
então eu vou apenas remover a coleção de pratos do meu banco de dados.

139
00:11:45,820 --> 00:11:48,180
Então, eu estou indo apenas para limpar o banco de dados e, em seguida,

140
00:11:48,180 --> 00:11:51,090
deixá-lo com um banco de dados vazio para que possamos ir para

141
00:11:51,090 --> 00:11:53,610
o próximo exercício onde nós podemos novamente

142
00:11:53,610 --> 00:11:57,115
executar tipo semelhante de operações para verificar isso.

143
00:11:57,115 --> 00:12:00,455
Este toma, como segundo parâmetro,

144
00:12:00,455 --> 00:12:06,815
uma função de retorno de chamada que retorna um erro ou um resultado.

145
00:12:06,815 --> 00:12:16,040
Dentro disso, verificamos e certificamo-nos de que a afirmação não é nula,

146
00:12:16,440 --> 00:12:20,780
e então diremos, cliente.close.

147
00:12:20,780 --> 00:12:25,425
Então vamos fechar a conexão com o banco de dados no local.

148
00:12:25,425 --> 00:12:34,465
Então, com isso, este conjunto simples de métodos nos permitem interagir com o nosso servidor,

149
00:12:34,465 --> 00:12:41,150
e também nos demonstra como podemos nos comunicar com o servidor usando

150
00:12:41,150 --> 00:12:48,185
os métodos que estão disponíveis através deste módulo nó MongoDB ou o driver MongoDB.

151
00:12:48,185 --> 00:12:51,900
Então, aqui, você vê que primeiro realizamos uma operação de inserção.

152
00:12:51,900 --> 00:12:54,875
Em seguida, após a operação de inserção, note que,

153
00:12:54,875 --> 00:12:59,715
estamos fazendo a segunda operação dentro da função de retorno de chamada.

154
00:12:59,715 --> 00:13:07,490
Então, isso garante que esta operação foi concluída antes de você fazer a próxima.

155
00:13:07,490 --> 00:13:15,680
Então, esta é uma segunda chamada que é fechada dentro da primeira função de retorno de chamada,

156
00:13:15,680 --> 00:13:19,470
e, em seguida, correspondentemente, dentro dela.

157
00:13:19,470 --> 00:13:24,370
Estamos novamente chamando os métodos aqui e lá dentro.

158
00:13:24,370 --> 00:13:28,080
Então, você vê que há um aninhamento dessas chamadas,

159
00:13:28,080 --> 00:13:29,435
uma dentro da outra.

160
00:13:29,435 --> 00:13:32,200
Observe a estrutura porque eu vou voltar para

161
00:13:32,200 --> 00:13:35,755
explicar algo sobre isso em um dos exercícios posteriores.

162
00:13:35,755 --> 00:13:40,235
Então, note que, aninhamento dessas chamadas uma dentro da outra.

163
00:13:40,235 --> 00:13:43,020
Vamos salvar as alterações

164
00:13:43,210 --> 00:13:49,330
e, em seguida, ver o que este aplicativo faz quando executá-lo.

165
00:13:49,330 --> 00:13:51,685
Voltando para o terminal, novamente,

166
00:13:51,685 --> 00:13:55,170
certifique-se de que seu servidor MongoDB está funcionando, e assim,

167
00:13:55,170 --> 00:14:00,560
quando ele está executando ele vai imprimir um monte de mensagens de log no console.

168
00:14:00,560 --> 00:14:04,230
Podemos ignorar as mensagens de registro por enquanto.

169
00:14:04,230 --> 00:14:06,710
Vamos executar o aplicativo de nó.

170
00:14:06,710 --> 00:14:09,330
Então, vamos dizer, npm start,

171
00:14:09,330 --> 00:14:12,095
e quando o aplicativo nó é executado,

172
00:14:12,095 --> 00:14:14,875
você percebe o que faz aplicativo nó está fazendo.

173
00:14:14,875 --> 00:14:19,705
Então ele diz, conectado corretamente ao servidor, Após Inserir,

174
00:14:19,705 --> 00:14:22,260
então ele mostra que

175
00:14:22,260 --> 00:14:28,375
este documento específico foi inserido em nosso MongoDB e o nó em particular,

176
00:14:28,375 --> 00:14:29,540
o ID dado aqui.

177
00:14:29,540 --> 00:14:32,570
Então, observe que isso não diz que este é um ID de objeto.

178
00:14:32,570 --> 00:14:35,995
Esse ID é inserido automaticamente

179
00:14:35,995 --> 00:14:39,730
pelo driver Mongo nó em seu documento quando

180
00:14:39,730 --> 00:14:43,745
você tenta inseri-lo no servidor MongoDB aqui.

181
00:14:43,745 --> 00:14:48,950
Esse formato é exatamente o mesmo que o ID do objeto que vimos.

182
00:14:48,950 --> 00:14:53,910
Depois disso, realizamos uma operação de busca.

183
00:14:53,910 --> 00:14:55,560
Então, isso é encontrado,

184
00:14:55,560 --> 00:14:58,710
e então ele imprime este item aqui.

185
00:14:58,710 --> 00:15:01,550
Note que a partir do exercício anterior,

186
00:15:01,550 --> 00:15:08,470
tínhamos deixado no documento anterior que tínhamos inserido no exercício anterior.

187
00:15:08,470 --> 00:15:11,005
Então, isso ainda é visto na coleção aqui,

188
00:15:11,005 --> 00:15:13,500
e no novo documento que acabamos de inserir aqui.

189
00:15:13,500 --> 00:15:17,179
Este documento é visto logo abaixo que aqui,

190
00:15:17,179 --> 00:15:20,510
mas note que estes dois têm dois IDs diferentes.

191
00:15:20,510 --> 00:15:25,030
Este ID corresponde ao ID do documento que acabamos de inserir.

192
00:15:25,030 --> 00:15:28,455
Então, isso é sobra do exercício anterior.

193
00:15:28,455 --> 00:15:32,765
Depois disso, é claro que deixamos cair a coleção para que

194
00:15:32,765 --> 00:15:38,060
todo este conjunto de documentos e a coleção de pratos sejam removidos do nosso banco de dados.

195
00:15:38,060 --> 00:15:41,060
Então, agora nosso banco de dados estará limpo e vazio.

196
00:15:41,060 --> 00:15:44,930
Então, isso demonstra a você como podemos usar

197
00:15:44,930 --> 00:15:52,900
o driver MongoDB para se comunicar a partir do nosso aplicativo nó com o servidor.

198
00:15:52,900 --> 00:15:55,330
Agora que temos nossa aplicação,

199
00:15:55,330 --> 00:16:01,000
deixe-me apresentar um.gitignore

200
00:16:01,000 --> 00:16:06,720
aqui e, em seguida, colocar módulos de nó no o.gitignore,

201
00:16:06,720 --> 00:16:10,540
e você rapidamente entender por que eu estou fazendo isso.

202
00:16:10,540 --> 00:16:16,595
Em seguida, vamos voltar e inicializar o repositório Git e, em seguida, fazer um git commit.

203
00:16:16,595 --> 00:16:18,590
Voltando para o terminal,

204
00:16:18,590 --> 00:16:21,505
deixe-me inicializar o repositório Git,

205
00:16:21,505 --> 00:16:31,460
e então, vamos verificar o status do Git e você verá que existem alguns arquivos não confirmados.

206
00:16:31,460 --> 00:16:37,204
Então deixe-me verificá-los em e, em seguida, fazer um git commit com a mensagem,

207
00:16:37,204 --> 00:16:46,450
Node MongoDB Exemplo um.

208
00:16:46,450 --> 00:16:49,305
Esta é a parte um do exercício,

209
00:16:49,305 --> 00:16:54,020
então vamos apenas verificar os itens em nosso repositório git.

210
00:16:54,020 --> 00:16:56,900
Isso completa este exercício.

211
00:16:56,900 --> 00:17:01,760
Neste exercício, vimos como instalamos o módulo de nó,

212
00:17:01,760 --> 00:17:04,365
o driver MongoDB, então,

213
00:17:04,365 --> 00:17:07,835
fomos capazes de se comunicar com o nosso servidor MongoDB de dentro do

214
00:17:07,835 --> 00:17:12,740
nosso aplicativo nó usando os métodos que são fornecidos pelo driver MongoDB.

215
00:17:12,740 --> 00:17:17,840
Continuaremos com este exercício na próxima parte

216
00:17:17,840 --> 00:17:24,380
do exercício, onde exploraremos mais alguns métodos do piloto MongoDB.