Node.js NodeJS嵌套承诺

我有一个场景，我必须使用AWS lambda从Redis获取数据

连接到redis

从redis哈希中获取密钥的数据。（对redis的异步调用）

如果您从步骤2获得数据（它将返回一个JSON数据），那么可以在JSON中操作一些东西

如果您从步骤2中获取数据，那么调用另一个异步API，该API将从redis获取数据，并将其添加到以前收到的JSON中

如果在步骤4中出现任何错误（拒绝），则返回错误

如果您从步骤2中得到空值，那么从另一个散列中得到数据 使用相同的密钥（对redis的异步调用）

如果您从步骤6获得数据（它将返回一个JSON数据），那么可以在JSON中操作一些东西

如果您从步骤6获取数据，那么调用另一个异步API，该API将从redis获取数据，并将其添加到以前收到的JSON中

如果在步骤8中出现任何错误（拒绝），则返回错误

断开与redis的连接

现在我不确定是否要用这些嵌套的和依赖的调用编写干净的代码nodeJS

redisConnection.on('connect', function(){ //Step 1
cache.getFromHash(hash1, key) //Step2
.then(data => {
    if(data){
        data.cost = 1000; // step3
        cache.getMultipleFromHash(hash3, keys) //step4
        .then(moredata => {
            data.moredata = moredata;
            const response = {
                statusCode: 200,
                body: JSON.stringify(data),
            };
            redisConnection.quit();
            callback(null, response);
        })
        .catch(err => { // step5
            const response = {
                statusCode: 200,
                body: JSON.stringify({"err": err}),
            };
            redisConnection.quit();
            callback(null, response);
         })
    } else {
        cache.getFromHash(hash2, key) // step6
        .then(defaultData => {
            defaultData.cost = 1000; // step7
            cache.getMultipleFromHash(hash3, keys) //step8
            .then(moreData => {
                data.moreData = moreData;
                const response = {
                    statusCode: 200,
                    body: JSON.stringify(data),
                  };
                  redisConnection.quit();
                callback(null, response);
            })
            .catch(err => { // Step 9
                const response = {
                    statusCode: 200,
                    body: JSON.stringify({"err": err}),
                };
                redisConnection.quit();
                callback(null, response);
             })
        })
        .catch(err => {
            const response = {
                statusCode: 200,
                body: JSON.stringify({"err": err}),
            };
            redisConnection.quit();
            callback(null, response);
        })
    }
})
.catch(err => {
    const response = {
        statusCode: 200,
        body: JSON.stringify({"err": err}),
    };
    redisConnection.quit();
    callback(null, response);
})
})

在这段代码中，我们可以看到：
1.步骤3和7-重复步骤
2.步骤4和8-重复步骤
3.多个捕捉块
4.多重返回和紧密连接

如果我在同步编程中编写相同的代码，那么它将是这样的（假设）：

我们可以让这个异步代码更清晰，还是没有选择

---

提前谢谢

你可以试试这样的东西

async yourFunction(){
redisConnection.on('connect', function(){ //Step 1
    try{
      let data = await cache.getFromHash(hash1, key) //Step2
      if(data){
        data.cost = 1000;
        let moredata = await cache.getMultipleFromHash(hash3, keys);
        data.moredata = moredata;
        const response = {
            statusCode: 200,
            body: JSON.stringify(data),
        };
        redisConnection.quit();
        callback(null, response);
      }
      else{
        let defaultData = await cache.getFromHash(hash2, key);
        defaultData.cost = 1000; // step7
        let moreData = await cache.getMultipleFromHash(hash3, keys) //step8
        data.moreData = moreData;
        const response = {
            statusCode: 200,
            body: JSON.stringify(data),
          };
          redisConnection.quit();
        callback(null, response);
      }
    }
    catch(error){
      const response = {
          statusCode: 200,
          body: JSON.stringify({"err": err}),
      };
      redisConnection.quit();
      callback(null, response);
    }
  }
}

yourFunction().then(result => console.log(result))

---

如果需要自定义错误处理，可以将每个等待包装在try-catch块中

你看过

async/await

的

Promise

语法了吗？尝试以更好的方式使用Promise链接。尝试了async/await&链接这两种方法，但仍然不是很干净的代码。当我必须在for循环中为多个键运行这个时，它会变得更复杂。你可以检查aync（）库，并使用异步函数调用next逐个执行。我相信函数列表可以解决你的问题。

async yourFunction(){
redisConnection.on('connect', function(){ //Step 1
    try{
      let data = await cache.getFromHash(hash1, key) //Step2
      if(data){
        data.cost = 1000;
        let moredata = await cache.getMultipleFromHash(hash3, keys);
        data.moredata = moredata;
        const response = {
            statusCode: 200,
            body: JSON.stringify(data),
        };
        redisConnection.quit();
        callback(null, response);
      }
      else{
        let defaultData = await cache.getFromHash(hash2, key);
        defaultData.cost = 1000; // step7
        let moreData = await cache.getMultipleFromHash(hash3, keys) //step8
        data.moreData = moreData;
        const response = {
            statusCode: 200,
            body: JSON.stringify(data),
          };
          redisConnection.quit();
        callback(null, response);
      }
    }
    catch(error){
      const response = {
          statusCode: 200,
          body: JSON.stringify({"err": err}),
      };
      redisConnection.quit();
      callback(null, response);
    }
  }
}

yourFunction().then(result => console.log(result))