Come faccio a rimuovere documenti utilizzando Node.js Mongoose?

Question

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

È possibile che questo non sembra funzionare. I record sono ancora lì.

Qualcuno può fix?

Answer 1

docs è un array di documenti. in modo che non dispone di un metodo mongooseModel.remove().

È possibile scorrere e rimuovere ogni documento nella matrice separatamente.

O - in quanto sembra che si stanno trovando i documenti da una (probabilmente) ID univoco -. Uso findOne invece di find

Answer 2

Se non avete voglia di iterazione, provare FBFriendModel.find({ id:333 }).remove( callback ); o FBFriendModel.find({ id:333 }).remove().exec();

mongoose.model.find un href="http://mongoosejs.com/docs/api.html#query-js"> Query , che ha una funzione remove .

Answer 3

UPDATE: versione Mongoose (5.5.3)

remove () è deprecato ed è possibile utilizzare deleteOne (), deleteMany (), o bulkWrite () al posto.

Come di "mongoose": ">=2.7.1" è possibile rimuovere il documento direttamente con il metodo .remove() piuttosto che trovare il documento e quindi rimuovendolo che mi sembra più efficiente e di facile manutenzione.

Vedere esempio:

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

UPDATE:

A partire dal 3.8.1 mangusta, ci sono diversi metodi che consente di rimuovere direttamente un documento, dicono:

• remove
• findByIdAndRemove
• findOneAndRemove

Fare riferimento a mangusta Documentazione API per ulteriori informazioni.

Answer 4

Questa per me è la migliore a partire dalla versione 3.8.1:

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

E richiede solo un DB chiamata. Utilizzare questo dato che non si esegue alcuna azione remove Pior alla ricerca e la rimozione.

Answer 5

È sufficiente fare

FBFriendModel.remove().exec();

Answer 6

mongoose.model.find() restituisce una query href="http://mongoosejs.com/docs/api.html#query_Query-remove"> oggetto che ha anche una funzione di remove().

È possibile utilizzare mongoose.model.findOne() pure, se si desidera rimuovere solo un documento unico.

altro si può seguire l'approccio tradizionale e dove prima recuperare il documento e quindi rimuovere.

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

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

In seguito sono i modi su oggetto model si può fare una delle seguenti per rimuovere il documento (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() è stato sconsigliato. Usa deleteOne(), deleteMany() o bulkWrite().

L'uso di codice I

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

Answer 8

Per generalizzare è possibile utilizzare:

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

Un altro modo per raggiungere questo obiettivo è:

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

Answer 9

Fare attenzione con findOne e rimuovere!

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

Il codice sopra Rimuove tutti gli utenti di nome 'Alice' al posto di il primo solo.

A proposito, io preferisco per rimuovere i documenti in questo modo:

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

Oppure creare una richiamata e omettere l'exec ()

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

Answer 10

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

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

Answer 11

Se siete alla ricerca di un solo oggetto da rimuovere, è possibile utilizzare

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

    });

In questo esempio, Mongoose sarà eliminare in base agli corrispondenza req.params.id.

Answer 12

.remove() funziona come .find():

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

Answer 13

Io preferisco la notazione promessa, in cui è necessario per es.

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

Answer 14

Per la rimozione dei documenti, io preferisco usare Model.remove(conditions, [callback])

Si prega di fare riferimento documentazione API per rimuovere: -

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

Per questo caso, il codice sarà: -

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

Se si desidera rimuovere i documenti senza attendere una risposta da MongoDB, non passa una richiamata, allora avete bisogno di chiamare exec sulla query restituita

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

Answer 15

Si può semplicemente utilizzare la query direttamente all'interno della funzione di rimozione, così:

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

Answer 16

È sempre possibile utilizzare Mongoose built-in funzione:

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

Aggiornamento: .remove() è ammortizzato, ma questo funziona ancora per le versioni precedenti

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

Answer 18

Metodo

utilizzando remove () è possibile in grado di rimuovere.

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

Answer 19

Questo ha funzionato per me, basta provare questo:

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

Come per risposta di Samyak Jain, io uso Async attendono

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

Answer 21

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