Comment puis-je supprimer des documents en utilisant Node.js Mangouste?

Question

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

Le ci-dessus ne semble pas fonctionner. Les dossiers sont toujours là.

Quelqu'un peut-il fixer?

Answer 1

docs est un tableau de documents. il ne dispose pas d'une méthode mongooseModel.remove().

Vous pouvez itérer et supprimer chaque document dans le tableau séparément.

Ou - car il semble que vous trouver les documents par un (probablement) identifiant unique -. L'utilisation findOne au lieu de find

Answer 2

Si vous ne vous sentez pas comme itérer, essayez FBFriendModel.find({ id:333 }).remove( callback ); ou FBFriendModel.find({ id:333 }).remove().exec();

retourne mongoose.model.find de requête, qui a une fonction remove .

Answer 3

Mise à jour: la version Mongoose (5.5.3)

remove () est dépréciée et vous pouvez utiliser deleteOne (), deleteMany (), ou bulkWrite () au lieu.

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

Voir l'exemple:

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

Mise à jour:

Au mangouste 3.8.1, il existe plusieurs méthodes qui vous permet de supprimer directement un document, dit:

• remove
• findByIdAndRemove
• findOneAndRemove

Reportez-vous à mangouste API docs pour plus d'informations.

Answer 4

pour moi est le meilleur de la version 3.8.1:

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

Et il ne nécessite qu'un seul appel DB. Utilisez ce étant donné que vous ne touchez aucune action de remove PIOR à la recherche et le retrait.

Answer 5

Il suffit de faire

FBFriendModel.remove().exec();

Answer 6

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

Vous pouvez utiliser mongoose.model.findOne() aussi bien, si vous voulez supprimer un seul document unique.

Sinon, vous pouvez suivre l'approche traditionnelle et où vous devez d'abord récupérer le document, puis supprimer.

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

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

Voici les nouveaux moyens sur l'objet model vous pouvez effectuer des opérations suivantes pour retirer le document (s):

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() a été désapprouvée. Utilisez deleteOne(), deleteMany() ou bulkWrite().

L'utilisation du code I

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

Answer 8

Pour vous généralisent 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
});

Answer 9

Soyez prudent avec findOne et supprimer!

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

Le code ci-dessus supprime tous les les utilisateurs nommé 'Alice' au lieu de le premier uniquement.

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

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

Ou fournir un rappel et omettre le exec ()

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

Answer 10

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

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

Answer 11

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 sera basé sur delete req.params.id correspondant.

Answer 12

.remove() fonctionne comme .find():

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

Answer 13

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

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

Answer 14

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

S'il vous plaît se référer la documentation API pour supprimer: -

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 voulez supprimer des documents sans attendre une réponse de MongoDB, ne passent pas un rappel, alors vous devez appeler exec sur la requête de retour

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

Answer 15

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

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

Answer 16

Vous pouvez toujours utiliser Mongoose fonction intégrée:

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

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

Answer 18

méthode

à l'aide remove (), vous pouvez en mesure de supprimer.

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

Answer 19

Cela a fonctionné pour moi, essayez 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
        })
      });

Answer 20

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

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

Answer 21

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