Question

首先，我是nodejs的新手。在API上工作，我必须在每个循环内进行多个查询。所以，我开始使用带有express的异步模块。我正在使用的确切代码是

        new_or_updated = {};
        async.each(rows, function(e, callbackParent) {
            new_or_updated.id = e.id;
            async.parallel([
                function(callback){
                    db.query("SELECT sender_string FROM  filter_positive_rules_sender WHERE rule_id = ? AND is_deleted = 0", e.id,function(err, rows, fields){
                        if (err) {
                            return callback(err);
                        }
                        new_or_updated.sender = rows.map(x => x.sender_string);
                        callback(null);
                    });
                },
                function(callback){
                    db.query("SELECT subject_string FROM filter_positive_rules_subject WHERE rule_id =  ? AND is_deleted = 0", e.id ,function(err, rows, fields){
                        if (err) {
                            return callback(err);
                        }
                        new_or_updated.subject = rows.map(x => x.subject_string);
                        callback(null);
                    });  
                },
                function(callback){
                    db.query("SELECT body_string FROM filter_positive_rules_body WHERE rule_id = ?  AND is_deleted = 0", e.id ,function(err, rows, fields){
                        if (err) {
                            return callback(err);
                        }
                        new_or_updated.body = rows.map(x => x.body_string);
                        callback(null);
                    });
                }
            ],
            function(err) {
                if (err) {
                    res.status(500).json(
                        "Internal server error"
                    ).send();
                }
                console.log(new_or_updated):
                callbackParent(null, new_or_updated);
            });

        },
        function(err, result) {
            if (err) {
                res.status(500).json(
                    "Internal server error"
                ).send();
            }
            console.log(result)
        });

如您所见，我正在尝试使用异步模块填充对象。当我在并行异步中控制new_or_updated时，数组已正确构建。但是，当我将变量发送到每个异步回调并控制它（结果变量）时，我得到了未定义。此外，当我在parentCallback中控制new_or_updated时，我只在数组中获得一个元素（使用每个异步模块的最后一个数组构建）。

我在这里做错了什么？有人可以向我解释嵌套异步实际上是如何在实践中起作用的。

Answer 1

根据async的代码库，“async.each”不是为回调中的两个参数而设计的。

它总是只用一个“err”（或没有任何参数）回调参数调用。

同时在“async.each”操作中设置全局对象的属性时，如果出现任何异步操作，将覆盖该属性。这意味着在第一次迭代中设置的“new_or_updated.id”的值可能会被“async.each”的任何后续迭代覆盖。

理想情况下，全局对象“new_or_updated”应该是一个对象数组，每个对象都有一些唯一的属性值。以便在“async.each”

中保存每次迭代的值和上下文

Answer 2

返回回调，试试这个。我正在使用async.map和async.waterfall 对不起，如果错了，英语不好的危险，我只是一个初学者，我只是一个学生。

async.map(rows, function(e, callbackParent) {
    async.waterfall([
        function(callback){
            db.query("SELECT sender_string FROM  filter_positive_rules_sender WHERE rule_id = ? AND is_deleted = 0", e.id,function(err, rows, fields){
                if (err) {
                    return callback(err);
                }
                e.sender = rows.map(x => x.sender_string);
                callback(null, e );
            });
        },
        function(Obj, callback){
            db.query("SELECT subject_string FROM filter_positive_rules_subject WHERE rule_id =  ? AND is_deleted = 0", e.id ,function(err, rows, fields){
                if (err) {
                    return callback(err);
                }
                Obj.subject = rows.map(x => x.subject_string);
                callback(null, Obj);
            });
        },
        function(Obj, callback){
            db.query("SELECT body_string FROM filter_positive_rules_body WHERE rule_id = ?  AND is_deleted = 0", e.id ,function(err, rows, fields){
                if (err) {
                    return callback(err);
                }
                Obj.body = rows.map(x => x.body_string);
                callback(null, Obj);
            });
        }
    ],
    function(err, result) {
        callbackParent(err, result);
    });
},
function(err, result) {
    if (err) {
        res.status(500).json(
            "Internal server error"
        ).send();
    }
    res.send( result )
});

我测试这是工作

function test( callback ) {
    callback( [
        {
            'name':'Anu'
        },
        {
            'name':'hem'
        }
    ] );
}
test( function( aaaaaaaaaaa ) {
    async.map( aaaaaaaaaaa, function( e, callbackParent ) {
        async.waterfall( [
            function( callback ) {
                e.number = 123;
                return callback( null, e );
            },
            function( obj, callback ) {
                obj.kelas = '1';
                return callback( null, obj );
            }
        ], function( eerr, r ) {
            callbackParent( eerr, r );
        } );
    }, function( erro, ok ) {
        res.send( ok );
    } );
} );

nodejs async并行于异步内部

2 个答案: