Javascript 如何按顺序执行四个异步函数？

我使用的这段代码包含四个异步函数。 我需要他们严格执行命令
如果他们将按照示例中给出的顺序执行，我该如何执行
我的用例在Lambda中，我可以访问async

    function scanProducts() {
      dynamoClient.scan(productParams, function (err, data) {

      });
    }

    function scanCoupons() {
      dynamoClient.scan(couponsParams, function (err, data) {

      });
    }

    function scanRetailers() {
      dynamoClient.scan(retailerParams, function (err, data) {

      });
    }

    function sendEmail(ses) {
      var email = {
        "Source": "test@gmail.com",
        "Template": "test-template",
        "Destination": {
          "ToAddresses": ["test@gmail.com"]
        },
        "TemplateData": `{}`
      }

      ses.sendTemplatedEmail(email);
    }

---

我会将

dynamoClient.scan

转换为基于承诺的函数，然后

等待它的每次调用，例如：

const dynamoClientScanProm = (params) => new Promise((resolve, reject) => {
  dynamoClient.scan(params, function (err, data) {
    if (err) reject(err);
    else resolve(data);
  });
});

// ...
// in an async function:

try {
  await dynamoClientScanProm(productParams);
  await dynamoClientScanProm(couponsParams);
  await dynamoClientScanProm(retailerParams);

  // promisify/await this too, if it's asynchronous
  ses.sendTemplatedEmail(email);
} catch(e) {
  // handle errors
}

不清楚您是否需要使用调用的结果，但是如果您确实需要结果，而不只是需要等待承诺解决，请在
wait
ing时为变量赋值，例如

const productResults = await dynamoClientScanProm(productParams);

也就是说，如果结果没有被
dynamoClientScanProm
的其他调用使用，那么并行运行所有调用（使用
Promise.all
）比串行运行更有意义，这样整个过程可以更快完成。
我会将
dynamoClient.scan
转换为基于Promise的函数，然后等待它的每次调用，例如：

const dynamoClientScanProm = (params) => new Promise((resolve, reject) => {
  dynamoClient.scan(params, function (err, data) {
    if (err) reject(err);
    else resolve(data);
  });
});

// ...
// in an async function:

try {
  await dynamoClientScanProm(productParams);
  await dynamoClientScanProm(couponsParams);
  await dynamoClientScanProm(retailerParams);

  // promisify/await this too, if it's asynchronous
  ses.sendTemplatedEmail(email);
} catch(e) {
  // handle errors
}

不清楚您是否需要使用调用的结果，但是如果您确实需要结果，而不只是需要等待承诺解决，请在
wait
ing时为变量赋值，例如

const productResults = await dynamoClientScanProm(productParams);

也就是说，如果结果没有被
dynamoClientScanProm
的其他调用使用，那么并行运行所有调用（使用
Promise.all
）比串行运行更有意义，这样整个过程可以更快地完成。
回答：
您可以根据使用来执行承诺的异步执行。这可以打包成一个构造函数，在示例中它被称为
Serial
（因为我们要按顺序逐个检查承诺）

上面是什么？

它是一个名为
Serial
的构造函数
它将返回承诺的函数数组作为参数
这些函数存储在
串行模式中。
它有一个空数组存储在
串行中。已解析
-这将存储已解析的承诺请求
它有两种方法：

addPromise
：获取一个函数，该函数返回一个承诺并将其添加到
Serial.promises
resolve
：异步调用自定义
符号。迭代器
。这个
迭代器
遍历每一个承诺，等待它完成，并将其添加到
Serial.resolved
。完成后，它返回一个map函数，该函数作用于填充的
Serial.resolved
数组。这使您可以简单地调用
resolve
，然后提供一个回调，说明如何处理响应中的成员。如果将承诺返回给该函数，则可以传递一个
函数，然后将整个数组传递给
函数



例如：

  promises.resolve((resolved_request) => { 
     //do something with each resolved request 

       return resolved_request;
  }).then((all_resolved_requests) => { 

     // do something with all resolved requests

  });

下面的示例显示了如何将其用于产生巨大的效果，无论您是希望在每个单独的分辨率上发生一些事情，还是等待所有事情完成

请注意，它们总是按顺序排列。第一个定时器设置为最高的
ms
计数，这一点很明显。第二个承诺在第一个承诺完成之前不会开始，第三个承诺在第二个承诺完成之前不会开始，等等

这使我想到一个重要的问题。尽管将您的承诺按顺序序列化是有效的，但重要的是要认识到，如果您的承诺占用了任何一个时间，那么这将延迟您对数据的响应。并行的美妙之处在于，如果一切顺利，所有请求都需要更短的时间来完成。如果一个应用程序有多个必需的请求，序列化之类的东西非常有用，如果一个请求不可用，或者一个项目依赖另一个（非常常见），整个过程都会失败


//助手
让log=console.log.bind（console），
承诺=串行（），
计时器=（标记，毫秒）=>（）=>新承诺（res=>{
设置超时（（）=>{
res（“成品”+标签）；
}，ms）}）；
函数序列（promissions=[]）{
返回{
承诺，
已解决：[]，
附加承诺：功能（fn）{
承诺推动（fn）；
},
解析：异步函数（cb=i=>i，err=（e）=>console.log（“trace:Serial.resolve”+e））{
试一试{
对于wait（设这个[Symbol.iterator]（））的p{}
返回此.resolved.map（cb）；
}捕获（e）{
错误（e）；
}
},
[符号.迭代器]：异步函数*（）{
此参数为[]；
为了（让我们承诺这个。承诺）{
让p=wait promise（）.catch（e=>console.log（“trace:Serial[Symbol.iterator]：：”+e））；
这个。解析。推（p）；
产量p；
}
}
}
}
承诺。添加承诺（计时器（1，3000））；
承诺。添加承诺（计时器（21000））；
承诺.addPromise（timer（32000））；
承诺
.resolve（msg=>（日志（msg），msg））
.然后（（完成）=>log（“一切都已完成：+complete”）答案：
您可以根据使用来执行承诺的异步执行。这可以打包成一个构造函数，在示例中它被称为
Serial
（因为我们要按顺序逐个检查承诺）

上面是什么？

它是一个名为
Serial
的构造函数
它将返回承诺的函数数组作为参数
这些函数存储在
串行模式中。
它有一个空数组存储在
串行中。已解析
-这将存储已解析的承诺请求
它有两种方法：

addPromise
：获取一个函数，该函数返回一个承诺并将其添加到
Serial.promises
resolve
：异步调用自定义
符号。迭代器
。这个