Ahora que hemos tenido una rápida visión general de Mangoose ODM y
cómo Mangoose trae esquemas para estructurar los documentos que almacenamos en nuestro MongoDB,
veamos cómo hacemos uso
del módulo de nodo de mangosta y luego lo incorporamos a nuestra aplicación de nodo.
Luego use Mangosta para comunicarse con
nuestro servidor MongoDB y luego almacenar y recuperar
documentos con información de estructura en los documentos.
Para comenzar a realizar este ejercicio,
vaya a una ubicación conveniente en su computadora.
Entonces, aquí estoy en la carpeta Node JS donde he estado almacenando
todos los ejemplos de este curso y luego voy a
crear una nueva carpeta llamada nodo Mangoose.
Aquí es donde vamos a crear la aplicación de nodo usando Mangoose siguiente.
En el terminal o la ventana de comandos,
mueva a la carpeta Mangoose nodo y luego inicialice una aplicación de nodo allí.
Entonces, déjame escribir npm init y luego
inicializar la aplicación del nodo y luego nombraría la aplicación
como node-mangosta y el punto de entrada es index.js git history,
palabras clave, autor y licencia y diremos que está bien.
Una vez creado el archivo package.json del nodo,
abra el proyecto en el editor de texto de su elección.
Entonces, aquí tengo mi proyecto abierto en Visual Studio.
Permítanme entrar en el archivo package.json y luego agregar
el script de inicio y luego
diremos índice de nodo de inicio como de costumbre cada vez que comenzemos con una nueva aplicación de nodo.
Luego, yendo a la terminal o a la ventana de comando, instalemos Mangoose.
Por lo tanto, en el símbolo del sistema, escriba npm install Mangosta, guarde.
Que en este momento es Mangosta 5.1.7.
Por lo tanto, estas son las versiones que voy a usar en este curso.
Luego voy a mi aplicación en el editor.
Permítanme crear una subcarpeta en el proyecto llamada como Modelos.
Entonces, aquí es donde voy a almacenar todos los modelos para mi aplicación.
En la carpeta de modelos,
permítanme crear un nuevo archivo llamado dishes.js.
Entonces, aquí es donde voy a crear el esquema y el modelo
de mis platos documento que voy a almacenar,
la colección de platos que almacena los documentos para cada plato.
Así que, justo ahí, déjame primero importar Mangosta.
Por lo tanto, vamos a requerir mangosta en este archivo y luego decir
const esquema es el esquema de mangosta.
A continuación, crearemos el esquema aquí.
Por lo tanto, vamos a decir const DishSchema nuevo esquema.
Entonces, aquí es donde defino el esquema para mi plato.
Dentro de este esquema, permítanme definir los diversos valores.
Entonces, diré nombre,
que es el tipo String.
Por lo tanto, este es el tipo de esquema y luego esto lo declararía según sea necesario.
Así que, voy a decir verdad.
Por lo tanto, cada documento tendrá el nombre como un campo obligatorio allí y luego
también declararé esto como un significado único de que
no hay dos documentos que tengan el mismo campo de nombre allí.
Por lo tanto, ese es el primer campo de mi documento.
Luego, también incluiremos otro campo llamado como, descripción.
La descripción es del tipo string y se requiere true.
Además, podemos hacer que Mongoose inserte automáticamente
marcas de tiempo en nuestro modelo.
Así que, justo ahí podemos configurar las marcas de tiempo de la bandera: true.
Por lo tanto, esto agregará automáticamente el creado en y actualizado en,
dos marcas de tiempo en cada documento que se almacena
en nuestra aplicación y actualizará automáticamente estos valores.
Cada vez que actualicemos el documento y el creado en se
inicializará automáticamente cuando el documento sea el primer creador de este tiempo.
Después de esto, diremos platos var.
Por lo tanto, dado el esquema,
ahora vamos a construir el modelo a partir de este esquema.
Por lo tanto, diremos modelo y plato de mangosta,
y esto va a ser usando el esquema de plato que acabamos de declarar antes.
A continuación, vamos a exportar
este modelo desde este archivo aquí.
Por lo tanto, diremos platos de exportación de módulos.
Por lo tanto, ahora hemos construido
el esquema Mangosta y el modelo correspondiente y el modelo ahora se exporta desde aquí.
Por lo tanto, esto se puede importar en nuestra aplicación y usar.
Entonces, dentro de nuestra carpeta de proyecto,
permítanme crear un nuevo archivo llamado index.js.
En el archivo index.js,
permítanme primero requerir Mangosta,
y luego después de esto podemos decir que los
platos const requieren modelos de platos.
Porque ya hemos creado el modelo de platos en
el archivo de platos de modelos allí y luego lo estamos requiriendo aquí.
Ahora, para establecer la conexión con el servidor Mongo,
diremos const URL mongodb.
Localhost 27017, Confusión.
Por lo tanto, esta base de datos es la que nos conectaremos desde nuestra aplicación y
luego podremos establecer la conexión diciendo const connect Mangoose.
Mangoose admite este método de conexión,
que toma la URL como primer parámetro.
Así que una vez que hemos establecido esto,
entonces simplemente decimos conectar entonces.
Tenga en cuenta que como ya estamos usando promesas,
podemos decir conectar entonces y luego esto tomará
una función como parámetro
y dentro de aquí ahora podemos conectarnos a la base de datos.
Así que ahora, una vez que se establece esta conexión,
permítanme hacer un registro de consola
diciendo conectado correctamente al servidor,
y aquí puedo crear un
nuevo plato diciendo var nuevo plato y luego platos y dentro de aquí puedo especificar un documento así que estoy creando
un nuevo plato de este tipo y luego así aquí Voy a
especificar los dos campos que son obligatorios.
Así que voy a decir nombre,
descripción y así es como se crearía un nuevo plato y luego una vez que creamos
un nuevo plato a partir del modelo simplemente vamos a decir nuevo plato guardar.
El método de
guardado hará que este valor de Dish se guarde y luego, como esperas, devolverá una promesa y
luego aquí obtendremos el valor de Dish como llamada de vuelta allí y luego,
simplemente puedo registrar el valor de Dish aquí y luego, después de eso, diremos que los
platos encuentran y así encontraremos
todos los Platos y luego decir exec.
El ejecutivo se asegurará de que esto se
ejecute y que devuelva una promesa y por lo que
se devolverá esa promesa para que luego pueda
encadenar el método a los restantes.
Así que ves cómo estoy usando promesas y luego estoy invocando el método anterior para que este
encuentre todos los Platos dentro de mi base de datos,
en la colección Platos y luego lo ponga a mi disposición.
Así que cuando obtenga los Platos, entonces puedo simplemente registrar los Platos solo para ver lo que se
devuelve y esto obviamente en esta etapa debería
devolver este único plato que he insertado en
mi colección de platos y luego diremos que
devuelve platos elimine con
un objeto JavaScript vacío que eliminará todos los platos de
la base de datos y devolverá el cierre de la
conexión de mangosta que cierra la conexión a la base de datos.
Y atrapar cualquier error en este punto.
Así que usaremos la captura y luego el registro de la consola.
Eso es todo. Así que lo que estamos haciendo aquí es que estamos creando el nuevo este plato y luego estamos
guardando el plato y luego estamos encontrando todos los platos de la colección.
Eso es todo. Estamos usando promesas aquí,
así que hemos encadenado todas las guaridas aquí. Eso es todo.
Vamos a guardar los cambios y luego ver esta aplicación ejecutándose.
Vaya a la terminal,
en el indicador escriba npm start y
verá que mi aplicación de nodo se ejecuta y luego muestra,
primero, que ha creado este Dish en particular.
Tenga en cuenta, en particular, que estos dos campos,
actualizados en y creados en,
estas dos marcas de tiempo se han agregado automáticamente en
el plato aquí y por lo que puede ver que el creado en y
actualizado en las marcas de tiempo son exactamente los mismos en este momento y
luego el ID también se agrega automáticamente en.
En el siguiente paso estamos imprimiendo todos los Platos que se han recuperado y así se
puede ver que este único plato está en la colección, la colección de
platos, y eso es lo que se imprime en la pantalla aquí.
Vamos a inicializar el repositorio de Git y luego vamos a configurar el archivo gitignore conseguido
así que vamos al editor, luego creamos el archivo.gitignore y luego agregamos
módulos de nodo al archivo gitignore y guardamos los cambios y
luego volvemos a la solicitud déjame
escribir estado git y vemos que
tenemos estos archivos que no se han registrado, así que diremos
git add y luego git
confirmar el mensaje Mangosta Parte Uno.
Con esto completamos este ejercicio.
En este ejercicio hemos visto lo fácil que es configurar una aplicación de nodo con
mangosta y conectarse a nuestro servidor MongoDB y luego interactuar con él.
Ahora ya que mangosta se basa en el servidor MongoDB,
Mangoose puede acceder a todos los diversos métodos
que son compatibles con el controlador MongoDB también.