2018 年的回调与承诺 [关闭]答案

【问题标题】：Callback vs Promise in 2018 [closed]2018 年的回调与承诺 [关闭]
【发布时间】：2019-01-16 22:00:11
【问题描述】：

现在制作异步函数的标准是什么？

我不是要在这里问基于选项的问题，而是要问 2018 年使用得更多的东西以及未来可扩展性更好的东西。

风格#1：

const client = new SteamUser();
    exports.setup = callback => {
        client.on('webSession', async (sessionID, cookies) => {
            offers.setup(client, cookies, callback);
        });

        client.on('error', err => {
           callback(error)
        });
    };

风格#2：

const client = new SteamUser();
    exports.setup = async () => {
        return new Promise(function(resolve, reject){
            client.on('webSession', async (sessionID, cookies) => {
                resolve(await offers.setup(client, cookies));
            });

            client.on('error', err => {
               reject(error)
            });
         });
        };

两者都在另一个文件中被调用：

    try{
await module.setup();
} catch(err){
console.log(err);
}

【问题讨论】：

风格#3：异步/等待
怎么样？当您使用异步等待时，您还需要承诺吗？
你问的是风格。 async/await 隐藏了承诺。
“标准”是使用util.promisify 将所有回调接受函数转换为promise。然后使用异步/等待。 ;)
你不能等待不返回承诺的东西 - 所以你的 Both called in another file by 绝对没有意义

标签： javascript node.js ecmascript-6 promise

【解决方案1】：

我认为我们应该明确地采用 try/catch 方法。 Pouchdb 文档很好地概述了它们的功能是如何以三种可能的不同方式实现的。

回调

db.allDocs({
  include_docs: true,
  attachments: true
}, function(err, response) {
  if (err) { return console.log(err); }
  // handle result
});

承诺

db.allDocs({
  include_docs: true,
  attachments: true
}).then(function (result) {
  // handle result
}).catch(function (err) {
  console.log(err);
});

异步尝试/捕获

try {
  var result = await db.allDocs({
    include_docs: true,
    attachments: true
  });
} catch (err) {
  console.log(err);
}

【讨论】：

【解决方案2】：

Promises 可帮助您获得更易读和可维护的代码。与回调相比，使用 Promise 涉及的嵌套更少。

以下代码使用回调：

someMethod = (arg) => {
    getSomething1(arg, res1 => {
        getSomething2(res1, res2 => {
            getSomething3(res2, res3 => {
                /* Do something here */
            });
        });
    })
}

上面的代码中有太多的嵌套：callback inside a callback inside a callback ...（回调地狱）。回调越多，阅读难度越大。

通过使用 Promise，它变成：

var someMethod = (arg) => {
    getSomething1(arg).then(res1 => {
        return getSomething2(res1);
    }).then(res2 => {
        return getSomething3(res2);
    }).then(res3 => {
       /* Do something here */
    });
}

而且它现在更具可读性，因为 Promise 允许您垂直链接事物。

可以通过使用异步等待进一步增强：

someMethod() = async (arg) => {
    var res1 = await getSomething1(arg);
    var res2 = await getSomething2(res1);
    var res3 = await getSomething3(res2); 
    /* Do something here */
}

它现在看起来像一个同步代码：易于阅读和维护。

【讨论】：