Comment supprimer des documents à l'aide de Node.js Mongoose?

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

Ce qui précède ne semble pas fonctionner. Les enregistrements sont toujours là.

Quelqu'un peut-il réparer?

Si vous n'avez pas envie d'itérer, essayez FBFriendModel.find({ id:333 }).remove( callback );ouFBFriendModel.find({ id:333 }).remove().exec();

mongoose.model.findrenvoie une requête , qui a une removefonction .

La mise à jour pour Mongoose v5.5.3 - remove()est désormais obsolète. Utiliser deleteOne(), deleteMany()oufindOneAndDelete() instead.

MISE À JOUR: version Mongoose (5.5.3)

remove () est obsolète et vous pouvez utiliser deleteOne (), deleteMany () ou bulkWrite () à la place.

Dès que "mongoose": ">=2.7.1"vous pouvez supprimer le document directement avec la .remove()méthode plutôt que de trouver le document puis de le supprimer ce qui me semble plus efficace et plus facile à entretenir.

Voir l'exemple:

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

METTRE À JOUR:

Comme pour la mangouste 3.8.1, il existe plusieurs méthodes qui vous permettent de supprimer directement un document, par exemple:

• remove
• findByIdAndRemove
• findOneAndRemove

Reportez-vous à la documentation de l'API mangouste pour plus d'informations.

docsest un tableau de documents. il n'a donc pas de mongooseModel.remove()méthode.

Vous pouvez parcourir et supprimer chaque document du tableau séparément.

Ou - puisqu'il semble que vous trouviez les documents par un identifiant (probablement) unique - utilisez findOneplutôt que find.

Pour moi, c'est le meilleur de la version 3.8.1:

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

Et cela ne nécessite qu'un seul appel DB. Utilisez ceci étant donné que vous n'effectuez aucune removeaction avant la recherche et la suppression.

Faites simplement

FBFriendModel.remove().exec();

mongoose.model.find()renvoie un objet de requête qui a également unremove() fonction.

Vous pouvez également l'utiliser mongoose.model.findOne()si vous souhaitez supprimer un seul document unique.

Sinon, vous pouvez également suivre l'approche traditionnelle lorsque vous récupérez d'abord le document, puis le supprimez.

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

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

modelVous trouverez ci-dessous les méthodes permettant de supprimer un ou plusieurs documents sur un objet:

yourModelObj.findOneAndRemove(conditions, options, callback)

yourModelObj.findByIdAndRemove(id, options, callback)

yourModelObj.remove(conditions, callback);

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

remove()est obsolète. Utiliser deleteOne(), deleteMany()oubulkWrite() .

Le code que j'utilise

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

Pour généraliser, vous pouvez utiliser:

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

Une autre façon d'y parvenir est:

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

Soyez prudent avec findOne et supprimez!

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

Le code ci-dessus supprime TOUS les utilisateurs nommés «Alice» au lieu du premier uniquement.

Soit dit en passant, je préfère supprimer des documents comme celui-ci:

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

Ou fournissez un rappel et omettez l'exec ()

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

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

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

Si vous recherchez un seul objet à supprimer, vous pouvez utiliser

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

    });

Dans cet exemple, Mongoose supprimera en fonction de la correspondance req.params.id.

.remove()fonctionne comme .find():

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

Je préfère la notation de promesse, où vous avez besoin, par exemple

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

Pour supprimer un document, je préfère utiliser Model.remove(conditions, [callback])

Veuillez consulter la documentation de l'API pour la suppression: -

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

Dans ce cas, le code sera: -

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

Si vous souhaitez supprimer des documents sans attendre une réponse de MongoDB, ne passez pas de rappel, alors vous devez appeler exec sur la requête retournée

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

Vous pouvez simplement utiliser la requête directement dans la fonction de suppression, donc:

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

Vous pouvez toujours utiliser la fonction intégrée 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;
    });

Mise à jour: .remove()est dépréciée mais cela fonctionne toujours pour les anciennes versions

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

en utilisant la méthode remove () que vous pouvez supprimer.

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

Cela a fonctionné pour moi, essayez simplement ceci:

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

Selon la réponse de Samyak Jain, j'utilise Async Await

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

J'aime vraiment ce modèle dans les applications asynchrones / attendez Express / Mongoose:

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