承诺不只是回调吗？

Question

我已经开发 JavaScript 几年了，我根本不理解对承诺的大惊小怪。

似乎我所做的只是改变：

api(function(result){
    api2(function(result2){
        api3(function(result3){
             // do work
        });
    });
});

无论如何，我都可以使用像async这样的库，例如：

api().then(function(result){
     api2().then(function(result2){
          api3().then(function(result3){
               // do work
          });
     });
});

哪个代码更多，可读性更低。 我在这里没有任何收获，它也不是突然神奇地“平坦”。 更不用说必须将事情转换为承诺。

那么，这里的承诺有什么大惊小怪的呢？

Answer 1

承诺不是回调。 承诺代表异步操作的未来结果。 当然，按照您的方式编写它们，您几乎没有什么好处。 但是，如果您按照它们的使用方式编写它们，则可以以类似于同步代码的方式编写异步代码，并且更易于遵循：

api().then(function(result){
    return api2();
}).then(function(result2){
    return api3();
}).then(function(result3){
     // do work
});

当然，不是更少的代码，而是更具可读性。

但这还不是结束。 让我们发现真正的好处：如果您想检查任何步骤中的任何错误怎么办？ 用回调来做这件事会很糟糕，但用承诺，是小菜一碟：

api().then(function(result){
    return api2();
}).then(function(result2){
    return api3();
}).then(function(result3){
     // do work
}).catch(function(error) {
     //handle any error that may occur before this point
});

与try { ... } catch块几乎相同。

更好的是：

api().then(function(result){
    return api2();
}).then(function(result2){
    return api3();
}).then(function(result3){
     // do work
}).catch(function(error) {
     //handle any error that may occur before this point
}).then(function() {
     //do something whether there was an error or not
     //like hiding an spinner if you were performing an AJAX request.
});

甚至更好：如果对api 、 api2 、 api3这 3 个调用可以同时运行（例如，如果它们是 AJAX 调用），但您需要等待这三个调用呢？ 没有承诺，你应该创建某种计数器。 使用 ES6 表示法的 promise 是另一块蛋糕，而且非常整洁：

Promise.all([api(), api2(), api3()]).then(function(result) {
    //do work. result is an array contains the values of the three fulfilled promises.
}).catch(function(error) {
    //handle the error. At least one of the promises rejected.
});

希望你现在以新的眼光看待 Promises。

Answer 2

是的，Promise 是异步回调。 它们不能做回调不能做的任何事情，并且您面临与普通回调相同的异步问题。

然而，承诺不仅仅是回调多。 它们是一个非常强大的抽象，允许更清晰、更好的功能性代码和更少出错的样板。

那么主要思想是什么？

Promise 是表示单个（异步）计算结果的对象。 他们只对那个结果下定决心一次。 这有几个意思：

Promise 实现了一个观察者模式：

• 在任务完成之前，您不需要知道将使用该值的回调。
• 您可以轻松地return一个 Promise 对象，而不是期望回调作为函数的参数
• 承诺将存储该值，您可以随时透明地添加回调。 当结果可用时将调用它。 “透明”意味着当你有一个承诺并向它添加一个回调时，结果是否已经到达对你的代码没有影响——API 和合同是相同的，大大简化了缓存/记忆。
• 您可以轻松添加多个回调

Promise 是可链接的（ monadic ，如果你愿意的话）：

• 如果您需要转换承诺所代表的值，您可以在承诺上映射一个转换函数，并返回一个代表转换结果的新承诺。 您无法以某种方式同步获取值以使用它，但是您可以轻松地在 Promise 上下文中提升转换。 没有样板回调。
• 如果要链接两个异步任务，可以使用.then()方法。 它将使用第一个结果调用回调，并为回调返回的承诺的结果返回一个承诺。

听起来很复杂？ 是时候写一个代码示例了。

var p1 = api1(); // returning a promise
var p3 = p1.then(function(api1Result) {
    var p2 = api2(); // returning a promise
    return p2; // The result of p2 …
}); // … becomes the result of p3

// So it does not make a difference whether you write
api1().then(function(api1Result) {
    return api2().then(console.log)
})
// or the flattened version
api1().then(function(api1Result) {
    return api2();
}).then(console.log)

扁平化不会神奇地出现，但您可以轻松做到。 对于您的重嵌套示例，（接近）等价物将是

api1().then(api2).then(api3).then(/* do-work-callback */);

如果看到这些方法的代码有助于理解，这里有几行最基本的promise lib 。

承诺有什么大惊小怪的？

Promise 抽象允许更好的函数可组合性。 例如，在用于链接的then旁边， all函数为多个并行等待的 promise 的组合结果创建一个 promise。

最后但并非最不重要的 Promise 带有集成的错误处理。 计算的结果可能是，要么承诺满足了值，也被拒绝，理由。 所有的组合函数都会自动处理这个并在承诺链中传播错误，这样你就不需要在任何地方显式地关心它 - 与普通的回调实现相反。 最后，您可以为所有发生的异常添加专用的错误回调。

更不用说必须将事情转换为承诺。

对于好的 Promise 库，这实际上非常简单，请参阅如何将现有的回调 API 转换为 Promise？

Answer 3

除了已经确定的答案之外，使用 ES6 箭头函数，Promises 从一个不起眼的小蓝矮星直接变成了一个红巨星。 那即将坍缩成超新星：

api().then(result => api2()).then(result2 => api3()).then(result3 => console.log(result3))

正如oligofren指出的那样，在 api 调用之间没有参数，您根本不需要匿名包装函数：

api().then(api2).then(api3).then(r3 => console.log(r3))

最后，如果你想达到超大质量黑洞级别，可以等待 Promises：

async function callApis() {
    let api1Result = await api();
    let api2Result = await api2(api1Result);
    let api3Result = await api3(api2Result);

    return api3Result;
}

Answer 4

除了上面很棒的答案之外，还可以添加 2 点：

1.语义差异：

Promise 可能在创建时就已经解决了。 这意味着它们保证条件而不是事件。 如果它们已经被解析，则传递给它的解析函数仍会被调用。

相反，回调处理事件。 因此，如果您感兴趣的事件在注册回调之前发生，则不会调用回调。

2. 控制反转

回调涉及控制反转。 当您使用任何 API 注册回调函数时，Javascript 运行时会存储回调函数并在它准备好运行后从事件循环中调用它。

有关解释，请参阅Javascript 事件循环。

使用Promises ，控制驻留在调用程序中。 如果我们存储 promise 对象，则 .then() 方法可以随时调用。

Answer 5

除了其他答案之外，ES2015 语法与 promise 无缝融合，减少了更多样板代码：

// Sequentially:
api1()
  .then(r1 => api2(r1))
  .then(r2 => api3(r2))
  .then(r3 => {
      // Done
  });

// Parallel:
Promise.all([
    api1(),
    api2(),
    api3()
]).then(([r1, r2, r3]) => {
    // Done
});

Answer 6

一点都不。

回调只是JavaScript中的函数，它们将在另一个函数执行完成后被调用并执行。 那么它是如何发生的呢？

实际上，在 JavaScript 中，函数本身被视为对象，因此与所有其他对象一样，甚至函数也可以作为参数发送给其他函数。 可以想到的最常见和通用的用例是 JavaScript 中的 setTimeout() 函数。

与使用回调做同样的事情相比， Promise只不过是一种更临时的处理和构造异步代码的方法。

Promise 在构造函数中接收两个回调：resolve 和 reject。 Promise 中的这些回调为我们提供了对错误处理和成功案例的细粒度控制。 当promise 执行成功时使用resolve 回调，reject 回调用于处理错误情况。

Answer 7

Promise 不是回调，两者都是促进异步编程的编程习惯用法。 使用使用协程或返回承诺的生成器的异步/等待风格的编程可以被认为是第三个这样的习惯用法。 这些习语在不同编程语言（包括 Javascript）中的比较如下： https : //github.com/KjellSchubert/promise-future-task

Answer 8

没有承诺只是回调的包装

示例您可以将 javascript 本机承诺与节点 js 一起使用

my cloud 9 code link : https://ide.c9.io/adx2803/native-promises-in-node

/**
* Created by dixit-lab on 20/6/16.
*/

var express = require('express');
var request = require('request');   //Simplified HTTP request client.


var app = express();

function promisify(url) {
    return new Promise(function (resolve, reject) {
    request.get(url, function (error, response, body) {
    if (!error && response.statusCode == 200) {
        resolve(body);
    }
    else {
        reject(error);
    }
    })
    });
}

//get all the albums of a user who have posted post 100
app.get('/listAlbums', function (req, res) {
//get the post with post id 100
promisify('http://jsonplaceholder.typicode.com/posts/100').then(function (result) {
var obj = JSON.parse(result);
return promisify('http://jsonplaceholder.typicode.com/users/' + obj.userId + '/albums')
})
.catch(function (e) {
    console.log(e);
})
.then(function (result) {
    res.end(result);
}
)

})


var server = app.listen(8081, function () {

var host = server.address().address
var port = server.address().port

console.log("Example app listening at http://%s:%s", host, port)

})


//run webservice on browser : http://localhost:8081/listAlbums

Answer 9

JavaScript Promises 实际上使用回调函数来确定在 Promise 被解析或拒绝后要做什么，因此两者没有根本的不同。 Promises 背后的主要思想是采用回调 - 特别是嵌套回调，您希望在其中执行某种操作，但它会更具可读性。

Answer 10

承诺概述：

在 JS 中，我们可以将异步操作（例如数据库调用、AJAX 调用）包装在 Promise 中。 通常我们想对检索到的数据运行一些额外的逻辑。 JS promise 具有处理异步操作的结果的处理函数。 处理程序函数甚至可以在其中包含其他异步操作，这些操作可能依赖于先前异步操作的值。

一个 promise 总是有以下 3 种状态：

1. 待定：每个承诺的起始状态，既不履行也不拒绝。
2. 已完成：操作成功完成。
3. 拒绝：操作失败。

可以使用值来解决/完成或拒绝挂起的承诺。 然后调用以下将回调作为参数的处理程序方法：

1. Promise.prototype.then() ：当 promise 被解析时，这个函数的回调参数将被调用。
2. Promise.prototype.catch() ：当承诺被拒绝时，该函数的回调参数将被调用。

尽管上述方法技能获取回调参数，但它们比仅使用回调要好得多，这里是一个可以阐明很多问题的示例：

例子

 function createProm(resolveVal, rejectVal) { return new Promise((resolve, reject) => { setTimeout(() => { if (Math.random() > 0.5) { console.log("Resolved"); resolve(resolveVal); } else { console.log("Rejected"); reject(rejectVal); } }, 1000); }); } createProm(1, 2) .then((resVal) => { console.log(resVal); return resVal + 1; }) .then((resVal) => { console.log(resVal); return resVal + 2; }) .catch((rejectVal) => { console.log(rejectVal); return rejectVal + 1; }) .then((resVal) => { console.log(resVal); }) .finally(() => { console.log("Promise done"); });

• createProm 函数创建一个 1 秒后根据随机 Nr 解析或拒绝的承诺
• 如果承诺解决第一个then调用方法和解析值被传入作为回调的参数
• 如果承诺被拒绝，则调用第一个catch方法并将被拒绝的值作为参数传入
• catch和then方法返回承诺，这就是我们可以链接它们的原因。 它们将任何返回值包装在Promise.resolve并将任何抛出值（使用throw关键字） Promise.reject在Promise.reject 。 所以任何返回的值都被转换成一个承诺，在这个承诺上我们可以再次调用一个处理函数。
• 与嵌套回调相比，Promise 链为我们提供了更精细的控制和更好的概览。 例如， catch方法处理在catch处理程序之前发生的所有错误。

Answer 11

与使用回调相比，Promise 允许程序员编写更简单、更易读的代码。

---

在一个程序中，有一些步骤要串联执行。

function f() {
   step_a();
   step_b();
   step_c();
   ...
}

每个步骤之间通常都有信息。

function f() {
   const a = step_a(   );
   const b = step_b( a );
   const c = step_c( b );
   ...
}

其中一些步骤可能需要（相对）较长的时间，因此有时您希望将它们与其他事情并行执行。 一种方法是使用线程。 另一个是异步编程。 （这两种方法各有利弊，这里不做讨论。）这里，我们讨论的是异步编程。

使用异步编程时实现上述目标的简单方法是提供一个回调，该回调在一个步骤完成后被调用。

// step_* calls the provided function with the returned value once complete.
function f() {
   step_a(
      function( a )
         step_b(
            function( b )
               step_c(
                  ...
               )
            },
         )
      },
   )
}

这很难读。 Promise 提供了一种扁平化代码的方法。

// step_* returns a promise.
function f() {
   step_a()
   .then( step_b )
   .then( step_c )
   ...
}

返回的 object 称为 promise，因为它表示 function（可能是值或异常）的未来结果（即承诺的结果）。

尽管 Promise 有帮助，但使用 Promise 仍然有点复杂。 这就是async和await的用武之地。在声明为async的 function 中，可以使用await代替then 。

// step_* returns a promise.
async function f()
   const a = await step_a(   );
   const b = await step_b( a );
   const c = await step_c( b );
   ...
}

不可否认，这比使用回调更具可读性。