Mangosta 101

Mongoose es una biblioteca que hace que MongoDB sea más fácil de usar. Hace dos cosas:

  1. Da estructura a las Colecciones MongoDB
  2. Le brinda métodos útiles para usar

En este artículo, aprenderá cómo usar Mongoose en un nivel básico.

requisitos previos

Supongo que has hecho lo siguiente:

  1. Ha instalado MongoDB en su computadora
  2. Sabes cómo configurar una conexión MongoDB local
  3. Sabes ver los datos que tienes en tu base de datos
  4. Ya sabes qué son las “colecciones” en MongoDB

Si no conoces ninguno de estos, por favor lee “Cómo configurar una conexión MongoDB local” antes de continuar.

También asumo que sabe cómo usar MongoDB para crear una aplicación CRUD simple. Si no sabes cómo hacerlo, lee “Cómo construir una aplicación CRUD con Node, Express y MongoDB” antes de continuar.

Conexión a una base de datos

Primero, necesitas descargar Mongoose.

npm install mongoose --save

Puede conectarse a una base de datos con el connect método. Digamos que queremos conectarnos a una base de datos llamada street-fighters. Aquí está el código que necesita:

const mongoose = require('mongoose')
const url="mongodb://127.0.0.1:27017/street-fighters"

mongoose.connect(url, { useNewUrlParser: true })

Queremos saber si nuestra conexión ha tenido éxito o ha fallado. Esto nos ayuda con la depuración.

Para comprobar si la conexión ha tenido éxito, podemos utilizar el open evento. Para verificar si la conexión falló, usamos el error evento.

const db = mongoose.connection
db.once('open', _ => {
  console.log('Database connected:', url)
})

db.on('error', err => {
  console.error('connection error:', err)
})

Intente conectarse a la base de datos. Deberías ver un registro como este:

Conectado a una base de datos.

Crear un modelo

En Mongoose, necesitas usar modelos para crear, leer, actualizar o eliminar elementos de una colección MongoDB.

Para crear un modelo, necesitas crear un esquema. Un esquema le permite** definir la estructura de una entrada** en la colección. Esta entrada también se denomina documento.

Así es como se crea un esquema:

const mongoose = require('mongoose')
const Schema = mongoose.Schema

const schema = new Schema({
  // ...
})

Puedes usar 10 tipos diferentes de valores en un Esquema. La mayoría de las veces, usará estos seis:

  • Cuerda
  • Número
  • booleano
  • Formación
  • Fecha
  • ID de objeto

Pongamos esto en práctica.

Digamos que queremos crear personajes para nuestra base de datos de Street Fighter.

En Mongoose, es una práctica normal poner cada modelo en su propio archivo. Así que crearemos un Character.js archivo primero. Este Character.js archivo se colocará en el models carpeta.

project/
    |- models/
        |- Character.js

En Character.jscreamos un characterSchema.

const mongoose = require('mongoose')
const Schema = mongoose.Schema

const characterSchema = new Schema({
  // ...
})

Digamos que queremos guardar dos cosas en la base de datos:

  1. Nombre del personaje
  2. Nombre de su último movimiento.

Ambos se pueden representar con cadenas.

const mongoose = require('mongoose')
const Schema = mongoose.Schema

const characterSchema = new Schema({
  name: String,
  ultimate: String
})

Una vez que hemos creado characterSchemapodemos usar mangosta model método para crear el modelo.

module.exports = mongoose.model('Character', characterSchema)

Creando un personaje

Digamos que tienes un archivo llamado index.js. Aquí es donde realizaremos operaciones Mongoose para este tutorial.

project/
    |- index.js
    |- models/
        |- Character.js

Primero, necesitas cargar el modelo de personaje. Puedes hacer esto con require.

const Character = require('./models/Character')

Digamos que quieres crear un personaje llamado Ryu. Ryu tiene un movimiento definitivo llamado “Shinku Hadoken”.

Para crear Ryu, usas el new, seguido de su modelo. En este caso, es new Character.

const ryu = new Character ({
  name: 'Ryu',
  ultimate: 'Shinku Hadoken'
})

new Character crea el personaje en la memoria. Todavía no se ha guardado en la base de datos. Para guardar en la base de datos, puede ejecutar el save método.

ryu.save(function (error, document) {
  if (error) console.error(error)
  console.log(document)
})

Si ejecuta el código anterior, debería ver esto en la consola.

Ryu guardó en la base de datos.

Promesas y Async/await

Mangosta apoya promesas. Te permite escribir un código más agradable como este:

// This does the same thing as above
function saveCharacter (character) {
  const c = new Character(character)
  return c.save()
}

saveCharacter({
  name: 'Ryu',
  ultimate: 'Shinku Hadoken'
})
  .then(doc => { console.log(doc) })
  .catch(error => { console.error(error) })

También puede utilizar el await palabra clave si tiene una función asíncrona.

Si el código Promise o Async/Await le parece extraño, le recomiendo leer “JavaScript asíncrono y en espera” antes de continuar con este tutorial.

async function runCode() {
  const ryu = new Character({
    name: 'Ryu',
    ultimate: 'Shinku Hadoken'
  })

  const doc = await ryu.save()
  console.log(doc)
}

runCode()
  .catch(error => { console.error(error) })

Nota: Usaré el formato async/await para el resto del tutorial.

Unicidad

Mongoose agrega un nuevo personaje a la base de datos cada vez que usa new Character y save. Si ejecuta los códigos anteriores tres veces, esperaría ver tres Ryus en la base de datos.

Tres Ryus en la base de datos.

No queremos tener tres Ryus en la base de datos. queremos tener UN Ryu solo. Para ello, podemos utilizar el único opción.

const characterSchema = new Schema({
  name: { type: String, unique: true },
  ultimate: String
})

los unique opción crea un índice único. Asegura que no podemos tener dos documentos con el mismo valor (por name en este caso).

Para unique para que funcione correctamente, necesita borrar la colección de personajes. Para borrar la colección de Personajes, puedes usar esto:

await Character.deleteMany({})

Intente agregar dos Ryus a la base de datos ahora. Obtendrás un E11000 duplicate key error. No podrás salvar al segundo Ryu.

Error de clave duplicada.

Agreguemos otro personaje a la base de datos antes de continuar con el resto del tutorial.

const ken = new Character({
  name: 'Ken',
  ultimate: 'Guren Enjinkyaku'
})

await ken.save()

La base de datos contiene dos caracteres.

Recuperando un personaje

Mongoose le ofrece dos métodos para encontrar cosas de MongoDB.

  1. findOne: Obtiene un documento.
  2. find: Obtiene una matriz de documentos

Encuentra uno

findOne devuelve el primer documento encuentra Puede especificar cualquier propiedad para buscar. busquemos Ryu:

const ryu = await Character.findOne({ name: 'Ryu' })
console.log(ryu)

Encontré a Ryu en la base de datos.

encontrar

find devuelve una matriz de documentos Si especifica una propiedad para buscar, devolverá documentos que coincidan con su consulta.

const chars = await Character.find({ name: 'Ryu' })
console.log(chars)

Peinó la base de datos y encontró un personaje con el nombre Ryu.

Si no especificó ninguna propiedad para buscar, devolverá una matriz que contiene todos los documentos de la colección.

const chars = await Character.find()
console.log(chars)

Encontré dos caracteres en la base de datos.

Actualizar un personaje

Digamos que Ryu tiene tres movimientos especiales:

  1. hadoken
  2. Shoryuken
  3. Tatsumaki Senpukyaku

Queremos agregar estos movimientos especiales a la base de datos. Primero, necesitamos actualizar nuestro CharacterSchema.

const characterSchema = new Schema({
  name: { type: String, unique: true },
  specials: Array,
  ultimate: String
})

Luego, usamos una de estas dos formas de actualizar un personaje:

  1. Usar findOneluego usa save
  2. Usar findOneAndUpdate

encuentra uno y guarda

Primero, usamos findOne para conseguir Ryu.

const ryu = await Character.findOne({ name: 'Ryu' })
console.log(ryu)

Luego, actualizamos a Ryu para incluir sus movimientos especiales.

const ryu = await Character.findOne({ name: 'Ryu' })
ryu.specials = [
  'Hadoken',
  'Shoryuken',
  'Tatsumaki Senpukyaku'
]

Después de que modificamos ryucorremos save.

const ryu = await Character.findOne({ name: 'Ryu' })
ryu.specials = [
  'Hadoken',
  'Shoryuken',
  'Tatsumaki Senpukyaku'
]

const doc = await ryu.save()
console.log(doc)

Ryu actualizado.

findOneAndUpdate es lo mismo que el de MongoDB findOneAndModify método.

Aquí, busca a Ryu y pasa los campos que desea actualizar al mismo tiempo.

// Syntax
await findOneAndUpdate(filter, update)
// Usage
const doc = await Character.findOneAndUpdate(
  { name: 'Ryu' },
  {
    specials: [
      'Hadoken',
      'Shoryuken',
      'Tatsumaki Senpukyaku'
    ]
  })

console.log(doc)

Ryu actualizado.

Dos grandes diferencias.

Primero el sintaxis para findOne + save es más fácil de leer que findOneAndUpdate.

Segundo, findOneAndUpdate no desencadena la save software intermedio.

elegiré findOne + save sobre findOneAndUpdate en cualquier momento debido a estas dos diferencias.

Eliminación de un personaje

Hay dos formas de eliminar un carácter:

  1. findOne + remove
  2. findOneAndDelete
const ryu = await Character.findOne({ name: 'Ryu' })
const deleted = await ryu.remove()

Uso de buscar y eliminar

const deleted = await Character.findOneAndDelete({ name: 'Ken' })

Aprendiste a usar Mongoose para:

  1. Conectarse a una base de datos
  2. Crear, leer, actualizar y eliminar documentos

Gracias por leer. Este artículo fue publicado originalmente en mi blog. Matricularse en mi boletín si desea más artículos que lo ayuden a convertirse en un mejor desarrollador frontend.

Similar Posts

Leave a Reply

Your email address will not be published.