Promise 如何在 Node.js 和 AWS lambda 函数中工作

Question

总的来说，我对 Javascript 和 Node.js 很陌生。因此，我试图了解 Node.js 中异步编程的概念以及如何在 AWS lambda 中使用它。

我在亚马逊博客上看到了这篇博文，它解释了 Node.js lambda 函数中对 async/await 的支持：https : //aws.amazon.com/blogs/compute/node-js-8-10-runtime-now-在 aws-lambda/ 中可用

据我所知，生成承诺的函数的概念如下面的代码片段所示：

const func1 = () => {
    console.log("Starting with execution of func1...")
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve("First promise ended after 3 secs")
        }, 3000)
    })
}

所以在这里函数显式地生成一个 Promise 并返回相同的。

但是在上面的 AWS 博客文章中，我看到了一个函数定义：

let AWS = require('aws-sdk');
let lambda = new AWS.Lambda();

exports.handler = async (event) => {
    return await lambda.getAccountSettings().promise() ;
};

现在我已经检查了 Node.js 文档的 AWS SDK（https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html#getAccountSettings-property），我看到函数 getAccountSettings 接受回调为第三个参数。

我.promise()对生成 promise的语法感到困惑。函数如何确保使用该语法返回一个 promise 对象。因为从文档中没有提到如果我使用.promise()它会返回一个承诺。我假设在这方面可能有一个经验法则。

也不是return await lambda.getAccountSettings().promise()如果我只是写下return await lambda.getAccountSettings()它会有什么不同。

有没有关于这方面的文件可以参考？

请求您对这种获取 promise 对象的新方法提供更多信息。

提前感谢您的任何帮助。

Answer 1

如果您想了解为什么该.promise()方法可用，以及为什么不只是像这样返回承诺，请注意此类 API 如何随时间演变，并且必须保持向后兼容性。

让我们构建一些类似的东西，但要简化得多。让我们创建一个函数，它为给定数字提供 1/x，但在 x=0 时提供错误对象。这将异步完成。

此外，我们希望该函数同步返回一个对象，该对象允许一个对象在发生错误时注册一个侦听器，另一个在成功时注册一个侦听器，另一个在两者中的任何一个发生时注册一个侦听器。这是 AWS 返回的一个非常简单的想法：在那里你会得到一个非常丰富的Request对象。

因此，想象一下我们在 2012 年，并且 Promise 尚未在 JavaScript 中广泛使用/使用。因此，我们为异步 1/x 函数提供了以下 API：

// Implementation in the first version of the API (without promises):
//    * returns an object with which you can register a listener
//    * accepts an optional callback
function getAsyncInverse(num, callback) {
    var onSuccess = [], // callbacks that are called on success
        onError = [], // callbacks that are called on failure
        onComplete = [];  // callbacks that are called in both situations
    if (callback) onComplete.push(callback);
    
    function complete(err=null) {
        var result = null;
        if (num === 0) err = new Error("Division by Zero");
        else result = 1/num;
        // Communicate the result/error to the appropriate listeners:
        if (err) for (var i = 0; i < onError.length; i++) onError[i](err);
        else for (var i = 0; i < onSuccess.length; i++) onSuccess[i](result);
        for (var i = 0; i < onComplete.length; i++) onComplete[i](err, result);
    }

    var timeoutId = setTimeout(complete, 100);

    var request = {
        on: function (type, callback) {
            if (type === "success") onSuccess.push(callback);
            else if (type === "error") onError.push(callback);
            else if (type === "complete") onComplete.push(callback);
            return request;
        },
        abort: function () {
            clearTimeout(timeoutId);
            complete(new Error("aborted"));
            return request;
        }
    }
    
    return request;
}

// How version 1 is used, by registering a listener via the returned object
var num = 2;
var request = getAsyncInverse(num); // let's not pass a callback here
request.on("success", function (result) { // ... but use the request object
    console.log("The result is:", result);    
}).on("error", function (err) {
    console.log("There was an error:", err);
});

但随后承诺变得越来越流行，您的 API 的用户正在推动承诺 API。您希望确保向后兼容，因此决定仅使用一个附加属性（一种方法）扩展返回的请求对象：promise()

以下是如何更改上述实现以实现这一目标：

// Implementation in the second version of the API (with promise), but backwards-compatible
//    * returns an object with which you can register a listener, or get the promise object
//    * accepts an optional callback
function getAsyncInverse(num, callback) {
    let onSuccess = [], // callbacks that are called on success
        onError = [], // callbacks that are called on failure
        onComplete = [];  // callbacks that are called in both situations
    if (callback) onComplete.push(callback);
    
    let request;
    // New: create a promise, and put the logic inside the promise-constructor callback
    let promise = new Promise(function (resolve, reject) {
        function complete(err=null) {
            let result = null;
            if (num === 0) err = new Error("Division by Zero");
            else result = 1/num;
            // Communicate the result/error to the appropriate listeners:
            if (err) for (let callback of onError) callback(err);
            else for (let callback of onSuccess) callback(result);
            for (let callback of onComplete) callback(err, result);
            // New: also call resolve/reject
            if (err) reject(err);
            else resolve(result);
        }

        let timeoutId = setTimeout(complete, 100);
        
        request = {
            on: function (type, callback) {
                if (type === "success") onSuccess.push(callback);
                else if (type === "error") onError.push(callback);
                else if (type === "complete") onComplete.push(callback);
                return request;
            },
            abort: function () {
                clearTimeout(timeoutId);
                complete(new Error("aborted"));
                return request;
            },
            promise: function () { // <--- added feature!
                return promise;
            }
        };
    });

    return request; // We return the same as in version-1, but with additional promise method
}

// How version 2 is used, by getting the new promise method
let num = 2;
let promise = getAsyncInverse(num).promise();
promise.then(function (result) {
    console.log("The result is:", result);    
}).catch(function (err) {
    console.log("There was an error:", err);
});

如您所见，省略请求对象并让函数返回承诺并不是一个好主意。这会使用您的 API 破坏现有代码（没有向后兼容性）。