Página de inicio > ¿Cuál es el punto de usar save() en Mongoose?

¿Cuál es el punto de usar save() en Mongoose?

Estoy aprendiendo MongoDB y Mongoose, y he visto a los instructores recomendar usar la función save() para guardar los cambios realizados en la base de datos.

Pero sigo haciendo cambios con éxito sin usar save(). Hice dos funciones para agregar un documento a la base de datos, una usando save() y la segunda sin usar save(), y todas hicieron el mismo trabajo.

Entonces, ¿cuál es el punto de usarlo entonces?

NOTA: he ocultado mi cadena de conexión

Mi código:

const express = require('express');
const mongoose = require('mongoose');

//-- Connect to Database --//:
mongoose.connect();

// make Schema & model:
const Person = mongoose.model('Person', new mongoose.Schema({
    name: String,
    age: Number
}));

//-- Interact with Database --//:
async function run1 () {
    const person = await Person.create({name: 'John', age: 25});
    await person.save();
    console.log(person);
}

async function run2 () {
    const person = await Person.create({name: 'Sally', age: 40});
    console.log(person);
}

run1();
run2();

Terminal de salida:

PS C:\Users\user\OneDrive\Desktop\Folders\Programming\Web Development\Web Development Projects\Database-Practice> node server
{
  name: 'Sally',
  age: 40,
  _id: new ObjectId("61d20d852b1e59a6b21149b1"),  __v: 0
}
{
  name: 'John',
  age: 25,
  _id: new ObjectId("61d20d852b1e59a6b21149b0"),  __v: 0
}

Imagen de mi base de datos después de ejecutar mi código:

Mostrar la mejor respuesta

#database #javascript #mongodb #node.js #mongoose

Publicado : 2 January, 2021 @ 20:47

Ibrahim

Los modelos Mongoose tienen una función create() que a menudo se usa para crear nuevos documentos.

const User = mongoose.model('User', mongoose.Schema({
email: String
}));

const doc = await User.create({ email: 'bill@microsoft.com' });
doc.email; // 'bill@microsoft.com'

La función crear() es un envoltorio delgado alrededor de la función guardar(). La llamada anterior a create() es equivalente a:

 const doc = new User({ email: 'bill@microsoft.com' });
 await doc.save();

La razón más común para usar create() es que puede guardar convenientemente varios documentos con una sola llamada de función al pasar una matriz de objetos:

 const User = mongoose.model('User', mongoose.Schema({
 email: String
 }));

 const docs = await User.create([
 { email: 'sergey@google.com' },
 { email: 'bill@microsoft.com' }
 ]);
 docs[0] instanceof User; // true
 docs[0].email; // 'sergey@google.com'
 docs[1].email; // 'bill@microsoft.com'

Publicado : 2 January, 2021 @ 20:57

Rubek Joshi

De los documentos:

Acceso directo para guardar uno o más documentos en la base de datos. MyModel.create(docs) hace new MyModel(doc).save() para cada documento en docs.

Mirando lo que tienes, déjame señalar:

async function run1 () {
    const person = await Person.create({name: 'John', age: 25});
    await person.save(); // unnecessary 2nd call here
    console.log(person);
}

Detrás de escena, su código se ejecutará como:

async function run1 () {
    const person = await new Person({name: 'John', age: 25}).save();
    await person.save(); // saving twice basically
    console.log(person);
}

Lo que puede hacer es (esto es lo que prefieren la mayoría):

async function run1 () {
    const person = new Person({name: 'John', age: 25});
    await person.save();
}

La razón es que hacerlo le da más control al guardar su documento. Por ejemplo, puede pasar el objeto de persona a cualquier función y guardarlo dentro de esa función sin requerir que el modelo esté en cualquier lugar donde exista esa función en su base de código.

async function run1 () {
    const person = new Person({name: 'John', age: 25});
    await doSth(person); // showing possibility, not a recommendation
}

// This function can exist anywhere, does not have to be in the same file
async doSth(person){
  // do some logging maybe
  // change some properties of the person maybe
  // slug-ify the persons name maybe
  await person.save();
}

Hacer esto le permite tener una mejor separación de preocupaciones. Aparte de eso, ambos producirán el mismo comportamiento y es más o menos una cuestión de preferencia. Pero el estándar actual en la comunidad va con el método .save().