Question

我有一个MEAN应用程序，可以很好地处理单个请求，让我们说/api/products?pid=500。但是我最近发现了一个＆＃34;爆发＆＃34;请求（我在50个产品中更新批量= 50个请求/api/products?pid=500 *** 550包含帖子数据），req.body有时会获得即将发布的新请求的值。

前端应用程序会根据所选产品进行调用：

 ds.forEach((d, key) => {
        this.ApiCall.setData('products', { action: 'send-product', data: d })
            .subscribe((result) => {
                //we have results
            });
        });
    //setData makes a http.post().map

返回app / mean分析帖子，尝试合成代码：

router.route('/')
.post(function (req, response) {
    if(req.body.data){
        var obj = { id: req.body.data.product_id }
        if(req.body.data.linked_products){
            req.body.data.linked_products.forEach(function(entry) {
                obj.linked = entry; //more ifs
            });
        }
        var async = require('async');
        async.series({
            q2: function(cb){
                queryProducts.findOne({id: req.body.data.product_id, null).exec(cb);
            },
            q3: function(cb){
                queryCategories.findOne({id: req.body.data.category_id, null).exec(cb);
            }
          }, function(err, qResults){

            var alreadysent = false;
            if (qResults.q3) qResults.q3.logs.forEach(function(entry) {
                if(entry.sent){
                    alreadysent = true;
                }
            });
            //more ifs
            qResults.q3.external_codes.forEach(function(entry) {
                obj.external_code = entry;//more ifs
            });
            if(req.body.data.price < 0){
                response.json({message: "Negative price didn't sent"});
                return;
            }
            if(qResults.q2.status=="inactive"){
                response.json({message: "Inactive didn't sent"});
                return;
            }
            req.body.data.campaigns(function(entry) {
                obj.price_offers = entry;//more ifs
            });
            //more ifs and foreach similar
            queryProducts.update({id: req.body.data.id}, {$push: { synced_products: obj }}, function (err, result) {
                //HERE I found req.body.data with values of a future request

                if(!err)
                    response.json({message: "Sent"});
                return;
            });
        });
    }
});
module.exports = router;

我理解提出请求

/api/products?pid=500
/api/products?pid=501
/api/products?pid=502
/api/products?pid=503
...

有不同的时间，但是如何有可能请求（pid = 501），调用最后一个req.body来获得new req（pid = 503）的req.body的值？任何想法如何避免？在帖子之后或者制作

之后首先放异步

var reqbody = req.body

谢谢！

Answer 1

我认为这是由async模块初始化引起的。引用node docs：

缓存

模块在第一次加载后进行缓存。这意味着（除其他外）每次调用require（＆＃39; foo＆＃39;）将获得完全相同的返回对象，如果它将解析为同一文件。

多次调用require（＆＃39; foo＆＃39;）可能不会导致模块代码多次执行。这是一个重要的特征。有了它，＆＃34;部分完成＆＃34;可以返回对象，从而允许传递依赖性，即使它们会导致循环。

让模块多次执行代码，导出一个函数，然后调用该函数。

当一连串请求导致重叠执行时，您将对async变量进行两次（或更多次）使用，同时修改＆＃34;＆＃34;。我建议使用某种互斥锁来控制对async变量的访问。

MEAN Node JS在许多请求中请求性交

1 个答案: