使用异步/等待计数来自3个不同循环的错误，这些循环在每次迭代时调用异步函数

我对Async / Await和Promises不熟悉，但对回调不陌生。

在node.JS服务器上，我试图计算来自3个不同的异步函数的数千个异步调用中的错误，然后我想记录发生的错误数量。我具有以下功能结构：

var sender = require('./sender');
module.exports = {
    mainFunc : function (dataObjct){
        this.func1(dataObjct.arr1);
        this.func2(dataObjct.arr2);
        this.func3(dataObjct.arr3);
    },
    func1 : function (arr){
        for(let i=0;i<arr.length;i++){
            sender.method1(arr[i]);
            //sleep for 100 seconds cause i don't want too many messages at the same time
            new Promise(resolve => setTimeout(resolve, '100'));
        }
    },
    func2 : function (arr){
        for(let i=0;i<arr.length;i++){
            sender.method2(arr[i]);
            //sleep for 100 seconds cause i don't want too many messages at the same time
            new Promise(resolve => setTimeout(resolve, '100'));
        }
    },
    func3 : function (arr){
        for(let i=0;i<arr.length;i++){
            sender.method3(arr[i]);
            //sleep for 100 seconds cause i don't want too many messages at the same time
            new Promise(resolve => setTimeout(resolve, '100'));
        }
    }
}

现在sender.method1，sender.method2和sender.method3都位于不同的文件中，并且它们内部都有一个异步调用。例如，这里是sender.method1：

method1 : function(options){
    const from = options.from;
    const to = options.to;
    const text = options.text;
    someAsyncFunction(function(err,data) {if(err) console.log(err);},from,to,text);
}

我想计算从sender.method1，sender.method2和sender.method3出现的所有错误，并仅在来自所有循环的所有异步调用完成后才记录该错误数。

澄清我知道我的代码还没有准备好做我想做的事情，我的问题是如何修改代码以实现我的目标。即使这意味着要以其他方式重写所有内容。

同步您的sender.methodx

按承诺

method1 : function(options){
    const from = options.from;
    const to = options.to;
    const text = options.text;
    //ensure someAsyncFunction is a promise
    return someAsyncFunction(function(err,data) {if(err) console.log(err);},from,to,text);
}

或通过回调（好的方法）

method1 : function(options, cb){
    ...
    return someAsyncFunction(function(err,data) {
        if(err){return cb(err)}
        return cb(null);
    },from,to,text);
}

我假设您返回promise

延迟您的批量

func1 : function (arr, oStat){
    return arr.reduce((acc, x)=>{
        //wait at least 100ms before next sender.method call
        return Promise.all([
            sender.methodX(x),
            new Promise(resolve => setTimeout(resolve, 100))//no need to be a string btw
        ])
    }, Promise.resolve())
}

捕获您的发送方方法错误以进行跟踪计数

这里认为：methodX之间的共享变量，以便在methodX终止之前有一个想法：

mainFunc : function (dataObjct){
    let stats = {data1:{}, data2:{}, data3:{}};
    this.func1(dataObjct.arr1, stats.data1);
    this.func2(dataObjct.arr2, stats.data2);
    this.func3(dataObjct.arr3, stats.data3);
},
func1 : function (arr, oStat){
    oStat.count = 0;
    return arr.reduce((acc, x)=>{
        //wait at least 100ms before next sender.method call
        return Promise.all([
            sender.methodX(x).catch(e=>{
                oStat.count++;
            }),
            new Promise(resolve => setTimeout(resolve, 100))//no need to be a string btw
        ])
    }, Promise.resolve())
},

同步您的mainFunc

您不想再现someAsyncFunction的不可同步状态，所以不要在空白处触发异步内容

mainFunc : function (dataObjct){
    let stats = {data1:{}, data2:{}, data3:{}};
    return Promise.all([
        this.func1(dataObjct.arr1, stats.data1),
        this.func2(dataObjct.arr2, stats.data2),
        this.func3(dataObjct.arr3, stats.data3)
    ])
},

使用异步/等待计数来自3个不同循环的错误，这些循环在每次迭代时调用异步函数

我对Async / Await和Promises不熟悉，但对回调不陌生。

在node.JS服务器上，我试图计算来自3个不同的异步函数的数千个异步调用中的错误，然后我想记录发生的错误数量。我具有以下功能结构：

var sender = require('./sender');
module.exports = {
    mainFunc : function (dataObjct){
        this.func1(dataObjct.arr1);
        this.func2(dataObjct.arr2);
        this.func3(dataObjct.arr3);
    },
    func1 : function (arr){
        for(let i=0;i<arr.length;i++){
            sender.method1(arr[i]);
            //sleep for 100 seconds cause i don't want too many messages at the same time
            new Promise(resolve => setTimeout(resolve, '100'));
        }
    },
    func2 : function (arr){
        for(let i=0;i<arr.length;i++){
            sender.method2(arr[i]);
            //sleep for 100 seconds cause i don't want too many messages at the same time
            new Promise(resolve => setTimeout(resolve, '100'));
        }
    },
    func3 : function (arr){
        for(let i=0;i<arr.length;i++){
            sender.method3(arr[i]);
            //sleep for 100 seconds cause i don't want too many messages at the same time
            new Promise(resolve => setTimeout(resolve, '100'));
        }
    }
}

现在sender.method1，sender.method2和sender.method3都位于不同的文件中，并且它们内部都有一个异步调用。例如，这里是sender.method1：

method1 : function(options){
    const from = options.from;
    const to = options.to;
    const text = options.text;
    someAsyncFunction(function(err,data) {if(err) console.log(err);},from,to,text);
}

我想计算从sender.method1，sender.method2和sender.method3出现的所有错误，并仅在来自所有循环的所有异步调用完成后才记录该错误数。

澄清我知道我的代码还没有准备好做我想做的事情，我的问题是如何修改代码以实现我的目标。即使这意味着要以其他方式重写所有内容。

同步您的sender.methodx

按承诺

method1 : function(options){
    const from = options.from;
    const to = options.to;
    const text = options.text;
    //ensure someAsyncFunction is a promise
    return someAsyncFunction(function(err,data) {if(err) console.log(err);},from,to,text);
}

或通过回调（好的方法）

method1 : function(options, cb){
    ...
    return someAsyncFunction(function(err,data) {
        if(err){return cb(err)}
        return cb(null);
    },from,to,text);
}

我假设您返回promise

延迟您的批量

func1 : function (arr, oStat){
    return arr.reduce((acc, x)=>{
        //wait at least 100ms before next sender.method call
        return Promise.all([
            sender.methodX(x),
            new Promise(resolve => setTimeout(resolve, 100))//no need to be a string btw
        ])
    }, Promise.resolve())
}

捕获您的发送方方法错误以进行跟踪计数

这里认为：methodX之间的共享变量，以便在methodX终止之前有一个想法：

mainFunc : function (dataObjct){
    let stats = {data1:{}, data2:{}, data3:{}};
    this.func1(dataObjct.arr1, stats.data1);
    this.func2(dataObjct.arr2, stats.data2);
    this.func3(dataObjct.arr3, stats.data3);
},
func1 : function (arr, oStat){
    oStat.count = 0;
    return arr.reduce((acc, x)=>{
        //wait at least 100ms before next sender.method call
        return Promise.all([
            sender.methodX(x).catch(e=>{
                oStat.count++;
            }),
            new Promise(resolve => setTimeout(resolve, 100))//no need to be a string btw
        ])
    }, Promise.resolve())
},

同步您的mainFunc

您不想再现someAsyncFunction的不可同步状态，所以不要在空白处触发异步内容

mainFunc : function (dataObjct){
    let stats = {data1:{}, data2:{}, data3:{}};
    return Promise.all([
        this.func1(dataObjct.arr1, stats.data1),
        this.func2(dataObjct.arr2, stats.data2),
        this.func3(dataObjct.arr3, stats.data3)
    ])
},