1
00:00:03,920 --> 00:00:10,025
Ahora que hemos aprendido sobre el controlador de nodo MongoDB, el módulo de nodo,

2
00:00:10,025 --> 00:00:14,205
que permite a nuestra aplicación de nodo ser capaz de interactuar

3
00:00:14,205 --> 00:00:18,475
con un servidor MongoDB, en este ejercicio,

4
00:00:18,475 --> 00:00:23,430
vamos a utilizar el módulo de nodo y utilizar los diversos métodos que son

5
00:00:23,430 --> 00:00:29,840
compatibles con el módulo de nodo para proporcionar introducción con nuestro servidor MongoDB.

6
00:00:29,840 --> 00:00:33,030
Para empezar, vaya a

7
00:00:33,030 --> 00:00:38,135
la carpeta NodeJS que ha estado usando para almacenar todos sus ejemplos,

8
00:00:38,135 --> 00:00:45,310
y luego cree una nueva carpeta allí llamada node-mongo.

9
00:00:45,320 --> 00:00:48,125
En esta carpeta, vamos a desarrollar

10
00:00:48,125 --> 00:00:52,715
la aplicación NodeJS que interactúa con nuestro servidor MongoDB.

11
00:00:52,715 --> 00:00:57,140
Ahora, asegúrese de que su servidor MongoDB está en funcionamiento,

12
00:00:57,140 --> 00:01:02,675
por lo que en el ejercicio anterior ya hemos visto cómo se puede iniciar nuestro servidor MongoDB.

13
00:01:02,675 --> 00:01:07,370
Por lo tanto, mantenga el servidor MongoDB en funcionamiento y en

14
00:01:07,370 --> 00:01:12,060
otra ventana de terminal o pestaña de terminal o ventana de comandos,

15
00:01:12,060 --> 00:01:15,020
vaya a la carpeta node-mongo que acaba de

16
00:01:15,020 --> 00:01:18,135
crear e inicialice una aplicación de nodo aquí.

17
00:01:18,135 --> 00:01:22,910
Por lo tanto, déjame escribir npm init y

18
00:01:22,910 --> 00:01:29,765
vamos a nombrar la aplicación como Node-Mongo y versión,

19
00:01:29,765 --> 00:01:36,895
descripción Node MongoDB Ejemplo,

20
00:01:36,895 --> 00:01:39,295
y el punto de entrada,

21
00:01:39,295 --> 00:01:48,980
y el autor, al igual que hemos estado llenando los ejercicios anteriores.

22
00:01:48,980 --> 00:01:53,255
Luego, una vez que se haya inicializado el archivo package.json,

23
00:01:53,255 --> 00:01:59,610
abra esto en el editor de su elección.

24
00:01:59,610 --> 00:02:02,635
Ahora entrando en el archivo package.json,

25
00:02:02,635 --> 00:02:09,370
permítanme introducir otro script aquí al igual que hemos estado haciendo antes, así que,

26
00:02:09,370 --> 00:02:16,350
diremos «start»: «index de nodo» y guardaremos los cambios.

27
00:02:16,350 --> 00:02:18,010
Volviendo a la terminal,

28
00:02:18,010 --> 00:02:22,350
instalemos el módulo de nodo MongoDB.

29
00:02:22,350 --> 00:02:30,080
Por lo tanto, escriba npm install mongodb @3 .0.10 —save.

30
00:02:30,080 --> 00:02:33,590
También instalaremos el módulo de nodo assert, así que,

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

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

33
00:02:42,710 --> 00:02:46,720
para verificar la verdad o valores falsos dentro de nuestra aplicación,

34
00:02:46,720 --> 00:02:49,535
y usted me verá usando más adelante.

35
00:02:49,535 --> 00:02:52,645
Ahora que hemos instalado estos módulos de nodo,

36
00:02:52,645 --> 00:02:58,355
vamos a crear nuestra aplicación de nodo que interactúa con el servidor MongoDB.

37
00:02:58,355 --> 00:03:00,455
Volviendo al editor,

38
00:03:00,455 --> 00:03:01,915
en la carpeta del proyecto,

39
00:03:01,915 --> 00:03:05,465
cree un archivo llamado index.js,

40
00:03:05,465 --> 00:03:07,684
y aquí es donde crearemos

41
00:03:07,684 --> 00:03:12,030
la aplicación de nodo que interactúa con nuestro servidor MongoDB.

42
00:03:12,030 --> 00:03:14,425
Entonces, en esta aplicación,

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

44
00:03:18,800 --> 00:03:21,555
y luego dirán,

45
00:03:21,555 --> 00:03:28,160
require (`mongodb`), el módulo de nodo MongoDB que ya hemos instalado,

46
00:03:28,160 --> 00:03:30,335
y luego esto nos proporcionaría

47
00:03:30,335 --> 00:03:38,045
el MongoClient que nos permite conectarnos al servidor MongoDB.

48
00:03:38,045 --> 00:03:47,160
Además, requiere el módulo assert.

49
00:03:48,830 --> 00:03:53,870
Ahora, para iniciar una conexión con el servidor MongoDB,

50
00:03:53,870 --> 00:04:03,590
vamos a crear una URL de nombre constante que será la URL donde se puede

51
00:04:03,590 --> 00:04:08,030
acceder al servidor MongoDB y el acceso del bebé es

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

53
00:04:14,950 --> 00:04:19,360
Recuerde que este es el número de puerto en el que su servidor MongoDB está

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

55
00:04:25,025 --> 00:04:27,205
y luego diremos confusión.

56
00:04:27,205 --> 00:04:28,820
Recordemos que hemos creado

57
00:04:28,820 --> 00:04:34,060
la base de datos Confusion en nuestro servidor MongoDB en el ejercicio anterior

58
00:04:34,060 --> 00:04:39,310
, así que vamos a acceder a esa base de datos ConFusion que hemos creado anteriormente.

59
00:04:39,310 --> 00:04:46,240
Ahora, para acceder al servidor, diremos MongoClient.connect.

60
00:04:48,690 --> 00:04:54,790
Por lo tanto, el método connect nos permite conectarnos al MongoClient desde nuestro servidor MongoDB,

61
00:04:54,790 --> 00:04:59,230
y luego diremos que toma la URL como primer parámetro,

62
00:04:59,230 --> 00:05:02,485
la URL del servidor MongoDB como el primer parámetro.

63
00:05:02,485 --> 00:05:06,590
El segundo parámetro es una función de devolución de llamada.

64
00:05:06,590 --> 00:05:14,275
Por lo tanto, la función de devolución de llamada tiene dos parámetros, el valor de error

65
00:05:14,275 --> 00:05:17,915
, y el cliente, que luego podemos utilizar

66
00:05:17,915 --> 00:05:22,405
para conectar a nuestra base de datos y luego realizar varias operaciones.

67
00:05:22,405 --> 00:05:27,040
Entonces, dentro de esta función de devolución de llamada,

68
00:05:27,040 --> 00:05:36,400
lo primero que haremos es verificar para asegurarnos de que el error no sea nulo.

69
00:05:36,400 --> 00:05:39,740
Por lo tanto, el assert comprobará si el error es igual a nulo,

70
00:05:39,740 --> 00:05:45,640
por lo que la función assert nos permite realizar varias comprobaciones de valores.

71
00:05:45,640 --> 00:05:48,010
Por lo tanto, comprobamos para asegurarnos de que el error no es,

72
00:05:48,010 --> 00:05:49,785
si no es nulo,

73
00:05:49,785 --> 00:05:55,660
entonces eso significa que hay un error y por lo tanto mostraremos el error en la pantalla.

74
00:05:55,660 --> 00:05:59,650
Entonces, ese es el uso de la función assert aquí.

75
00:05:59,650 --> 00:06:03,025
Ahora, si eso no sucede,

76
00:06:03,025 --> 00:06:07,430
entonces eso significa que nos hemos conectado correctamente al servidor,

77
00:06:07,430 --> 00:06:15,170
así que diremos `conectado correctamente al servidor`

78
00:06:15,170 --> 00:06:25,120
const db= client.db (dbname) para conectarse a la base de datos,

79
00:06:25,120 --> 00:06:33,570
entonces podemos decir const collection db. ,

80
00:06:33,570 --> 00:06:38,810
por lo que el db nos proporcionará varios métodos que nos permiten

81
00:06:38,810 --> 00:06:44,380
interactuar con el servidor así que diremos db.collection (`dishes`) Por lo tanto,

82
00:06:44,380 --> 00:06:49,765
intentaremos acceder a la colección de platos dentro de esta base de datos.

83
00:06:49,765 --> 00:06:55,175
Ahora, lo siguiente que vamos a tratar de hacer es

84
00:06:55,175 --> 00:07:04,414
collection.insertone por lo que vamos a tratar de insertar un objeto en la colección,

85
00:07:04,414 --> 00:07:08,360
y este objeto sería con

86
00:07:08,360 --> 00:07:28,510
el nombre y la descripción, «prueba».

87
00:07:28,510 --> 00:07:32,520
Por lo tanto, esta colección proporciona este método llamado

88
00:07:32,520 --> 00:07:36,825
insertOne, que nos permite insertar un documento en esta colección,

89
00:07:36,825 --> 00:07:42,825
y el documento es el primer argumento de este método aquí.

90
00:07:42,825 --> 00:07:49,780
El segundo argumento para el método es una función de devolución de llamada,

91
00:07:49,780 --> 00:07:56,720
y la función de devolución de llamada toma dos parámetros, error y resultado.

92
00:07:58,260 --> 00:08:01,000
Entonces, dentro de esta función de devolución de llamada,

93
00:08:01,000 --> 00:08:03,180
si se obtiene el resultado,

94
00:08:03,180 --> 00:08:08,610
entonces podemos acceder a la colección y luego realizar operaciones adicionales.

95
00:08:08,610 --> 00:08:16,645
Entonces, aquí, lo primero que haremos es verificar para asegurarnos de que el error no sea nulo.

96
00:08:16,645 --> 00:08:19,450
Entonces, haremos una afirmación allí,

97
00:08:19,450 --> 00:08:33,470
y luego aquí podemos decir, «Después de insertar».

98
00:08:37,770 --> 00:08:45,145
Entonces, después de insertar, entonces vemos que

99
00:08:45,145 --> 00:08:51,490
obtenemos el valor de resultado que se devuelve allí, por lo que este resultado.

100
00:08:51,490 --> 00:08:56,070
Este resultado también proporcionará

101
00:08:56,070 --> 00:09:00,805
esta propiedad OPS que dice cuántas operaciones se han llevado a cabo con éxito.

102
00:09:00,805 --> 00:09:02,715
Así que eso es lo que voy a imprimir.

103
00:09:02,715 --> 00:09:05,140
Por lo tanto, dirá que el número insertado es uno.

104
00:09:05,140 --> 00:09:12,030
Por lo tanto, lo que significa que este documento en particular se ha insertado en la base de datos.

105
00:09:12,070 --> 00:09:15,440
Entonces, eso es lo que confirmaremos aquí.

106
00:09:15,440 --> 00:09:19,810
Luego, después de eso, realizaremos otra opción,

107
00:09:19,810 --> 00:09:22,415
una operación en la colección, y

108
00:09:22,415 --> 00:09:30,200
digamos, búsqueda de colección, e intentaremos buscar todos los registros de la colección.

109
00:09:30,200 --> 00:09:37,420
Entonces, aquí, proporcionaremos una cadena JSON vacía o un objeto JavaScript de nivel correspondiente. Por

110
00:09:37,420 --> 00:09:40,895
lo tanto, buscará todo lo que hay en la colección,

111
00:09:40,895 --> 00:09:43,750
y luego, nos proporcionará eso.

112
00:09:43,750 --> 00:09:48,640
Luego, esto se puede convertir en una matriz de objetos JSON. Por

113
00:09:48,640 --> 00:09:52,215
lo tanto, esta es la razón por la que llamamos a ToArray,

114
00:09:52,215 --> 00:09:59,365
y esto toma una función de devolución de llamada como parámetro.

115
00:09:59,365 --> 00:10:07,065
El primer parámetro, por supuesto, es el valor del error, por lo que de nuevo,

116
00:10:07,065 --> 00:10:16,365
comprobamos para asegurarnos de que el error no es nulo.

117
00:10:16,365 --> 00:10:25,990
Luego diremos, console.log encontró,

118
00:10:25,990 --> 00:10:29,140
y luego imprimirá lo que se haya encontrado,

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

120
00:10:32,505 --> 00:10:35,080
Por lo tanto, el segundo parámetro aquí, docs,

121
00:10:35,080 --> 00:10:38,370
devolverá todos los documentos de esta colección

122
00:10:38,370 --> 00:10:42,380
que coincidan con los criterios que especifique aquí.

123
00:10:42,380 --> 00:10:43,970
Dado que esto está vacío,

124
00:10:43,970 --> 00:10:47,535
entonces eso significa que todos los documentos de la colección nos serán devueltos.

125
00:10:47,535 --> 00:10:49,500
Puede especificar un filtro aquí,

126
00:10:49,500 --> 00:10:54,030
diciendo que el nombre es igual a un valor

127
00:10:54,030 --> 00:10:57,325
y, a continuación, sólo se recuperarán los documentos que coincidan con ese valor.

128
00:10:57,325 --> 00:11:04,040
Así que aquí, permítanme imprimir los documentos aquí,

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

130
00:11:07,660 --> 00:11:11,990
sido insertado en la colección y luego será recuperado,

131
00:11:11,990 --> 00:11:15,950
y luego simplemente imprimirlo solo para asegurarnos de que el documento que acabamos de

132
00:11:15,950 --> 00:11:20,590
insertar en la operación anterior está de hecho en la colección,

133
00:11:20,590 --> 00:11:22,420
y así lo imprimiremos aquí.

134
00:11:22,420 --> 00:11:28,060
Ahora, después de esto, entonces usaremos

135
00:11:28,060 --> 00:11:35,880
el método DropCollection aquí.

136
00:11:35,880 --> 00:11:40,560
Por lo tanto, DropCollection eliminará la colección especificada aquí.

137
00:11:40,560 --> 00:11:42,410
Por lo tanto, diremos platos DropCollection,

138
00:11:42,410 --> 00:11:45,820
así que solo voy a eliminar la colección de platos de mi base de datos.

139
00:11:45,820 --> 00:11:48,180
Por lo tanto, solo voy a limpiar la base de datos y luego

140
00:11:48,180 --> 00:11:51,090
dejarla con una base de datos vacía para que podamos ir

141
00:11:51,090 --> 00:11:53,610
al siguiente ejercicio donde podamos volver a

142
00:11:53,610 --> 00:11:57,115
realizar un tipo similar de operaciones para comprobar esto.

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

144
00:12:00,455 --> 00:12:06,815
una función de devolución de llamada que devuelve un error o un resultado.

145
00:12:06,815 --> 00:12:16,040
Dentro de esto, verificaremos y aseguraremos que la afirmación no sea nula,

146
00:12:16,440 --> 00:12:20,780
y luego diremos, client.close.

147
00:12:20,780 --> 00:12:25,425
Así que cerraremos la conexión a la base de datos en el acto.

148
00:12:25,425 --> 00:12:34,465
Así que con esto, este sencillo conjunto de métodos nos permite interactuar con nuestro servidor,

149
00:12:34,465 --> 00:12:41,150
y también nos demuestra cómo podemos comunicarnos con el servidor usando

150
00:12:41,150 --> 00:12:48,185
los métodos que están disponibles a través de este módulo de nodo MongoDB o el controlador MongoDB.

151
00:12:48,185 --> 00:12:51,900
Entonces, aquí, ves que primero realizamos una operación de inserción.

152
00:12:51,900 --> 00:12:54,875
Luego, después de la operación de inserción, tenga en cuenta que,

153
00:12:54,875 --> 00:12:59,715
estamos haciendo la segunda operación dentro de la función de devolución de llamada.

154
00:12:59,715 --> 00:13:07,490
Por lo tanto, esto garantiza que esta operación se haya completado antes de hacer la siguiente.

155
00:13:07,490 --> 00:13:15,680
Entonces, esta es una segunda llamada que está encerrada dentro de la primera función de devolución de llamada,

156
00:13:15,680 --> 00:13:19,470
y luego correspondientemente, dentro de eso.

157
00:13:19,470 --> 00:13:24,370
Estamos llamando de nuevo a los métodos aquí y dentro de allí.

158
00:13:24,370 --> 00:13:28,080
Entonces, ves que hay un anidamiento de estas llamadas,

159
00:13:28,080 --> 00:13:29,435
una dentro de la otra.

160
00:13:29,435 --> 00:13:32,200
Tenga en cuenta la estructura porque voy a volver a

161
00:13:32,200 --> 00:13:35,755
explicar algo sobre esto en uno de los ejercicios posteriores.

162
00:13:35,755 --> 00:13:40,235
Por lo tanto, tenga en cuenta que, la anidación de estas llamadas una dentro de la otra.

163
00:13:40,235 --> 00:13:43,020
Vamos a guardar los cambios,

164
00:13:43,210 --> 00:13:49,330
y luego ver qué hace esta aplicación cuando la ejecutamos.

165
00:13:49,330 --> 00:13:51,685
Volviendo a la terminal, de nuevo,

166
00:13:51,685 --> 00:13:55,170
asegúrese de que su servidor MongoDB está en funcionamiento y, por

167
00:13:55,170 --> 00:14:00,560
lo tanto, cuando se esté ejecutando, va a imprimir muchos mensajes de registro en la consola.

168
00:14:00,560 --> 00:14:04,230
Podemos ignorar esos mensajes de registro por ahora.

169
00:14:04,230 --> 00:14:06,710
Vamos a ejecutar la aplicación de nodo.

170
00:14:06,710 --> 00:14:09,330
Por lo tanto, diremos, npm start,

171
00:14:09,330 --> 00:14:12,095
y cuando se ejecuta la aplicación de nodo,

172
00:14:12,095 --> 00:14:14,875
notará lo que hace la aplicación de nodo está haciendo.

173
00:14:14,875 --> 00:14:19,705
Así que dice, conectado correctamente al servidor, Después de Insertar,

174
00:14:19,705 --> 00:14:22,260
entonces muestra que

175
00:14:22,260 --> 00:14:28,375
este documento en particular se ha insertado en nuestro MongoDB y el nodo en particular,

176
00:14:28,375 --> 00:14:29,540
el ID dado aquí.

177
00:14:29,540 --> 00:14:32,570
Por lo tanto, observe que esto no dice que se trata de un ID de objeto.

178
00:14:32,570 --> 00:14:35,995
Este ID es insertado automáticamente por

179
00:14:35,995 --> 00:14:39,730
el controlador de nodo Mongo en su documento

180
00:14:39,730 --> 00:14:43,745
cuando intenta insertarlo en el servidor MongoDB aquí.

181
00:14:43,745 --> 00:14:48,950
Este formato es exactamente el mismo que el ID de objeto que hemos visto.

182
00:14:48,950 --> 00:14:53,910
A partir de entonces, realizamos una operación de hallazgo.

183
00:14:53,910 --> 00:14:55,560
Entonces, esto se encuentra,

184
00:14:55,560 --> 00:14:58,710
y luego imprime este artículo aquí.

185
00:14:58,710 --> 00:15:01,550
Obsérvese que en el ejercicio anterior

186
00:15:01,550 --> 00:15:08,470
habíamos sobrado en el documento anterior que habíamos insertado en el ejercicio anterior.

187
00:15:08,470 --> 00:15:11,005
Por lo tanto, eso todavía se ve en la colección aquí,

188
00:15:11,005 --> 00:15:13,500
y el nuevo documento que acabamos de insertar aquí.

189
00:15:13,500 --> 00:15:17,179
Este documento se ve justo debajo de eso aquí,

190
00:15:17,179 --> 00:15:20,510
pero tenga en cuenta que estos dos tienen dos ID diferentes.

191
00:15:20,510 --> 00:15:25,030
Este ID coincide con el ID del documento que acabamos de insertar.

192
00:15:25,030 --> 00:15:28,455
Entonces, esto es lo que sobra del ejercicio anterior.

193
00:15:28,455 --> 00:15:32,765
Después de esto, por supuesto dejamos la colección para que

194
00:15:32,765 --> 00:15:38,060
todo este conjunto de documentos y la colección de platos se eliminen de nuestra base de datos.

195
00:15:38,060 --> 00:15:41,060
Por lo tanto, ahora nuestra base de datos estará limpia y vacía.

196
00:15:41,060 --> 00:15:44,930
Por lo tanto, eso demuestra a usted cómo podemos usar

197
00:15:44,930 --> 00:15:52,900
el controlador MongoDB para comunicarse desde nuestra aplicación de nodo con el servidor.

198
00:15:52,900 --> 00:15:55,330
Ahora que tenemos nuestra aplicación,

199
00:15:55,330 --> 00:16:01,000
permítanme presentar una.gitignore

200
00:16:01,000 --> 00:16:06,720
aquí y luego poner módulos de nodo en el.gitignore,

201
00:16:06,720 --> 00:16:10,540
y entienden rápidamente por qué estoy haciendo esto.

202
00:16:10,540 --> 00:16:16,595
Luego, regresaremos e inicializaremos el repositorio de Git y luego haremos una confirmación de git.

203
00:16:16,595 --> 00:16:18,590
Volviendo a la terminal,

204
00:16:18,590 --> 00:16:21,505
permítanme inicializar el repositorio de Git

205
00:16:21,505 --> 00:16:31,460
, y luego, comprobemos el estado de Git y veamos que hay algunos archivos no confirmados.

206
00:16:31,460 --> 00:16:37,204
Así que déjame registrarlos y luego hacer una confirmación de git con el mensaje,

207
00:16:37,204 --> 00:16:46,450
Node MongoDB Ejemplo uno.

208
00:16:46,450 --> 00:16:49,305
Esta es la primera parte del ejercicio,

209
00:16:49,305 --> 00:16:54,020
así que solo verificaremos los elementos en nuestro repositorio git.

210
00:16:54,020 --> 00:16:56,900
Esto completa este ejercicio.

211
00:16:56,900 --> 00:17:01,760
En este ejercicio, hemos visto cómo instalamos el módulo de nodo,

212
00:17:01,760 --> 00:17:04,365
el controlador MongoDB, entonces,

213
00:17:04,365 --> 00:17:07,835
pudimos comunicarnos con nuestro servidor MongoDB desde dentro de

214
00:17:07,835 --> 00:17:12,740
nuestra aplicación de nodo utilizando los métodos proporcionados por el controlador MongoDB.

215
00:17:12,740 --> 00:17:17,840
Continuaremos con este ejercicio en la siguiente parte

216
00:17:17,840 --> 00:17:24,380
del ejercicio donde exploraremos algunos métodos más del controlador MongoDB.