1
00:00:03,950 --> 00:00:09,370
En este ejercicio, continuaremos con el ejercicio anterior donde

2
00:00:09,370 --> 00:00:14,650
desarrollamos la interacción entre la aplicación de nodo y el servidor MongoDB.

3
00:00:14,650 --> 00:00:18,120
En este ejercicio, voy a encapsular algunas de

4
00:00:18,120 --> 00:00:21,750
las operaciones de base de datos en un módulo de nodo propio,

5
00:00:21,750 --> 00:00:23,540
un módulo de nodo basado en archivos,

6
00:00:23,540 --> 00:00:29,345
y luego hacer uso de él dentro de mi aplicación de nodo para interactuar con el servidor.

7
00:00:29,345 --> 00:00:31,940
Al mismo tiempo, realizaremos varias operaciones en

8
00:00:31,940 --> 00:00:35,630
el servidor para demostrar que podremos

9
00:00:35,630 --> 00:00:43,040
interactuar con el servidor utilizando nuestra aplicación de nodo y el controlador de nodo MongoDB.

10
00:00:43,040 --> 00:00:47,605
Para empezar, vayamos a nuestro proyecto

11
00:00:47,605 --> 00:00:53,975
y luego creamos un nuevo archivo llamado operations.js.

12
00:00:53,975 --> 00:00:57,720
Este archivo encapsulará todas esas operaciones de base de datos,

13
00:00:57,720 --> 00:01:00,705
las cuatro operaciones que voy a realizar insertar,

14
00:01:00,705 --> 00:01:05,855
encontrar, eliminar y actualizar un documento en mi base de datos.

15
00:01:05,855 --> 00:01:09,980
Ahora, esto se organizará como un módulo de nodo basado en archivos,

16
00:01:09,980 --> 00:01:15,070
que luego lo usaré en mi aplicación de nodo para acceder al servidor.

17
00:01:15,070 --> 00:01:16,330
Entonces, para comenzar,

18
00:01:16,330 --> 00:01:25,780
permítanme primero requerir assert,

19
00:01:25,780 --> 00:01:27,565
en este módulo de nodo,

20
00:01:27,565 --> 00:01:30,225
y dado que esto sucede a ser un módulo de nodo,

21
00:01:30,225 --> 00:01:35,055
estaremos exportando varios métodos desde el módulo de nodo.

22
00:01:35,055 --> 00:01:41,705
El primer método sería insertar documento obviamente como cabría esperar,

23
00:01:41,705 --> 00:01:44,520
y esto tomará cuatro parámetros DB,

24
00:01:44,520 --> 00:01:49,555
el MongoDB, conexión de base de datos dentro de mi aplicación de nodo,

25
00:01:49,555 --> 00:01:54,240
que obtendré dentro de la aplicación de nodo.

26
00:01:54,240 --> 00:01:57,785
Entonces, el segundo es el documento que quiero insertar.

27
00:01:57,785 --> 00:02:02,800
El tercer parámetro es la colección en la que quiero insertar el documento.

28
00:02:02,800 --> 00:02:05,675
La última es una función de devolución de llamada,

29
00:02:05,675 --> 00:02:10,425
que será llamada de vuelta una vez que se complete esa operación.

30
00:02:10,425 --> 00:02:14,800
Luego vamos a cerrar la función aquí,

31
00:02:14,800 --> 00:02:20,100
y esto esencialmente encapsula el método de inserción de documento aquí.

32
00:02:20,100 --> 00:02:27,415
Entonces, esta es una función que es exportada por este módulo de nodo aquí.

33
00:02:27,415 --> 00:02:34,250
Ahora, también voy a incorporar algunos métodos más aquí.

34
00:02:34,250 --> 00:02:42,870
El segundo sería encontrar documentos.

35
00:02:42,870 --> 00:02:46,025
No sólo uno, sino varios documentos.

36
00:02:46,025 --> 00:02:54,390
Esto me gustaría buscar en la colección y encontrar todos los documentos que están en la colección.

37
00:02:54,390 --> 00:02:58,130
Entonces, es por eso que solo tomo la base de datos

38
00:02:58,130 --> 00:03:02,090
y la colección como los dos parámetros junto con la devolución de llamada.

39
00:03:02,090 --> 00:03:11,550
La tercera función que voy a implementar una exportación desde aquí es el removedocument.

40
00:03:12,290 --> 00:03:15,590
Esto admite la operación de eliminación,

41
00:03:15,590 --> 00:03:19,855
por lo que el nombre del documento tomará la base de datos, el documento,

42
00:03:19,855 --> 00:03:23,775
la colección y la devolución de llamada como los cuatro parámetros,

43
00:03:23,775 --> 00:03:30,595
y llamaremos a la devolución de llamada cuando se complete la operación.

44
00:03:30,595 --> 00:03:34,445
El último, por supuesto, es actualizar el documento.

45
00:03:34,445 --> 00:03:38,120
Ahora, por supuesto, no necesariamente tienes que hacerlo de esta manera.

46
00:03:38,120 --> 00:03:42,830
Simplemente sentí que esta sería otra forma de ilustrar cómo puedes

47
00:03:42,830 --> 00:03:49,110
encapsular esas funciones en su propio módulo de nodo.

48
00:03:49,110 --> 00:03:55,395
Esto es solo reorganizar el código de una manera que es más fácil de usar.

49
00:03:55,395 --> 00:03:57,205
Entonces, para las exportaciones,

50
00:03:57,205 --> 00:04:00,070
para el documento de actualización toma el DB,

51
00:04:00,070 --> 00:04:03,750
alguna forma de identificar el documento como un segundo parámetro.

52
00:04:03,750 --> 00:04:06,205
El tercer parámetro es la actualización,

53
00:04:06,205 --> 00:04:08,750
y el cuarto parámetro es la colección en la que

54
00:04:08,750 --> 00:04:11,505
existe este documento y la devolución de llamada.

55
00:04:11,505 --> 00:04:18,160
Por lo tanto, cuatro funciones para ser exportadas por el archivo operations.js.

56
00:04:18,160 --> 00:04:20,380
Ahora, dentro de estas funciones,

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

58
00:04:21,735 --> 00:04:23,420
En el documento de inserción,

59
00:04:23,420 --> 00:04:27,680
lo primero que voy a hacer es decir

60
00:04:27,680 --> 00:04:36,000
colección const y dirá colección DB,

61
00:04:38,930 --> 00:04:44,710
y el parámetro es la colección.

62
00:04:45,350 --> 00:04:50,190
Por lo tanto, vamos a buscar la colección allí.

63
00:04:50,190 --> 00:04:54,640
Ahora, esto tiene que ser realizado en los cuatro métodos.

64
00:04:54,640 --> 00:04:59,990
Entonces, voy a ir y pegar este código en los cuatro métodos aquí,

65
00:05:01,140 --> 00:05:05,390
porque esa es una función que necesito en todos ellos.

66
00:05:05,390 --> 00:05:07,820
Entonces, una vez que me apoye de la colección,

67
00:05:07,820 --> 00:05:11,680
entonces como recuerdas del ejercicio anterior,

68
00:05:11,680 --> 00:05:13,895
puedo realizar operaciones en la colección.

69
00:05:13,895 --> 00:05:19,160
Entonces, diré colección, insertar,

70
00:05:21,300 --> 00:05:27,610
y esto toma como primer parámetro el documento que se insertará,

71
00:05:27,610 --> 00:05:35,695
y el segundo parámetro es la devolución de llamada con el error y ese resultado.

72
00:05:35,695 --> 00:05:40,990
Entonces, ahora cuando este documento

73
00:05:40,990 --> 00:05:46,780
se inserta llamando al método de inserción en la colección de base de datos,

74
00:05:46,780 --> 00:05:49,180
el método de inserción permítanme recordarles,

75
00:05:49,180 --> 00:05:52,090
es compatible con el controlador MongoDB.

76
00:05:52,090 --> 00:05:53,980
Entonces, ese es el método que estamos usando aquí,

77
00:05:53,980 --> 00:05:56,420
o esa es la función que estamos usando aquí.

78
00:05:56,420 --> 00:06:05,060
Ahora, lo primero que voy a comprobar para esto, err assertequal, nulo.

79
00:06:05,060 --> 00:06:09,185
Por lo tanto, quiero asegurarme de que no tengo un error.

80
00:06:09,185 --> 00:06:11,225
Así que quiero asegurarme de que el error sea nulo.

81
00:06:11,225 --> 00:06:12,470
Si no es nulo,

82
00:06:12,470 --> 00:06:15,930
esto imprimirá la información y luego saldrá de la aplicación.

83
00:06:15,930 --> 00:06:19,760
En este momento, siento que esto está bien para manejarlo que más adelante,

84
00:06:19,760 --> 00:06:24,680
veremos cómo podemos tener una forma global de manejar todos los errores cuando

85
00:06:24,680 --> 00:06:34,390
implementemos en la siguiente lección otra forma de acceder a la base de datos MongoDB.

86
00:06:34,390 --> 00:06:36,640
Ahora, después de hacer esto,

87
00:06:36,640 --> 00:06:38,050
voy a implementar,

88
00:06:38,050 --> 00:06:40,075
voy a simplemente registrar esta información.

89
00:06:40,075 --> 00:06:48,570
Así que voy a decir, registro de la consola e insertarlo.

90
00:06:48,570 --> 00:06:55,375
Por lo tanto, esta información se imprimirá en la pantalla aquí, insertada.

91
00:06:55,375 --> 00:07:00,440
Ahora de nuevo, recuerde los puntos y coma y todo lo que

92
00:07:00,440 --> 00:07:05,120
es importante no los olvide cuando esté escribiendo su código.

93
00:07:05,120 --> 00:07:07,930
Entonces, diré resultado insertado.

94
00:07:07,930 --> 00:07:12,165
Este objeto de resultado que se devuelve,

95
00:07:12,165 --> 00:07:15,785
tendrá en él una propiedad llamada propiedad result,

96
00:07:15,785 --> 00:07:20,270
y esta propiedad contendrá un valor.

97
00:07:20,270 --> 00:07:23,600
Esta propiedad de resultado es también un objeto JavaScript,

98
00:07:23,600 --> 00:07:31,395
y esto contendrá una propiedad n que nos indica cuántos documentos se han insertado.

99
00:07:31,395 --> 00:07:36,875
Así que esa es la información que voy a imprimir aquí,

100
00:07:36,875 --> 00:07:39,540
y luego iremos a la siguiente línea y

101
00:07:39,540 --> 00:07:50,750
decimos «documentos en la colección».

102
00:07:53,070 --> 00:08:02,040
Ahora, esta es solo una forma de informar al usuario que esta operación se llevó a cabo correctamente,

103
00:08:02,040 --> 00:08:10,135
y luego pasarán ese resultado a nuestra función de llamada.

104
00:08:10,135 --> 00:08:15,330
Por lo tanto, llamaremos a la devolución de llamada y luego el resultado será el parámetro de la devolución de llamada.

105
00:08:15,330 --> 00:08:21,595
Por lo tanto, cuando implementemos el uso de esta función en nuestro archivo index.js,

106
00:08:21,595 --> 00:08:23,930
vamos a proporcionar la devolución de llamada allí que

107
00:08:23,930 --> 00:08:26,880
recibirá el resultado como el parámetro entrante.

108
00:08:26,880 --> 00:08:30,670
Por lo tanto, esto es para el «InsertDocument».

109
00:08:30,670 --> 00:08:33,010
Ahora, para el «FindDocument

110
00:08:33,010 --> 00:08:36,750
», lo que voy a hacer es decir,

111
00:08:37,010 --> 00:08:41,640
«coll.find» y voy a encontrar todos los documentos.

112
00:08:41,640 --> 00:08:44,810
Entonces, es por eso que daré un objeto JavaScript vacío aquí,

113
00:08:44,810 --> 00:08:51,040
que coincidirá con todos los documentos de la colección y luego diré,

114
00:08:51,040 --> 00:09:01,820
«ToArray» y esto tomará como parámetro una función de devolución de llamada,

115
00:09:02,220 --> 00:09:06,505
y dentro de esta función de devolución de llamada, por supuesto,

116
00:09:06,505 --> 00:09:11,710
afirmaré que esto no es nulo,

117
00:09:11,710 --> 00:09:20,590
y luego diremos, «documentos de devolución de llamada».

118
00:09:20,590 --> 00:09:27,440
Simplemente pasaremos de nuevo los documentos recuperados a la función de llamada.

119
00:09:28,200 --> 00:09:37,750
Ahora, para el «RemoveDocument», voy a decir, «colección DeleteOne».

120
00:09:37,750 --> 00:09:40,270
Por lo tanto, trataré de encontrar el primer documento que

121
00:09:40,270 --> 00:09:45,130
coincida con lo que hemos especificado y luego eliminarlo.

122
00:09:45,130 --> 00:09:47,070
Y luego esto tomará, de nuevo,

123
00:09:47,070 --> 00:09:50,380
una función de devolución de llamada como segundo parámetro,

124
00:09:50,380 --> 00:09:52,685
y dentro de esta función de devolución de llamada,

125
00:09:52,685 --> 00:09:58,160
lo primero que verifico es asegurarme de que el error no sea nulo.

126
00:09:58,160 --> 00:10:01,820
Y luego, después de eso, diremos,

127
00:10:02,130 --> 00:10:20,890
«registro de la consola eliminó el documento con coma».

128
00:10:20,890 --> 00:10:24,840
Usamos la coma aquí porque este es un objeto JavaScript por lo que,

129
00:10:24,840 --> 00:10:26,890
si especifica el registro de la consola como este,

130
00:10:26,890 --> 00:10:30,360
el documento se imprimirá y luego pasaremos

131
00:10:30,360 --> 00:10:36,705
ese resultado a través de la función de devolución de llamada.

132
00:10:36,705 --> 00:10:47,550
Y luego, finalmente, para la actualización vamos a Coll.UpdateOne.

133
00:10:47,670 --> 00:10:52,255
Este es un método que admite el controlador MongoDB.

134
00:10:52,255 --> 00:10:56,560
Por lo tanto, voy a decir, «Update.One document,

135
00:10:56,560 --> 00:11:01,480
" y el segundo parámetro es donde

136
00:11:01,480 --> 00:11:06,960
vamos a pasar en los campos que necesitan ser actualizados.

137
00:11:06,960 --> 00:11:08,915
Y la forma en que se hace,

138
00:11:08,915 --> 00:11:12,810
diremos, «actualización de colon conjunto de dólares».

139
00:11:12,810 --> 00:11:16,100
Por lo tanto, esto tomará la información de actualización que

140
00:11:16,100 --> 00:11:19,120
estoy enviando y luego la pasará a Update.one.

141
00:11:19,120 --> 00:11:21,620
El primero es el documento que debe actualizarse.

142
00:11:21,620 --> 00:11:25,425
El segundo es qué campos del documento deben actualizarse aquí.

143
00:11:25,425 --> 00:11:28,660
Y el tercer parámetro es nulo,

144
00:11:28,770 --> 00:11:36,305
y ese último parámetro es una función de devolución de llamada,

145
00:11:36,305 --> 00:11:45,660
que obviamente nos dará el resultado de la operación.

146
00:11:45,660 --> 00:11:51,125
Entonces, lo primero que voy a verificar para asegurarme de que el error no sea nulo.

147
00:11:51,125 --> 00:11:59,535
Luego, haré un «registro de consola actualizado el documento con».

148
00:11:59,535 --> 00:12:03,195
Ahora, de nuevo, los registros de la consola son puramente para nosotros para

149
00:12:03,195 --> 00:12:07,920
garantizar que el código está haciendo lo que está haciendo.

150
00:12:07,920 --> 00:12:09,690
No ayuda de ninguna manera.

151
00:12:09,690 --> 00:12:11,995
Esto es sólo para nuestra propia información.

152
00:12:11,995 --> 00:12:15,070
En un servidor de producción,

153
00:12:15,070 --> 00:12:18,570
tal vez no tendría estos registros de consola.

154
00:12:18,570 --> 00:12:24,220
Puedes desactivarlos. Así que, eso es todo.

155
00:12:24,220 --> 00:12:32,370
Así que cuatro métodos que se soportan en este módulo de nodo basado en archivos en particular insertar,

156
00:12:32,370 --> 00:12:35,040
encontrar, eliminar y actualizar.

157
00:12:35,040 --> 00:12:38,490
Entonces, ahora que hemos implementado este módulo de nodo basado en archivos,

158
00:12:38,490 --> 00:12:41,185
vamos al archivo index.js,

159
00:12:41,185 --> 00:12:45,985
y luego para hacer uso de ese módulo de nodo basado en archivos,

160
00:12:45,985 --> 00:12:48,010
necesito requerir esto aquí.

161
00:12:48,010 --> 00:12:53,969
Así que, voy a decir, «Const dboper requiere».

162
00:12:53,969 --> 00:13:00,155
Dado que este es un módulo de nodo basado en archivos, obtiene la ruta completa al módulo de nodo,

163
00:13:00,155 --> 00:13:03,865
y que en este caso sucede que lo es. /operations

164
00:13:03,865 --> 00:13:09,760
porque está en la misma carpeta que mi archivo index.js.

165
00:13:09,760 --> 00:13:12,400
Ahora, una vez que hayamos hecho esto,

166
00:13:12,400 --> 00:13:19,570
entonces justo aquí, esta función,

167
00:13:19,570 --> 00:13:24,355
este código que estábamos haciendo para acceder a la base de datos ahora insertar,

168
00:13:24,355 --> 00:13:32,430
vamos a usar el dboper que acabamos de implementar para acceder a esa base de datos.

169
00:13:32,430 --> 00:13:36,280
Entonces, diremos, «dboper insert document

170
00:13:36,280 --> 00:13:40,345
», y este «insert document» toma el db como el primer parámetro.

171
00:13:40,345 --> 00:13:45,015
El db aquí, es este db que entró cuando llamamos a MongoClient connect.

172
00:13:45,015 --> 00:13:48,010
Para que se pase db, de modo que de esa manera,

173
00:13:48,010 --> 00:13:53,805
mi módulo de nodo de operaciones sabe dónde acceder a la base de datos.

174
00:13:53,805 --> 00:13:59,325
Entonces el segundo parámetro es el,

175
00:13:59,325 --> 00:14:03,950
por lo que si miras el «documento de inserción» verás

176
00:14:03,950 --> 00:14:08,055
que el segundo parámetro es el documento que se va a insertar.

177
00:14:08,055 --> 00:14:10,850
Así que, voy a decir, «nombre. «

178
00:14:11,640 --> 00:14:21,680
Solo voy a construir un objeto JSON o un objeto JavaScript aquí,

179
00:14:21,680 --> 00:14:27,315
que se asignará automáticamente al objeto adyacente cuando se inserte.

180
00:14:27,315 --> 00:14:30,135
Y el tercer parámetro, como puede ver,

181
00:14:30,135 --> 00:14:32,790
«colección de documentos db y devolución de llamada.»

182
00:14:32,790 --> 00:14:36,690
Así que el tercer parámetro es la colección y la colección es

183
00:14:36,690 --> 00:14:42,855
la colección de platos y el final es la devolución de llamada.

184
00:14:42,855 --> 00:14:48,605
La llamada de nuevo a medida que recuerde recibe el resultado.

185
00:14:48,605 --> 00:14:52,710
Si mira hacia atrás en el bebé implementó el documento de inserción,

186
00:14:52,710 --> 00:14:55,245
la devolución de llamada recibió el resultado como parámetro.

187
00:14:55,245 --> 00:15:00,305
Entonces, dentro de esta devolución de llamada, manejaremos ese valor de resultado aquí.

188
00:15:00,305 --> 00:15:07,000
Entonces, cuando llegue el valor del resultado, haremos un console.log.

189
00:15:07,390 --> 00:15:12,750
Vamos a decir insertar

190
00:15:13,240 --> 00:15:20,565
barra invertida del documento N y vamos a decir resultados OPS.

191
00:15:20,565 --> 00:15:24,760
El OPS le indica el número de operaciones de inserción que se llevaron a cabo.

192
00:15:24,760 --> 00:15:28,680
Entonces, este es otro objeto que va a estar en el

193
00:15:28,680 --> 00:15:31,790
objeto JavaScript resultado que se pasa

194
00:15:31,790 --> 00:15:34,650
de nuevo como parámetro y así que solo voy a imprimir ese valor.

195
00:15:34,650 --> 00:15:38,260
Así que eso nos dará alguna información sobre lo que ha sucedido.

196
00:15:38,260 --> 00:15:40,610
Ahora, una vez que esto se complete,

197
00:15:40,610 --> 00:15:45,880
dentro de esta función de devolución de llamada voy a llamar a la siguiente operación de base de datos.

198
00:15:45,880 --> 00:15:50,730
Así que voy a decir dboper y luego encontrar los documentos.

199
00:15:50,730 --> 00:16:00,260
Luego diré dbservers y el tercer parámetro es docs,

200
00:16:00,260 --> 00:16:03,090
que es la función de devolución de llamada.

201
00:16:03,090 --> 00:16:06,100
Cuando reciba los documentos, voy a hacer un

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

203
00:16:16,170 --> 00:16:22,140
y simplemente bloquearemos los documentos en la pantalla.

204
00:16:22,140 --> 00:16:25,075
Por lo tanto, esto imprimirá los documentos encontrados.

205
00:16:25,075 --> 00:16:28,470
Tenga en cuenta que esta llamada está dentro de

206
00:16:28,470 --> 00:16:37,480
la función de devolución de llamada que se aplica para la llamada a función anterior,

207
00:16:37,480 --> 00:16:41,225
por lo que es algo que quiero que note específicamente.

208
00:16:41,225 --> 00:16:46,290
Ahora, de nuevo dentro de esta llamada de función necesitan hacerlo de esta manera porque hasta que

209
00:16:46,290 --> 00:16:52,185
se llame a esta devolución de llamada no podemos hacer la siguiente operación.

210
00:16:52,185 --> 00:16:58,855
Entonces, en la próxima operación voy a actualizar el documento que acabo de insertar.

211
00:16:58,855 --> 00:17:03,990
Así que diré que actualice el documento y diré Actualizar Document DB,

212
00:17:03,990 --> 00:17:07,880
y luego el siguiente parámetro es el documento

213
00:17:07,880 --> 00:17:11,800
y no necesito especificar todo el documento, solo puedo especificar un campo y

214
00:17:11,800 --> 00:17:20,740
luego encontrará el documento que coincida con este campo en particular.

215
00:17:21,960 --> 00:17:27,690
Lo que voy a hacer es que el siguiente parámetro es la actualización que necesita ser suministrada.

216
00:17:27,690 --> 00:17:30,770
Entonces, la actualización es qué campo quiero actualizar,

217
00:17:30,770 --> 00:17:35,350
así que voy a actualizar

218
00:17:35,350 --> 00:17:42,050
el campo de descripción diciendo Prueba actualizada,

219
00:17:43,030 --> 00:17:48,475
y luego la cuarta es la colección que es Platos,

220
00:17:48,475 --> 00:17:53,820
y la última es la función de devolución de llamada que obtiene

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

222
00:18:01,110 --> 00:18:08,705
más bien resultado de la operación de actualización que acabamos de llevar a cabo.

223
00:18:08,705 --> 00:18:11,890
Luego, dentro de esta función de devolución de llamada,

224
00:18:11,890 --> 00:18:20,845
voy a volver a hacer un console.log diciendo

225
00:18:20,845 --> 00:18:31,050
barra invertida del documento actualizado N. El documento actualizado se pasará de

226
00:18:31,050 --> 00:18:38,125
nuevo en result.result en

227
00:18:38,125 --> 00:18:43,115
esta propiedad del objeto resultado que se pasa el seguimiento.

228
00:18:43,115 --> 00:18:49,044
Nuevamente observe cómo las llamadas se anidan

229
00:18:49,044 --> 00:18:54,585
dentro de las funciones de devolución de llamada aquí.

230
00:18:54,585 --> 00:18:57,880
Quiero que note esta estructura del código

231
00:18:57,880 --> 00:19:03,130
específicamente porque eso es a lo que voy a volver en el próximo ejercicio.

232
00:19:03,130 --> 00:19:05,760
Ahora, después de hacer eso,

233
00:19:05,760 --> 00:19:07,529
voy a encontrar los documentos,

234
00:19:07,529 --> 00:19:12,930
así que déjame copiar eso y luego voy a usar el mismo código aquí.

235
00:19:13,840 --> 00:19:19,530
Así que voy a decir, encontrar documentos.

236
00:19:20,000 --> 00:19:27,695
Dentro de aquí voy a decir de nuevo, encontrado documento actualizado.

237
00:19:27,695 --> 00:19:30,375
Entonces, finalmente, cuando termine con esto,

238
00:19:30,375 --> 00:19:35,855
simplemente llamaré a db drop collection.

239
00:19:35,855 --> 00:19:38,760
Así que voy a eliminar esta colección de platos para que

240
00:19:38,760 --> 00:19:41,630
limpie mi base de datos para que no tenga

241
00:19:41,630 --> 00:19:44,350
nada más porque para el próximo ejercicio quiero limpiar

242
00:19:44,350 --> 00:19:47,230
la base de datos y luego comenzar con una base de datos más limpia.

243
00:19:47,230 --> 00:19:48,835
Por lo tanto, voy a limpiar

244
00:19:48,835 --> 00:19:57,770
la colección de platos y esto daría como resultado una devolución de llamada.

245
00:19:59,110 --> 00:20:07,410
Así que dentro de aquí voy a hacer un console.log diciendo,

246
00:20:07,410 --> 00:20:17,000
colección abandonada, y luego simplemente imprimiré el resultado que entró.

247
00:20:17,820 --> 00:20:25,250
Luego, finalmente, cierre la base de datos.

248
00:20:25,650 --> 00:20:28,895
Tenga en cuenta que la estructura del código, el

249
00:20:28,895 --> 00:20:34,580
documento de inserción de DB y dentro de la función de devolución de llamada voy a llamar a

250
00:20:34,580 --> 00:20:37,690
la siguiente función y dentro de

251
00:20:37,690 --> 00:20:39,660
la devolución de llamada apagado que voy a llamar a

252
00:20:39,660 --> 00:20:42,270
la siguiente función y dentro de la siguiente función de devolución de llamada y así sucesivamente.

253
00:20:42,270 --> 00:20:46,990
Por lo tanto, puede ver un conjunto anidado de devoluciones de llamada aquí y

254
00:20:46,990 --> 00:20:52,665
un conjunto anidado estructurado de árbol de devoluciones de llamada aquí.

255
00:20:52,665 --> 00:20:56,505
Eso es algo a lo que quiero que prestes atención.

256
00:20:56,505 --> 00:21:02,680
Vamos a guardar los cambios y vamos a ver esta versión de nuestra aplicación.

257
00:21:02,680 --> 00:21:04,725
Volviendo a la terminal,

258
00:21:04,725 --> 00:21:08,045
déjame ejecutar la aplicación.

259
00:21:08,045 --> 00:21:13,035
Así que déjame escribir inicio de NPM y veremos ese resultado.

260
00:21:13,035 --> 00:21:19,060
Ahora, a partir de este resultado se puede ver que el documento se

261
00:21:19,060 --> 00:21:25,330
inserta en la colección y que es el documento que se ha encontrado.

262
00:21:25,330 --> 00:21:26,990
En el segundo paso,

263
00:21:26,990 --> 00:21:31,540
estamos encontrando el documento por lo que cuando llamamos al documento de búsqueda de base de datos,

264
00:21:31,540 --> 00:21:36,175
este es el documento que se recupera de mi colección.

265
00:21:36,175 --> 00:21:39,010
Luego le pido que actualice el documento con

266
00:21:39,010 --> 00:21:42,915
esto y luego notará que dice documento actualizado y luego

267
00:21:42,915 --> 00:21:46,850
aquí imprime el resultado u OPS y dice que N es igual a

268
00:21:46,850 --> 00:21:51,775
un número modificado como uno y estaba bien.

269
00:21:51,775 --> 00:21:57,010
Luego imprime el documento actualizado,

270
00:21:57,010 --> 00:22:02,020
encontramos el documento actualizado aquí y eso es lo que se imprime aquí,

271
00:22:02,020 --> 00:22:05,770
y observa en particular que la descripción ha sido actualizada.

272
00:22:05,770 --> 00:22:09,390
Luego, finalmente, dejó caer la colección.

273
00:22:09,990 --> 00:22:16,690
Así que vemos cómo se ejecuta esta aplicación y es capaz de hacer uso

274
00:22:16,690 --> 00:22:23,410
del módulo de nodo que implementamos y luego realizamos varias operaciones de base de datos.

275
00:22:23,410 --> 00:22:26,560
Con esto completamos este ejercicio.

276
00:22:26,560 --> 00:22:31,520
En este ejercicio le he demostrado cómo interactuaría con

277
00:22:31,520 --> 00:22:37,085
su servidor MongoDB desde su aplicación de nodo.

278
00:22:37,085 --> 00:22:43,455
Hemos implementado nuestro propio módulo de nodo aquí y luego lo usamos

279
00:22:43,455 --> 00:22:46,810
dentro de nuestra aplicación de nodo encapsulando

280
00:22:46,810 --> 00:22:50,965
algunas de las operaciones de base de datos en ese módulo de nodo.

281
00:22:50,965 --> 00:22:54,020
Este es un buen momento para que hagas una confirmación de Git con

282
00:22:54,020 --> 00:22:58,860
el nodo de mensaje MongoDB ejemplo parte dos.