¿Cómo elimino los documentos usando Node.js Mongoose?

Question

FBFriendModel.find({
    id: 333
}, function (err, docs) {
    docs.remove(); //Remove all the documents that match!
});

Lo anterior no parece funcionar. Los registros todavía están ahí.

¿Alguien puede arreglar?

Answer 1

docs es una variedad de documentos. Entonces no tiene un mongooseModel.remove() método.

Puede iterar y eliminar cada documento en la matriz por separado.

O, ya que parece que está encontrando los documentos por una identificación (probablemente) única - use findOne en vez de find.

Answer 2

Si no tiene ganas de iterar, intente FBFriendModel.find({ id:333 }).remove( callback ); o FBFriendModel.find({ id:333 }).remove().exec();

mongoose.model.find Devuelve un Consulta, que tiene un remove función.

Answer 3

Actualización: Versión de Mongoose (5.5.3)

Eliminar () está en desuso y puede usar Deleteone (), Deletemany () o Bulkwrite () en su lugar.

A partir de "mongoose": ">=2.7.1" puede eliminar el documento directamente con el .remove() Método en lugar de encontrar el documento y luego eliminarlo, lo que me parece más eficiente y fácil de mantener.

Ver ejemplo:

Model.remove({ _id: req.body.id }, function(err) {
    if (!err) {
            message.type = 'notification!';
    }
    else {
            message.type = 'error';
    }
});

ACTUALIZAR:

A partir de la mangosta 3.8.1, hay varios métodos que le permiten eliminar directamente un documento, digamos:

• remove
• findByIdAndRemove
• findOneAndRemove

Referirse a Docios API de Mongoose para mayor información.

Answer 4

Esto para mí es el mejor a partir de la versión 3.8.1:

MyModel.findOneAndRemove({field: 'newValue'}, function(err){...});

Y solo requiere una llamada de DB. Usa esto dado que no realizas ninguno remove Acciones Pior a la búsqueda y eliminación.

Answer 5

Simplemente hacer

FBFriendModel.remove().exec();

Answer 6

mongoose.model.find() Devuelve un Objeto de consulta que también tiene un remove() función.

Puedes usar mongoose.model.findOne() Además, si desea eliminar solo un documento único.

De lo contrario, también puede seguir el enfoque tradicional donde primero recupere el documento y luego elimine.

yourModelObj.findById(id, function (err, doc) {
    if (err) {
        // handle error
    }

    doc.remove(callback); //Removes the document
})

Los siguientes son los caminos en model Objeto Puede hacer cualquiera de los siguientes para eliminar documentos:

yourModelObj.findOneAndRemove(conditions, options, callback)

yourModelObj.findByIdAndRemove(id, options, callback)

yourModelObj.remove(conditions, callback);

var query = Comment.remove({ _id: id });
query.exec();

Answer 7

remove() ha sido desaprobado. Usar deleteOne(), deleteMany() o bulkWrite().

El código que uso

TeleBot.deleteMany({chatID: chatID}, function (err, _) {
                if (err) {
                    return console.log(err);
                }
            });

Answer 8

Para generalizar que puede usar:

SomeModel.find( $where, function(err,docs){
  if (err) return console.log(err);
  if (!docs || !Array.isArray(docs) || docs.length === 0) 
    return console.log('no docs found');
  docs.forEach( function (doc) {
    doc.remove();
  });
});

Otra forma de lograr esto es:

SomeModel.collection.remove( function (err) {
  if (err) throw err;
  // collection is now empty but not deleted
});

Answer 9

¡Tenga cuidado con FindOne y elimine!

  User.findOne({name: 'Alice'}).remove().exec();

El código anterior elimina todo usuarios llamados 'Alice' en lugar de el primero solamente.

Por cierto, prefiero eliminar documentos como este:

  User.remove({...}).exec();

O proporcione una devolución de llamada y omita el exec ()

  User.remove({...}, callback);

Answer 10

model.remove({title:'danish'}, function(err){
    if(err) throw err;
});

Árbitro: http://mongoosejs.com/docs/api.html#model_model.remove

Answer 11

Si está buscando solo un objeto para eliminar, puede usar

Person.findOne({_id: req.params.id}, function (error, person){
        console.log("This object will get deleted " + person);
        person.remove();

    });

En este ejemplo, Mongoose se eliminará en función de Req.Params.id coincidente.

Answer 12

.remove() funciona como .find():

MyModel.remove({search: criteria}, function() {
    // removed.
});

Answer 13

Prefiero la notación de la promesa, donde necesitas, por ejemplo

Model.findOneAndRemove({_id:id})
    .then( doc => .... )

Answer 14

Para eliminar el documento, prefiero usar Model.remove(conditions, [callback])

Consulte la documentación de API para eliminar:-

http://mongoosejs.com/docs/api.html#model_model.remove

Para este caso, el código será:-

FBFriendModel.remove({ id : 333 }, function(err, callback){
console.log(‘Do Stuff’);
})

Si desea eliminar documentos sin esperar una respuesta de MongoDB, no pase una devolución de llamada, entonces debe llamar a Exec en la consulta devuelta

var removeQuery = FBFriendModel.remove({id : 333 });
removeQuery.exec();

Answer 15

Puede usar la consulta directamente dentro de la función eliminar, así que:

FBFriendModel.remove({ id: 333}, function(err){});

Answer 16

Siempre puede usar la función incorporada de mangosta:

var id = req.params.friendId; //here you pass the id
    FBFriendModel
   .findByIdAndRemove(id)
   .exec()
   .then(function(doc) {
       return doc;
    }).catch(function(error) {
       throw error;
    });

Answer 17

Actualizar: .remove() se deprecia pero esto todavía funciona para versiones más antiguas

YourSchema.remove({
    foo: req.params.foo
}, function(err, _) {
    if (err) return res.send(err)
    res.json({
        message: `deleted ${ req.params.foo }`
    })
});

Answer 18

Usando el método remove () que puede eliminar.

getLogout(data){
        return this.sessionModel
        .remove({session_id: data.sid})
        .exec()
        .then(data =>{
            return "signup successfully"
        })
    }

Answer 19

Esto funcionó para mí, solo intenta esto:

const id = req.params.id;
      YourSchema
      .remove({_id: id})
      .exec()
      .then(result => {
        res.status(200).json({
          message: 'deleted',
          request: {
            type: 'POST',
            url: 'http://localhost:3000/yourroutes/'
          }
        })
      })
      .catch(err => {
        res.status(500).json({
          error: err
        })
      });

Answer 20

Según la respuesta de Samyak Jain, uso async espera

let isDelete = await MODEL_NAME.deleteMany({_id:'YOUR_ID', name:'YOUR_NAME'});

Answer 21

db.collection.remove(<query>,
 {
  justOne: <boolean>,
  writeConcern: <document>
})