Come rimuovo i documenti usando Node.js Mongoose?

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

Quanto sopra non sembra funzionare. I registri sono ancora lì.

Qualcuno può risolvere?

Se non hai voglia di iterare, prova FBFriendModel.find({ id:333 }).remove( callback );oFBFriendModel.find({ id:333 }).remove().exec();

mongoose.model.findrestituisce una query , che ha una removefunzione .

L'aggiornamento per Mongoose v5.5.3 remove()è ora obsoleto. Usa deleteOne(), deleteMany()ofindOneAndDelete() instead.

AGGIORNAMENTO: versione Mongoose (5.5.3)

remove () è deprecato e puoi usare deleteOne (), deleteMany () o bulkWrite () invece.

A partire da "mongoose": ">=2.7.1"te puoi rimuovere il documento direttamente con il .remove()metodo piuttosto che trovare il documento e quindi rimuoverlo che mi sembra più efficiente e facile da mantenere.

Vedi esempio:

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

AGGIORNARE:

A partire da mangusta 3.8.1, esistono diversi metodi che ti consentono di rimuovere direttamente un documento, ad esempio:

• remove
• findByIdAndRemove
• findOneAndRemove

Per ulteriori informazioni, consultare i documenti API di mangusta .

docsè una matrice di documenti. quindi non ha un mongooseModel.remove()metodo.

È possibile iterare e rimuovere ogni documento nell'array separatamente.

Oppure - dato che sembra che tu stia trovando i documenti con un id (probabilmente) unico - usa findOneinvece di find.

Questo per me è il migliore dalla versione 3.8.1:

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

E richiede solo una chiamata DB. Usa questo dato che non esegui alcuna removeazione per la ricerca e la rimozione.

Semplicemente

FBFriendModel.remove().exec();

mongoose.model.find()restituisce un oggetto query che ha anche una remove()funzione.

Puoi anche usare mongoose.model.findOne(), se vuoi rimuovere solo un documento unico.

Altrimenti puoi seguire anche l'approccio tradizionale in cui hai prima recuperato il documento e poi rimosso.

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

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

Di seguito sono riportati i modi modelsull'oggetto che è possibile eseguire una delle seguenti operazioni per rimuovere i documenti:

yourModelObj.findOneAndRemove(conditions, options, callback)

yourModelObj.findByIdAndRemove(id, options, callback)

yourModelObj.remove(conditions, callback);

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

remove()è stato deprecato. Usa deleteOne(), deleteMany()o bulkWrite().

Il codice che uso

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

Per generalizzare puoi usare:

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

Fai attenzione con findOne e rimuovi!

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

Il codice sopra rimuove TUTTI gli utenti denominati "Alice" anziché solo il primo .

A proposito, preferisco rimuovere documenti come questo:

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

O fornire un callback e omettere il exec ()

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

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

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

Se stai cercando un solo oggetto da rimuovere, puoi usarlo

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

    });

In questo esempio, Mongoose verrà eliminato in base alla corrispondenza di req.params.id.

.remove()funziona come .find():

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

Preferisco la notazione della promessa, dove è necessario ad es

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

Per rimuovere il documento, preferisco usare Model.remove(conditions, [callback])

Fare riferimento alla documentazione API per la rimozione: -

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

In questo caso, il codice sarà: -

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

Se si desidera rimuovere documenti senza attendere una risposta da MongoDB, non passare un callback, è necessario chiamare exec sulla query restituita

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

Puoi semplicemente utilizzare la query direttamente all'interno della funzione di rimozione, quindi:

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

Puoi sempre usare la funzione integrata 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;
    });

Aggiornamento: .remove()è ammortizzato ma 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 }`
    })
});

utilizzando il metodo remove () è possibile rimuovere.

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

Questo ha funzionato per me, prova 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
        })
      });

Come da Samyak Jain's Answer, uso Async Await

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

Mi piace molto questo modello nelle app Express / Mongoose compatibili asincrono / wait:

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