Question

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

连接到Redis
从redis HASH获取数据以获取密钥。（异步调用redis）
如果您从第2步中获取数据（它将返回JSON数据），请使用JSON操作
如果您从第2步中获取数据，则调用另一个异步API，该API将从redis获取数据并将其添加到先前接收的JSON中。
如果在步骤4中发生任何错误（拒绝），则返回错误。
如果您从步骤2中获得了null，则从另一个哈希中获取数据使用相同的键（异步调用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.多次返回和关闭连接。

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

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

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

NodeJS嵌套诺言

1 个答案: