node.js - NodeJS 嵌套 promise

Question

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

1. 连接到redis
2. 从redis HASH 获取key 的数据。 (对 redis 的异步调用)
3. 如果您从第 2 步中获取数据(它将返回一个 JSON 数据)，然后在 JSON 中操作一些内容
4. 如果您从第 2 步获取数据，则调用另一个异步 API，该 API 将从 redis 获取数据并将其添加到之前收到的 JSON。

5. 如果在第 4 步中出现任何错误(拒绝)，则返回错误。

6. 如果您从第 2 步中得到 null，则从另一个散列中获取数据使用相同的 key (对 redis 的异步调用)

7. 如果您从第 6 步获得数据(它将返回一个 JSON 数据)，然后在 JSON 中操作一些东西
8. 如果您从第 6 步获取数据，则调用另一个异步 API，该 API 将从 redis 获取数据并将其添加到之前收到的 JSON。

9. 如果在第 8 步中出现任何错误(拒绝)，则返回错误。

10. 断开与 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. Step 3 & 7 - 重复步骤
2. Step 4 & 8 - 重复步骤
3.多个catch block
4.多次返回关闭连接。

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

   redisConnection.on('connect', function(){
    let data = cache.getFromHash(hash1, key)
    if (! data) {
            data = cache.getFromHash(hash2, key)
    }
    let moreData = cache.getMultipleFromHash(hash3, keys)
    data.cost = 1000;
    data.moreData = moreData;
    connection.quit();
    return data;
})

我们可以让这个异步代码更清晰还是别无选择？

提前致谢!

Answer 1

你可以尝试这样的事情。

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))

如果您想要自定义错误处理，您可以将每个 await 包装在一个 try catch block 中。