How do I remove documents using Node.js Mongoose?

FBFriendModel.find({
    id: 333
}, function (err, docs) {
    docs.remove(); //Remove开发者_如何学Python all the documents that match!
});

The above doesn't seem to work. The records are still there.

Can someone fix?

---

If you don't feel like iterating, try

FBFriendModel.find({ id:333 }).remove( callback );

or

FBFriendModel.find({ id:333 }).remove().exec();

mongoose.model.find returns a Query, which has a remove function.

Update for Mongoose v5.5.3 - remove() is now deprecated. Use deleteOne(), deleteMany() or findOneAndDelete() instead.

---

UPDATE: Mongoose version (5.5.3)

remove() is deprecated and you can use deleteOne(), deleteMany(), or bulkWrite() instead.

As of "mongoose": ">=2.7.1" you can remove the document directly with the .remove() method rather than finding the document and then removing it which seems to me more efficient and easy to maintain.

See example:

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

UPDATE:

As of mongoose 3.8.1, there are several methods that lets you remove directly a document, say:

• remove
• findByIdAndRemove
• findOneAndRemove

Refer to mongoose API docs for further information.

---

docs is an array of documents. so it doesn't have a mongooseModel.remove() method.

You can iterate and remove each document in the array separately.

Or - since it looks like you are finding the documents by a (probably) unique id - use findOne instead of find.

---

This for me is the best as of version 3.8.1:

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

And it requires only one DB call. Use this given that you don't perform any remove actions pior to the search and removal.

---

remove() has been deprecated. Use deleteOne(), deleteMany() or bulkWrite().

The code I use

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

---

Simply do

FBFriendModel.remove().exec();

---

mongoose.model.find() returns a Query Object which also has a remove() function.

You can use mongoose.model.findOne() as well, if you want to remove only one unique document.

Else you can follow traditional approach as well where you first retrieving the document and then remove.

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

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

Following are the ways on model object you can do any of the following to remove document(s):

yourModelObj.findOneAndRemove(conditions, options, callback)

yourModelObj.findByIdAndRemove(id, options, callback)

yourModelObj.remove(conditions, callback);

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

---

To generalize you can use:

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();
  });
});

Another way to achieve this is:

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

---

Be careful with findOne and remove!

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

The code above removes ALL users named 'Alice' instead of the first one only.

By the way, I prefer to remove documents like this:

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

Or provide a callback and omit the exec()

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

---

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

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

---

If you are looking for only one object to be removed, you can use

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

    });

In this example, Mongoose will delete based on matching req.params.id.

---

.remove() works like .find():

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

---

I prefer the promise notation, where you need e.g.

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

---

For removing document, I prefer using Model.remove(conditions, [callback])

Please refer API documentation for remove :-

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

For this case, code will be:-

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

If you want to remove documents without waiting for a response from MongoDB, do not pass a callback, then you need to call exec on the returned Query

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

---

You can just use the query directly within the remove function, so:

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

---

You can always use Mongoose built-in function:

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

---

Update: .remove() is depreciated but this still works for older versions

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

---

I really like this pattern in async/await capable Express/Mongoose apps:

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)
}))

---

using remove() method you can able to remove.

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

---

As per Samyak Jain's Answer, i use Async Await

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

---

This worked for me, just try this:

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
        })
      });

---

To delete a single document you can use deleteOne() or remove()with single:true and deleteMany() or remove() to delete multiple documents :-

1. Using deleteOne()

    syntax
    Model.deleteOne({conditions},function(err){});

    Example
     Model.deleteOne({title:"hi"},function(err){
        if(err)
        {
            res.send(err);
        }
        else{
            res.send("deleted");
        }
    });

2.Using remove()

    syntax
    Model.remove({conditions},{single:true},function(err){});

    Example
     Model.remove({title:"hi"},{single:true},function(err){
        if(err)
        {
            res.send(err);
        }
        else{
            res.send("deleted");
        }
    });

3.using deleteMany()

syntax
Model.deleteMany({conditions},function(err){});

    Example
     Model.deleteMany({title:"hi"},function(err){
        if(err)
        {
            res.send(err);
        }
        else{
            res.send("deleted");
        }
    });

4. Using remove()

 syntax
    Model.remove({conditions},function(err){});

    Example
     Model.remove({title:"hi"},function(err){
        if(err)
        {
            res.send(err);
        }
        else{
            res.send("deleted");
        }
    });

---

if you know _id of the document you can use findByIdAndDelete(id) and this is is a shorthand for findOneAndDelete({ _id: id }).

import Question from '../models/Question';

const deleteQuestion = (questionId: string) => {
    try {
        Question.findByIdAndDelete(questionId);
    } catch (e) {
        console.error(e);
    }
};

here questionId is documentId (_id)

---

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