这是处理JavaScript承诺的正确方法吗？

请原谅，我对JS的承诺还不熟悉。我想我需要使用一个与AWS服务交互，AWS服务向DynamoDB写入数据并从中提取数据。我有一个JavaScript应用程序，由无服务器npm插件运行，该插件将导出的函数定义为端点。在这些端点中，在承诺完成后，我需要将数据冒泡回端点，以将其作为JSON主体公开。请参阅下面的代码

exports.getBlog = async (event) => {
    return getBlogPost(event).then((data) => {
        console.log("worked", data);
        var response =  {
            statusCode: 200,
            body: JSON.stringify(data)
        };

        return response;
    })
    .catch((error) => {
        console.log("didn't work");
        var response = {
            statusCode: 400,
            body: JSON.stringify(error.toString())
        };

        return response;
    });
}

让我觉得这不对的是，我必须创建一个

var响应

并返回它，然后在

exports.getBlog

的根目录下再次返回。是这样吗？它可以正确地打印JSON，但在线阅读教程时我感到困惑，这是否是一种好的做法

如果不是，您将如何从promise返回数据并将其作为JSON结果公开

在本例中，

exports.getBlog

被无服务器框架引用为端点，如下所示：-

functions:
  get-blog:
    handler: api/blog.getBlog
    events:
      - http:
          path: api/v1/blog
          method: GET
          cors: true

---

你把两者混为一谈。下面是异步/等待

 exports.getBlog = async (event) => {
 try {
    var res = await getBlogPost(event);
    var data = res.data;
    console.log("worked", data);
    var response =  {
        statusCode: 200,
        body: JSON.stringify(data)
    };

    return response;
} catch(error) {
    console.log("didn't work");
    var response = {
        statusCode: 400,
        body: JSON.stringify(error.toString())
    };

    return response;
   }
}

没有

exports.getBlog = event => {
    return getBlogPost(event).then((data) => {
    console.log("worked", data);
    var response =  {
        statusCode: 200,
        body: JSON.stringify(data)
    };

    return response;
})
.catch((error) => {
    console.log("didn't work");
    var response = {
        statusCode: 400,
        body: JSON.stringify(error.toString())
    };

    return response;
});
}

好书：

---

编辑：添加async/await，以及如何用它重写promise代码

您将两者混为一谈。下面是异步/等待

 exports.getBlog = async (event) => {
 try {
    var res = await getBlogPost(event);
    var data = res.data;
    console.log("worked", data);
    var response =  {
        statusCode: 200,
        body: JSON.stringify(data)
    };

    return response;
} catch(error) {
    console.log("didn't work");
    var response = {
        statusCode: 400,
        body: JSON.stringify(error.toString())
    };

    return response;
   }
}

没有

exports.getBlog = event => {
    return getBlogPost(event).then((data) => {
    console.log("worked", data);
    var response =  {
        statusCode: 200,
        body: JSON.stringify(data)
    };

    return response;
})
.catch((error) => {
    console.log("didn't work");
    var response = {
        statusCode: 400,
        body: JSON.stringify(error.toString())
    };

    return response;
});
}

好书：

---

编辑：添加async/await以及如何用它重写promise代码有两种主要的编写promise的方法，第一种是使用resolve和reject函数，第二种是使用.then and.catch函数

第一个案例：

let promise = new Promise(function(resolve, reject) {
  setTimeout(() => reject(new Error("Whoops!")), 1000);
});

// reject runs the second function in .then
promise.then(
  result => alert(result), // doesn't run
  error => alert(error) // shows "Error: Whoops!" after 1 second
);

第二个例子：

let promise = new Promise(function(resolve, reject) {
  setTimeout(() => reject(new Error("Whoops!")), 1000);
});

// reject runs the second function in .then
promise.then(
  result => alert(result), // doesn't run
  error => alert(error) // shows "Error: Whoops!" after 1 second
);

如果我们只对成功完成感兴趣，那么我们只能向提供一个函数参数。然后：

let promise = new Promise(resolve => {
  setTimeout(() => resolve("done!"), 1000);
});

promise.then(alert); // shows "done!" after 1 second

如果我们只对错误感兴趣，那么可以使用null作为第一个参数：。然后（null，errorHandlingFunction）。或者我们可以使用.catch（errorHandlingFunction），它完全相同：

let promise = new Promise((resolve, reject) => {
  setTimeout(() => reject(new Error("Whoops!")), 1000);
});

// .catch(f) is the same as promise.then(null, f)
promise.catch(alert); // shows "Error: Whoops!" after 1 second

---

有两种主要的方法来编写承诺：首先使用resolve和reject函数，然后使用and.catch函数

第一个案例：

let promise = new Promise(function(resolve, reject) {
  setTimeout(() => reject(new Error("Whoops!")), 1000);
});

// reject runs the second function in .then
promise.then(
  result => alert(result), // doesn't run
  error => alert(error) // shows "Error: Whoops!" after 1 second
);

第二个例子：

let promise = new Promise(function(resolve, reject) {
  setTimeout(() => reject(new Error("Whoops!")), 1000);
});

// reject runs the second function in .then
promise.then(
  result => alert(result), // doesn't run
  error => alert(error) // shows "Error: Whoops!" after 1 second
);

如果我们只对成功完成感兴趣，那么我们只能向提供一个函数参数。然后：

let promise = new Promise(resolve => {
  setTimeout(() => resolve("done!"), 1000);
});

promise.then(alert); // shows "done!" after 1 second

如果我们只对错误感兴趣，那么可以使用null作为第一个参数：。然后（null，errorHandlingFunction）。或者我们可以使用.catch（errorHandlingFunction），它完全相同：

let promise = new Promise((resolve, reject) => {
  setTimeout(() => reject(new Error("Whoops!")), 1000);
});

// .catch(f) is the same as promise.then(null, f)
promise.catch(alert); // shows "Error: Whoops!" after 1 second

---

谢谢你。我担心我在混什么东西。我会试一试的，谢谢@当然可以。关于第二个示例中的2个返回，我相信如果您同时删除{}，那么可以删除第一个返回，因此它将是exports.getBlog=event=>getBlogPost（event）。然后，

async

/

wait

代码段中的

.catch

不起作用，链接的文章大部分是balderdash，特别是书名。@Roamer-1888所以我想你写了/知道一个更好的，可以和我们分享吗？谢谢。我担心我在混什么东西。我会试一试的，谢谢@当然可以。关于第二个示例中的2个返回，我相信如果您同时删除{}，那么可以删除第一个返回，因此它将是exports.getBlog=event=>getBlogPost（event）。然后，

async

/

wait

代码段中的

.catch

不起作用，链接的文章大部分是balderdash，特别是标题。@Roamer-1888所以我想你写了/知道了一个更好的，可以与我们分享吗？如果

getBlog（）

应该返回一个承诺，并且如果你想在出现错误时解决（而不是拒绝）该承诺，那么这将实现该目标。

返回响应

通过从

.then（）

或

.catch（）

处理程序返回值来设置承诺的解析值。

return getBlogPost（）中的
return
。然后（…）.catch（…）

从函数返回承诺。你确实需要两者来实现你的目标，这是一个完美的实践。现在，在出现错误时解决承诺（而不是拒绝承诺）有点非常规。这取决于调用者期望的内容以及调用代码的编写方式。如果

getBlog（）

应该返回一个承诺，并且即使出现错误，您也希望该承诺得到解决（而不是拒绝），那么这将实现该目标。

返回响应

通过从

.then（）

或

.catch（）

处理程序返回值来设置承诺的解析值。

return getBlogPost（）中的
return
。然后（…）.catch（…）

从函数返回承诺。你确实需要两者来实现你的目标，这是一个完美的实践。现在，在出现错误时解决承诺（而不是拒绝承诺）有点非常规。这取决于调用方期望的内容以及调用代码的编写方式。