小开

实际上，您可以使用 Mongoose 的“ create”方法，它可以包含一个文档数组，请参见下面的示例:

Candy.create({ candy: 'jelly bean' }, { candy: 'snickers' }, function (err, jellybean, snickers) {
});

回调函数包含插入的文档。您并不总是知道需要插入多少项(固定参数长度，如上所示) ，这样您就可以遍历它们:

var insertedDocs = [];
for (var i=1; i<arguments.length; ++i) {
insertedDocs.push(arguments[i]);
}

更新: 更好的解决方案

一个更好的解决方案是使用 Candy.collection.insert()而不是 Candy.create()(在上面的例子中使用了 Candy.create()) ，因为它更快(create()在每个项目上调用 Model.save()，所以速度更慢)。

有关更多信息，请参见 Mongo 文档: Http://docs.mongodb.org/manual/reference/method/db.collection.insert/

(感谢 Arcseldon指出这一点)

小开

Create () vs Model.Collection.insert () : 一种更快的方法

如果您处理的是一个非常大的批量，那么 Model.create()是一种不好的插入方法。它将是 非常慢。在这种情况下，您应该使用执行 好多了的 Model.collection.insert。根据批量的大小，Model.create()甚至会崩溃！找了一百万份文件，没找到。使用 Model.collection.insert只需要几秒钟。

Model.collection.insert(docs, options, callback)

docs是要插入的文档数组;
options是一个可选的配置对象-参见那些文件
在保存所有文档或发生错误后，将调用 callback(err, docs)。成功时，docs 是持久化文档的数组。

正如 Mongoose 的作者指出的给你，这种方法将绕过任何验证过程，直接访问 Mongo 驱动程序。这是一个必须做出的权衡，因为您要处理大量的数据，否则根本无法将其插入到数据库中(请记住，我们在这里讨论的是数十万个文档)。

举个简单的例子

var Potato = mongoose.model('Potato', PotatoSchema);


var potatoBag = [/* a humongous amount of potato objects */];


Potato.collection.insert(potatoBag, onInsert);


function onInsert(err, docs) {
if (err) {
// TODO: handle error
} else {
console.info('%d potatoes were successfully stored.', docs.length);
}
}

更新2019-06-22 : 虽然 insert()仍然可以很好地使用，但是它已经被废弃了，取而代之的是 insertMany()。参数是完全相同的，所以您可以使用它作为一个插件替换，一切都应该工作得很好(嗯，返回值有点不同，但您可能不使用它反正)。

参考文献

小开

可以使用 mongoDB shell 通过在数组中插入值来执行大容量插入。

db.collection.insert([{values},{values},{values},{values}]);

小开

您可以使用猫鼬执行批量插入，作为得分最高的答案。但这个例子行不通，它应该是:

/* a humongous amount of potatos */
var potatoBag = [{name:'potato1'}, {name:'potato2'}];


var Potato = mongoose.model('Potato', PotatoSchema);
Potato.collection.insert(potatoBag, onInsert);


function onInsert(err, docs) {
if (err) {
// TODO: handle error
} else {
console.info('%d potatoes were successfully stored.', docs.length);
}
}

不要对批量插入使用模式实例，应该使用普通的映射对象。

小开

似乎使用猫鼬有一个超过1000个文档的限制，当使用

Potato.collection.insert(potatoBag, onInsert);

你可使用:

var bulk = Model.collection.initializeOrderedBulkOp();


async.each(users, function (user, callback) {
bulk.insert(hash);
}, function (err) {
var bulkStart = Date.now();
bulk.execute(function(err, res){
if (err) console.log (" gameResult.js > err " , err);
console.log (" gameResult.js > BULK TIME  " , Date.now() - bulkStart );
console.log (" gameResult.js > BULK INSERT " , res.nInserted)
});
});

但是，在使用10000个文档进行测试时，这几乎快了一倍:

function fastInsert(arrOfResults) {
var startTime = Date.now();
var count = 0;
var c = Math.round( arrOfResults.length / 990);


var fakeArr = [];
fakeArr.length = c;
var docsSaved = 0


async.each(fakeArr, function (item, callback) {


var sliced = arrOfResults.slice(count, count+999);
sliced.length)
count = count +999;
if(sliced.length != 0 ){
GameResultModel.collection.insert(sliced, function (err, docs) {
docsSaved += docs.ops.length
callback();
});
}else {
callback()
}
}, function (err) {
console.log (" gameResult.js > BULK INSERT AMOUNT: ", arrOfResults.length, "docsSaved  " , docsSaved, " DIFF TIME:",Date.now() - startTime);
});
}

小开

Mongoose 4.4.0现在支持批量插入

Mongoose 4.4.0使用模型方法 .insertMany()引入了—— true ——大容量插入。它比在 .create()上循环或提供数组快得多。

用法:

var rawDocuments = [/* ... */];


Book.insertMany(rawDocuments)
.then(function(mongooseDocuments) {
/* ... */
})
.catch(function(err) {
/* Error handling */
});

或者

Book.insertMany(rawDocuments, function (err, mongooseDocuments) { /* Your callback function... */ });

你可以追踪到:

小开

分享我们项目的工作代码和相关代码:

//documentsArray is the list of sampleCollection objects
sampleCollection.insertMany(documentsArray)
.then((res) => {
console.log("insert sampleCollection result ", res);
})
.catch(err => {
console.log("bulk insert sampleCollection error ", err);
});

小开

这里介绍了使用 insert 许多保存数据和保存数据的两种方法

1) Mongoose 使用 insertMany批量保存文档阵列

/* write mongoose schema model and export this */
var Potato = mongoose.model('Potato', PotatoSchema);


/* write this api in routes directory  */
router.post('/addDocuments', function (req, res) {
const data = [/* array of object which data need to save in db */];


Potato.insertMany(data)
.then((result) => {
console.log("result ", result);
res.status(200).json({'success': 'new documents added!', 'data': result});
})
.catch(err => {
console.error("error ", err);
res.status(400).json({err});
});
})

2)用 .save()保存文档数组

这些文档将保存并行文档。

/* write mongoose schema model and export this */
var Potato = mongoose.model('Potato', PotatoSchema);


/* write this api in routes directory  */
router.post('/addDocuments', function (req, res) {
const saveData = []
const data = [/* array of object which data need to save in db */];
data.map((i) => {
console.log(i)
var potato = new Potato(data[i])
potato.save()
.then((result) => {
console.log(result)
saveData.push(result)
if (saveData.length === data.length) {
res.status(200).json({'success': 'new documents added!', 'data': saveData});
}
})
.catch((err) => {
console.error(err)
res.status(500).json({err});
})
})
})

猫鼬(mongodb)批量插入？

更新: 更好的解决方案

Create () vs Model.Collection.insert () : 一种更快的方法

举个简单的例子

参考文献

Mongoose 4.4.0现在支持批量插入