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

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

Lo anterior no parece funcionar. Los registros aún están allí.

Alguien puede arreglar?

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

mongoose.model.finddevuelve una consulta , que tiene una removefunción .

Actualización para Mongoose v5.5.3: remove()ahora está en desuso. Uso deleteOne(), deleteMany()ofindOneAndDelete() instead.

ACTUALIZACIÓN: versión de mangosta (5.5.3)

remove () está en desuso y puede usar deleteOne (), deleteMany () o bulkWrite () en su lugar.

A partir de entonces "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, por ejemplo:

• remove
• findByIdAndRemove
• findOneAndRemove

Consulte los documentos de la API de mangosta para obtener más información.

docses una serie 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 se están encontrando los documentos de un (probablemente) Identificación única - utilizar findOneen lugar de find.

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

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

Y solo requiere una llamada de DB. Use esto dado que no realiza ninguna removeacción previa a la búsqueda y eliminación.

Simplemente haz

FBFriendModel.remove().exec();

mongoose.model.find()devuelve un objeto de consulta que también tiene una remove()función.

También puede usar mongoose.model.findOne(), si desea eliminar solo un documento único.

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

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

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

Las siguientes son las formas en las modelque puede realizar cualquiera de los siguientes procedimientos 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();

remove()ha quedado en desuso Uso deleteOne(), deleteMany()o bulkWrite().

El código que uso

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

Para generalizar puedes 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
});

¡Tenga cuidado con findOne y elimínelo!

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

El código anterior elimina TODOS los usuarios llamados 'Alice' en lugar de solo el primero .

Por cierto, prefiero eliminar documentos como este:

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

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

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

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

Ref: http://mongoosejs.com/docs/api.html#model_Model.remove

Si está buscando eliminar solo un objeto, 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 la combinación de req.params.id.

.remove()funciona como .find():

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

Prefiero la notación de promesa, donde la necesitas

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

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

Consulte la documentación de la 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();

Puede usar la consulta directamente dentro de la función remove, por lo que:

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

Siempre puede usar la función incorporada Mongoose:

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

Actualización: .remove()se deprecia pero todavía funciona para versiones anteriores

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

usando el método remove () puedes eliminarlo.

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

Esto funcionó para mí, solo prueba 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
        })
      });

Según la respuesta de Samyak Jain, uso Async Await

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

Realmente me gusta este patrón en aplicaciones Express / Mongoose asíncronas / en espera :

app.delete('/:idToDelete', asyncHandler(async (req, res) => {
  const deletedItem = await YourModel
    .findByIdAndDelete(req.params.idToDelete) // This method is the nice method for deleting
    .catch(err => res.status(400).send(err.message))

  res.status(200).send(deletedItem)
}))

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