Wie entferne ich Dokumente mit Node.js Mongoose?

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

Das obige scheint nicht zu funktionieren. Die Aufzeichnungen sind noch da.

Kann jemand reparieren?

Wenn Sie keine Lust zum Iterieren haben, versuchen Sie es FBFriendModel.find({ id:333 }).remove( callback );oderFBFriendModel.find({ id:333 }).remove().exec();

mongoose.model.findgibt eine Abfrage zurück , die eine removeFunktion hat .

Update für Mongoose v5.5.3 - remove()ist jetzt veraltet. Verwendung deleteOne(), deleteMany()oderfindOneAndDelete() instead.

UPDATE: Mungo-Version (5.5.3)

remove () ist veraltet und Sie können stattdessen deleteOne (), deleteMany () oderulkWrite () verwenden.

Ab "mongoose": ">=2.7.1"sofort können Sie das Dokument direkt mit der .remove()Methode entfernen , anstatt das Dokument zu finden und dann zu entfernen, was mir effizienter und einfacher zu warten erscheint.

Siehe Beispiel:

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

AKTUALISIEREN:

Ab Mungo 3.8.1gibt es verschiedene Methoden, mit denen Sie ein Dokument direkt entfernen können, z. B.:

• remove
• findByIdAndRemove
• findOneAndRemove

Weitere Informationen finden Sie in den API-Dokumenten für Mungos .

docsist eine Reihe von Dokumenten. Es gibt also keine mongooseModel.remove()Methode.

Sie können jedes Dokument im Array separat iterieren und entfernen.

Oder - da es so aussieht, als würden Sie die Dokumente anhand einer (wahrscheinlich) eindeutigen ID finden - verwenden Sie findOnestatt find.

Dies ist für mich das Beste ab Version 3.8.1:

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

Und es ist nur ein DB-Aufruf erforderlich. Verwenden Sie diese removeOption, da Sie vor dem Suchen und Entfernen keine Aktionen ausführen.

Einfach machen

FBFriendModel.remove().exec();

mongoose.model.find()Gibt ein Abfrageobjekt zurück, das auch eine remove()Funktion hat.

Sie können auch verwenden mongoose.model.findOne(), wenn Sie nur ein eindeutiges Dokument entfernen möchten.

Andernfalls können Sie auch dem traditionellen Ansatz folgen, bei dem Sie zuerst das Dokument abrufen und dann entfernen.

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

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

Im Folgenden finden modelSie die folgenden Möglichkeiten für Objekte, um Dokumente zu entfernen:

yourModelObj.findOneAndRemove(conditions, options, callback)

yourModelObj.findByIdAndRemove(id, options, callback)

yourModelObj.remove(conditions, callback);

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

remove()wurde veraltet. Verwenden Sie deleteOne(), deleteMany()oder bulkWrite().

Der Code, den ich benutze

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

Zur Verallgemeinerung können Sie verwenden:

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

Ein anderer Weg, dies zu erreichen, ist:

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

Seien Sie vorsichtig mit findOne und entfernen Sie!

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

Der obige Code entfernt ALLE Benutzer mit dem Namen "Alice" anstelle des ersten .

Übrigens ziehe ich es vor, Dokumente wie diese zu entfernen:

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

Oder geben Sie einen Rückruf ein und lassen Sie exec () weg

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

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

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

Wenn Sie nur ein zu entfernendes Objekt suchen, können Sie es verwenden

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

    });

In diesem Beispiel wird Mongoose basierend auf der Übereinstimmung mit req.params.id gelöscht.

.remove()funktioniert wie .find():

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

Ich bevorzuge die Versprechensnotation, wo Sie zB brauchen

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

Zum Entfernen von Dokumenten bevorzuge ich die Verwendung Model.remove(conditions, [callback])

Informationen zum Entfernen finden Sie in der API-Dokumentation: -

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

In diesem Fall lautet der Code: -

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

Wenn Sie Dokumente entfernen möchten, ohne auf eine Antwort von MongoDB zu warten, keinen Rückruf übergeben, müssen Sie exec für die zurückgegebene Abfrage aufrufen

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

Sie können die Abfrage einfach direkt in der Entfernungsfunktion verwenden, also:

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

Sie können immer die integrierte Funktion Mongoose verwenden:

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()wird abgeschrieben, funktioniert aber immer noch für ältere Versionen

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

Mit der Methode remove () können Sie entfernen.

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

Das hat bei mir funktioniert, versuchen Sie es einfach:

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

Gemäß der Antwort von Samyak Jain verwende ich Async Await

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

Ich mag dieses Muster in asynchronen / wartungsfähigen Express / Mongoose-Apps sehr:

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