2018年的Callback vs Promise

Question

如今，异步功能的标准是什么？

我不是在这里问基于选项的问题，而是要问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);
}

Answer 1

承诺可帮助您拥有更具可读性和可维护性的代码。与回调相比，使用promise的嵌套更少。

下面的代码使用回调：

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

上面的代码中有太多嵌套：回调内部的回调...回调内部（回调地狱）。您拥有的回调越多，阅读起来就越困难。

通过使用Promise，它将变为：

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

现在，它更加可读，因为promise允许您垂直链接事物。

可以使用async await进一步增强它：

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

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