Respostas:
Se você não quiser repetir, tente FBFriendModel.find({ id:333 }).remove( callback );
ouFBFriendModel.find({ id:333 }).remove().exec();
mongoose.model.find
devolve uma consulta , que tem uma remove
função .
A atualização para o Mongoose v5.5.3 - remove()
agora está obsoleta. Use deleteOne()
, deleteMany()
oufindOneAndDelete() instead.
.exec()
no entanto, isso não acontece. É .exec()
necessário, existem efeitos colaterais em usá-lo ou não?
ATUALIZAÇÃO: versão Mongoose (5.5.3)
remove () foi descontinuado e você pode usar deleteOne (), deleteMany () ou bulkWrite ().
A partir de "mongoose": ">=2.7.1"
que você pode remover o documento diretamente com o .remove()
método em vez de encontrar o documento e, em seguida, removê-lo o que me parece mais eficiente e fácil de manter.
Consultar exemplo:
Model.remove({ _id: req.body.id }, function(err) {
if (!err) {
message.type = 'notification!';
}
else {
message.type = 'error';
}
});
ATUALIZAR:
No mangusto 3.8.1
, existem vários métodos que permitem remover diretamente um documento, como:
remove
findByIdAndRemove
findOneAndRemove
Consulte os documentos da API mangusto para obter mais informações.
remove(query)
potencialmente pode esvaziar toda a sua coleção se você passar acidentalmente query = {}
. Por esse motivo, prefiro findOneAndRemove(query)
se estiver removendo apenas um documento.
Model.remove({ _id: 'whatever' }).exec().then(...)
docs
é uma variedade de documentos. então não tem um mongooseModel.remove()
método.
Você pode iterar e remover cada documento da matriz separadamente.
Ou - já que parece que você está encontrando os documentos por um (provavelmente) ID único - use em findOne
vez de find
.
Isso para mim é o melhor da versão 3.8.1:
MyModel.findOneAndRemove({field: 'newValue'}, function(err){...});
E isso requer apenas uma chamada de banco de dados. Use isso, pois você não realiza nenhumaremove
ação pior para a pesquisa e remoção.
pre 'remove'
ações, ele funciona bem.
Simplesmente faça
FBFriendModel.remove().exec();
mongoose.model.find()
retorna um objeto de consulta que também tem uma remove()
função.
Você também pode usar mongoose.model.findOne()
se quiser remover apenas um documento exclusivo.
Caso contrário, você pode seguir a abordagem tradicional, bem como onde primeiro recuperou o documento e depois remove.
yourModelObj.findById(id, function (err, doc) {
if (err) {
// handle error
}
doc.remove(callback); //Removes the document
})
A seguir, são apresentadas as formas do model
objeto que você pode executar para remover os documentos:
yourModelObj.findOneAndRemove(conditions, options, callback)
yourModelObj.findByIdAndRemove(id, options, callback)
yourModelObj.remove(conditions, callback);
var query = Comment.remove({ _id: id });
query.exec();
remove()
foi descontinuado. Use deleteOne()
, deleteMany()
ou bulkWrite()
.
O código que eu uso
TeleBot.deleteMany({chatID: chatID}, function (err, _) {
if (err) {
return console.log(err);
}
});
(node:9132) DeprecationWarning: collection.remove is deprecated. Use deleteOne, deleteMany, or bulkWrite instead.
Para generalizar você pode usar:
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();
});
});
Outra maneira de conseguir isso é:
SomeModel.collection.remove( function (err) {
if (err) throw err;
// collection is now empty but not deleted
});
Cuidado com o findOne e remova-o!
User.findOne({name: 'Alice'}).remove().exec();
O código acima remove TODOS os usuários nomeados 'Alice', em vez do primeiro .
A propósito, prefiro remover documentos como este:
User.remove({...}).exec();
Ou forneça um retorno de chamada e omita o exec ()
User.remove({...}, callback);
model.remove({title:'danish'}, function(err){
if(err) throw err;
});
Se você estiver procurando apenas um objeto a ser removido, poderá usar
Person.findOne({_id: req.params.id}, function (error, person){
console.log("This object will get deleted " + person);
person.remove();
});
Neste exemplo, o Mongoose será excluído com base na correspondência req.params.id.
Para remover documento, prefiro usar Model.remove(conditions, [callback])
Consulte a documentação da API para remover: -
http://mongoosejs.com/docs/api.html#model_Model.remove
Nesse caso, o código será: -
FBFriendModel.remove({ id : 333 }, function(err, callback){
console.log(‘Do Stuff’);
})
Se você deseja remover documentos sem aguardar uma resposta do MongoDB, não transmita um retorno de chamada, será necessário chamar exec na Consulta retornada
var removeQuery = FBFriendModel.remove({id : 333 });
removeQuery.exec();
Você pode simplesmente usar a consulta diretamente na função remover, portanto:
FBFriendModel.remove({ id: 333}, function(err){});
Você sempre pode usar a função interna do 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;
});
Atualização: .remove()
está obsoleta, mas isso ainda funciona para versões mais antigas
YourSchema.remove({
foo: req.params.foo
}, function(err, _) {
if (err) return res.send(err)
res.json({
message: `deleted ${ req.params.foo }`
})
});
usando o método remove () que você pode remover.
getLogout(data){
return this.sessionModel
.remove({session_id: data.sid})
.exec()
.then(data =>{
return "signup successfully"
})
}
Isso funcionou para mim, apenas tente o seguinte:
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
})
});
Model.remove
está obsoleto
De acordo com a resposta de Samyak Jain, eu uso o Async Await
let isDelete = await MODEL_NAME.deleteMany({_id:'YOUR_ID', name:'YOUR_NAME'});
Eu realmente gosto desse padrão em aplicativos Express / Mongoose assíncronos / aguardados:
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>
})