Javascript 如何立即执行mongoose查询并用Promise.all等待它们？

我刚刚习惯了承诺，我想向表中添加一个额外的ObjectId引用。我使用以下代码：

'use strict';

const mongoose = require('mongoose');
const config = require('config');

mongoose.connect(config.get("DBUrl"), {useMongoClient: true});
mongoose.set('debug', true);

require('../model/AnnotationRequest');
require('../model/Website');

const AnnotationRequest = mongoose.model('AnnotationRequest');
const Website = mongoose.model('Website');

foo(function () {
    console.log('done');
});

function foo(done) {

    Website.find()
        .then(function (websites) {
            if (!websites) console.error('could not find any websites');

            AnnotationRequest.find({website: {$exists: false}})
                .then(function (annotationRequests) {

                    let jobs = [];

                    for (let k = 0; k < annotationRequests.length; k++) {
                        let found = false;

                        for (let i = 0; i < websites.length; i++) {
                            let websiteAnnotations = websites[i].annotations;

                            for (let o = 0; o < websiteAnnotations.length; o++) {

                                if (websiteAnnotations[o].equals(annotationRequests[k].annotation)) {
                                    found = true;
                                    annotationRequests[k].website = websites[i];
                                    jobs.push(
                                        annotationRequests[k].save()
                                            .then(function (res) {
                                                console.log("success saving", res._id);
                                            }).catch(function (err) {
                                                console.error(err);
                                                done(err);
                                            })
                                    );
                                    break;
                                }
                            }
                            if (found) {
                                break;
                            }
                        }
                    }

                    Promise.all(jobs).then(
                        function () {
                            done();
                        }
                    ).catch(function (err) {
                        console.error(err);
                    });
                });
        });
}

“严格使用”；
const mongoose=require（'mongoose'）；
const config=require（'config'）；
connect（config.get（“DBUrl”），{useMongoClient:true}）；
mongoose.set（'debug'，true）；
需要（'../model/AnnotationRequest'）；
需要（“../model/Website”）；
const AnnotationRequest=mongoose.model（'AnnotationRequest'）；
const-Website=mongoose.model（“网站”）；
foo（函数（）{
console.log（'done'）；
});
函数foo（完成）{
网址：find（）
.然后（功能（网站）{
if（！websites）console.error（'找不到任何网站'）；
AnnotationRequest.find（{website:{$exists:false}}）
.then（函数（注释请求）{
让乔布斯=[]；
for（设k=0；k

第一个保存查询报告在Promise.all语句中启动。在第一个

.save（）

语句之后是否不立即执行查询？我怎样才能立即启动它们

另一个问题是，对于200000个条目，此代码需要2小时。在服务器上，我们有超过2M个条目。不确定它是否会起作用。有什么建议吗

---

谢谢，

节点运行单线程，所以如果您有200k循环，则所有保存语句都将等待，直到代码的同步执行并完成

尝试使用异步模块使代码更异步友好。

尝试此代码，但此代码与您的代码有相同的错误。Id不止一个网站有相同的注释，你的第一次发现，我的可能最后一次发现

'use strict';

const mongoose = require('mongoose');
const config = require('config');
const async = require('async');


mongoose.connect(config.get("DBUrl"), {useMongoClient: true});
mongoose.set('debug', true);

require('../model/AnnotationRequest');
require('../model/Website');

const AnnotationRequest = mongoose.model('AnnotationRequest');
const Website = mongoose.model('Website');

foo(function () {
    console.log('done');
});

function foo(done) {

    const pageSize= 10000;

    async.parallel([function(callback) {

        Website.find().then( function(websites) {
            callback(null, websites);
        }).catch(callback);

    },function(callback) {
        AnnotationRequest.count({website: {$exists: false}}).then( function(count) {
            callback(null, count);
        }).catch(callback);
    }], function(err, results) {

        if(err) {
            console.error(err);
            return;
        }

        const websites = results[0];
        const annotationRequestsCount = results[1];

        let websiteAnnotationMap = {};

        websites.forEach(function (website) {
            website.annotations.forEach(function (annotation) {
                websiteAnnotationMap[annotation] = website;
            });
        });


        var skip = 0;

        async.during(
            function (callback) {
                return callback(null, skip < annotationRequestsCount);
            },
            function (callback) {

                AnnotationRequest.find({website: {$exists: false}},  { skip: skip, limit: pageSize })
                    .then( function(annotationRequests) {

                        skip += pageSize;

                        async.each(annotationRequests, function(annotationRequest, eachCallback) {

                            let website = websiteAnnotationMap[annotationRequest.annotation];
                            if(website) {
                                annotationRequest.website = website;
                                annotationRequest.save().then(function () {
                                    eachCallback();
                                }).catch(eachCallback);

                            } else {
                                eachCallback();
                            }
                        }, callback);
                }).catch(callback);
            },
            done
        );


    });
}

“严格使用”；
const mongoose=require（'mongoose'）；
const config=require（'config'）；
const async=require（'async'）；
connect（config.get（“DBUrl”），{useMongoClient:true}）；
mongoose.set（'debug'，true）；
需要（'../model/AnnotationRequest'）；
需要（“../model/Website”）；
const AnnotationRequest=mongoose.model（'AnnotationRequest'）；
const-Website=mongoose.model（“网站”）；
foo（函数（）{
console.log（'done'）；
});
函数foo（完成）{
常量页面大小=10000；
async.parallel（[函数（回调））{
Website.find（）.then（函数（网站）{
回调（空，网站）；
}).catch（回调）；
}，函数（回调）{
count（{website:{$exists:false}}）。然后（函数（count）{
回调（null，count）；
}).catch（回调）；
}]，函数（错误，结果）{
如果（错误）{
控制台错误（err）；
返回；
}
const网站=结果[0]；
const annotationrequestscont=结果[1]；
让websiteAnnotationMap={}；
网站。forEach（功能（网站）{
website.annotations.forEach（函数（注释）{
网站注释地图[注释]=网站；
});
});
var-skip=0；
异步过程(
函数（回调）{
返回回调（null，跳过

节点运行单线程，因此，如果您有200k循环，则所有save语句将等待代码同步执行并完成

尝试使用异步模块使代码更异步友好。

尝试此代码，但此代码与您的代码有相同的错误。我是莫尔