Javascript collection.find上的代码暂停

我是JS的新手，在这一点上我被卡住了。我试图在启动新查询之前清除我的DBs，但它在collection.find命令处一直处于暂停状态。如果我删除了代码来清除数据库，一切正常

router.get('/parse', function(req, res) {
    collection.remove({})
    collectionweb.remove({})
    collectionhit.remove({})
    //Converter Class
    var Converter = require("csvtojson").core.Converter;
    var fs = require("fs");
    var csvFileName = "./download/company.csv";
    var fileStream = fs.createReadStream(csvFileName);
    //new converter instance
    var param = {};
    var csvConverter = new Converter(param);
    request({
        uri: "http://online.barrons.com/news/articles/SB50001424053111904537004580085820431503044?mod=BOL_twm_fs",
    }, function(error, response, body) {
        collectionweb.insert({
            "website": body
        });
    });
    //end_parsed will be emitted once parsing finished
    csvConverter.on("end_parsed", function(jsonObj) {
        //Insert into DB
        collection.insert(jsonObj);
    });
    fileStream.pipe(csvConverter);
    collectionweb.find({}, function(e, docs1) {
        for (var j in docs1) {
            var body = docs1[j]
            var webs = body.website
            console.log(1)
            collection.find({}, function(e, docs) {
                for (var i in docs) {
                    console.log(2)
                    var companies = docs[i]
                    var Score = 0;
                    $words = webs.search(companies.Symbol);
                    console.log(3)
                    if ($words > 0) {
                        StockScore++console.log(Score)
                        collectionhit.insert(companies)
                        collectionhit.update({
                            "Name": companies.Name
                        }, {
                            '$set': {
                                "score": Score
                            }
                        })
                    } else {};
                };
            });
        };
    });
});

---

有一些问题，但它们有一个共同点：您还不了解Node.js是异步的。只需google node.js asynchronous，您将获得少量资源，或者只需在此处查找，例如

其要点是等待回调或事件，例如：

var eiot = new EventedIOThing('paaarammm');

// use once, unless you for sure need to listen for the event multiple times
eiot.once('open',function onEIOTOpen() {
    console.log('opened the thing.');
}).once('error',function onEIOTError(err) {
    console.warn('there were problemzzz');
}).once('end',function onEIOTEnd() {
    // successfully finished evented IO thing...
    someAction(this.dep,'anotherparam',function callMeWhenActionIsDone(err,result) {
        if ( err ) {
            console.warn('someAction had a problem!',err);
            return; // exit early if we didn't get an optimal result
        }
        anotherDependentAction(result,function callMeWhenSecondActionIsDone(err,result) {
            if ( err ) { // this 'err' is local to this function's scope
                console.warn('anotherDependentAction had a problem!',err);
                return; // exit early again
            }
            console.log('All done... what do you want to do next?');
        });
    });
});

鉴于变量/函数名和注释，上面的代码是非常自解释的，但请密切注意调用方法的方式，尤其是在调用方法时。事情不会连续发生，相反，代码处于备用状态，直到相关/适当的事情发生并取得成功，然后程序流程才会继续

上述编码风格的缺点是，最终会得到很多嵌套函数。这就是LIB喜欢发挥作用的地方。它允许浅层函数程序流：您指定一个函数数组，并在内部调用回调时指定异步句柄，您只需担心顺序

现在，根据您当前拥有的代码，我们从第一个示例中了解到的内容，以及1-引入异步模块，可以将其重写如下：

var async = require('async'), // https://github.com/caolan/async
    fs = require('fs'),
    Converter = require('csvtojson').core.Converter;

router.get('/parse',function cbGetParse(req, res) {
    async.series([
        collection.remove.bind(collection),
        collectionweb.remove.bind(collectionweb),
        collectionhit.remove.bind(collectionhit),
        function convertCsv(callback) {
            var cbCalled = false; // i don't trust csvtojson to handle errors properly
            fs.createReadStream('./download/company.csv')
                .once('error',function(err) {
                    if ( !cbCalled ) {
                        cbCalled = true;
                        callback(err,null);
                    }
                })
                .pipe(new Converter({})) // pipe returns an instance of the Converter object
                .once('end_parsed',function onConverterEnd(jsonObj) {
                    collection.insert(jsonObj,function cbCollInsert(err,result) {
                        if ( !cbCalled ) {
                            cbCalled = true;
                            callback(err,result);
                        }
                    });
                });
        },
        function barronsHttpRequest(callback) {
            request({
                uri: 'http://online.barrons.com/news/articles/SB50001424053111904537004580085820431503044?mod=BOL_twm_fs',
            },function cbRequest(err,response,body) {
                if ( err ) {
                    callback(err,null);
                    return; // if err, exit early
                }
                collectionweb.insert({'website':body},function cbCollWebInsert(err,result) {
                    callback(err,result);
                });
            });
        },
        function lastChunkOfCode(callback) {
            // not going to rewrite this, same principle applies as above
            collectionweb.find({}, function(e, docs1) {
                for (var j in docs1) {
                    var body = docs1[j]
                    var webs = body.website
                    console.log(1)
                    collection.find({}, function(e, docs) {
                        for (var i in docs) {
                            console.log(2)
                            var companies = docs[i]
                            var Score = 0;
                            $words = webs.search(companies.Symbol);
                            console.log(3)
                            if ($words > 0) {
                                StockScore++console.log(Score)
                                collectionhit.insert(companies)
                                collectionhit.update({
                                    "Name": companies.Name
                                }, {
                                    '$set': {
                                        "score": Score
                                    }
                                })
                            } else {};
                        };
                    });
                };
                callback();
            });
        }
    ],function asyncComplete(err,result) {
        // you don't specify how to respond to the request so...
        if ( err ) {
            console.warn('Problem with /parse:',err);
        }
        res.end();
    });
});

我对脚本应该如何工作做了大量的假设，因此它可能不是您想要的100%，但异步概念已经被应用。另外，我没有测试这段代码。您需要确定什么可以并行运行，什么是串行运行，您的控制流应该是什么样子，以及您希望如何处理发生的错误

请注意，我没有在脚本的最后一块中实现异步行为，因为我无法确定您的集合关系是什么-我不会为您完成所有工作。我注意到它可以被优化一点。我不认为有任何理由选择这两个集合中的所有文档。您需要将选择器/查询处理卸载到数据库上，如果您可以帮助的话，它不应该在您的应用程序中

一些外卖：

接受回调，使用它。 与相同-尽管文档称回调是可选的，但只有在非常罕见的情况下才应该忽略它。我不管你是否在使用书面关注。 注意你的循环： 不应使用for…in，尤其是与数组一起使用，请使用普通for或array.forEach 当对任何异步调用使用任何类型的for循环时（特别是与套接字相关的调用，即MongoDb），您需要耐心等待回调，否则会像拒绝服务攻击一样淹没套接字。我建议使用或 我喜欢将我的Lambdas命名为矛盾修饰法？，它有助于剖析堆栈跟踪。 请使用“或”，它们的作用完全相同，不要混合使用。 分成小块发展。让一个零件工作，然后是下一个零件，然后是下一个零件。做小而抽象的工作。

---

1 Collection.prototype.remove不同步。2请求不同步。3 ReadStream.prototype.pipe不同步。4 Collection.prototype.find不同步。5 Node.js通常不同步！您必须等待回调或发出的事件，具体取决于实现。这意味着，你的代码是一个命令一个命令地执行的，是的，但是仅仅因为解释器移动到下一个命令并不意味着上一个命令已经完成。Node.js是事件I/O。有什么建议可以让它工作吗？