Node.js 使用async.parallel&；异步/等待。有没有更好的办法

这是一个更好的方法，下面的代码是有效的，我想做的是

读取schedule.json文件

处理每个主计划 同步地

子计划可以并行运行

const async=require（'async'）；
施工进度表={
“附表A”：{
“JobA”：“a.bat 1000”，
“作业b”：“b.bat 800”
},
“附表B”：{
“JobC”：“c.js 600”
},
“附表C”：{
“JobD”：“d.js 400”
},
“预定”：{
“JobE”：“e.bat 200”，
“JobF”：“f.js 0”
}  
};
var wait=（作业、睡眠时间）=>{
返回新承诺（功能（解决、拒绝）{
设置超时（（）=>{
解决（作业+“-完成”）；
}，睡眠时间）；
});
}
var executeSchedule=（sched，jobs）=>{
返回新承诺（函数（解析、拒绝）{
log（'处理计划：'+sched）；
让堆栈=[]；
设keys1=Object.keys（作业）；
for（设i=0；i{
console.log（“在结果为：+resp之后）；
解决（resp）；
});
});
});
}
常量开始=（）=>{
返回新承诺（异步函数（解析、拒绝）{
让结果=[]；
设keys1=Object.keys（明细表）；
console.log（键1）；
for（设i=0；i{
log（'Response:'+JSON.stringify（resp，null，2））；
}).catch（错误=>{
log（'Error:'+err）；
});

最终将用child_process/spawn/exec功能替换wait（），这将在windows中触发.bat和.js程序

我想知道的是

是否有更好的方法来编写程序，最初考虑使用async.series来处理主计划（目前在start（）中使用async/await）

在executeSchedule中，目前我使用的是async.parallel，也可以使用async.map。但我想知道的是，有没有更简单更好的本机nodejs方式，而不使用异步库（或）更适合这里的async

---

你可以玩承诺链

要序列化，只需实现“next”函数或使用iterable，对于并行，您只需使用

Promise.all

请注意评论中提到的“显式承诺构造反模式”，因为它会增加巨大的性能开销

这是一个工作示例，从以下内容开始：

const schedule = {
  "scheduleA": {
    "JobA": "a.bat 1000",
    "JobB": "b.bat 800"
  },
  "scheduleB": {
    "JobC": "c.js 600"
  },
  "scheduleC": {
    "JobD": "d.js 400"
  },
  "scheduleD": {
    "JobE": "e.bat 200",
    "JobF": "f.js 0"
  }
};

var wait = (job, sleepTime) => {
  return new Promise(function (resolve) {
    setTimeout(() => { resolve(job + ' - Completed'); }, sleepTime);
  });
}

var executeSchedule = (sched, jobs) => {
  console.log('Processing Schedule : ' + sched);
  const stack = Object.values(jobs).map(script => {
    const args = script.split(' ');
    return wait(args[0], args[1])
  })

  return Promise.all(stack)
    .then(resp => {
      // NOTE: this .then is useless
      console.log("After Results are: " + resp);
      return resp
    });
}

const start = async () => {
  const serial = Object.entries(schedule)
  const results = []
  const next = async () => {
    if (serial.length > 0) {
      const [key, value] = serial.shift()
      const out = await executeSchedule(key, value)
      results.push(out)
      return next()
    }
    return results
  }
  return next()
}


start()
  .then(results => {
    console.log('Response : ' + JSON.stringify(results, null, 2));
  })
  .catch(err => {
    console.log('Error : ' + err);
  });

---

避免显式承诺构造反模式！非常感谢。反模式对我来说是新的，我将开始阅读。

const schedule = {
  "scheduleA": {
    "JobA": "a.bat 1000",
    "JobB": "b.bat 800"
  },
  "scheduleB": {
    "JobC": "c.js 600"
  },
  "scheduleC": {
    "JobD": "d.js 400"
  },
  "scheduleD": {
    "JobE": "e.bat 200",
    "JobF": "f.js 0"
  }
};

var wait = (job, sleepTime) => {
  return new Promise(function (resolve) {
    setTimeout(() => { resolve(job + ' - Completed'); }, sleepTime);
  });
}

var executeSchedule = (sched, jobs) => {
  console.log('Processing Schedule : ' + sched);
  const stack = Object.values(jobs).map(script => {
    const args = script.split(' ');
    return wait(args[0], args[1])
  })

  return Promise.all(stack)
    .then(resp => {
      // NOTE: this .then is useless
      console.log("After Results are: " + resp);
      return resp
    });
}

const start = async () => {
  const serial = Object.entries(schedule)
  const results = []
  const next = async () => {
    if (serial.length > 0) {
      const [key, value] = serial.shift()
      const out = await executeSchedule(key, value)
      results.push(out)
      return next()
    }
    return results
  }
  return next()
}


start()
  .then(results => {
    console.log('Response : ' + JSON.stringify(results, null, 2));
  })
  .catch(err => {
    console.log('Error : ' + err);
  });