我已经开发JavaScript几年了，但我完全不明白承诺（Promise）的热度是怎么回事。
似乎我所做的一切都只是改变：
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
});
});
});
这段代码更冗长，不易读懂。我在这里没有获得任何好处，它也不会神奇地变得“扁平”。更别提必须将事物转换为promises。
那么，这里关于promises有什么大惊小怪的呢？
Promise不是回调函数。一个Promise代表一项异步操作的未来结果。当然，如果像你所写的那样，你得到的好处很少。但如果按照它们应该使用的方式编写它们，您可以以类似于同步代码的方式编写异步代码，并且更易于理解：
api().then(function(result){
return api2();
}).then(function(result2){
return api3();
}).then(function(result3){
// do work
});
当然，代码量并没有减少，但可读性提高了许多。
但这还不是全部。让我们探索真正的好处：如果您想要检查任何步骤中的错误，使用回调将会很麻烦，但使用 Promises 就非常简单：
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.
});
更好的是：如果那3个对api、api2和api3的调用可以同时运行（例如，如果它们是AJAX调用），但您需要等待这三个调用完成后再继续下一步，该怎么办呢？没有 Promise，您应该要创建某种计数器。有了 Promise 并使用 ES6 的符号，这又是小菜一碟且相当简洁：
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.
});
希望你现在能够以新的方式看待Promise。
api2和api3中有异步操作，那么最后一个.then只有在这些异步操作完成后才会被调用吗？ - NiCk Newman返回一个Promise对象，而不是期望回调作为函数的参数。Promise是可链接的（单子，如果你想要）：
.then() 方法。它将接受一个回调函数，该函数将被调用并带有第一个结果，并返回一个代表回调返回的 promise 结果的 promise。听起来很复杂吗？是时候看一个代码示例了。
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 有什么大惊小怪的？
Promise 抽象允许更好地组合函数。例如，除了用于链接的 then，all 函数创建一个承诺，用于多个并行等待的承诺的组合结果。
最后但并非最不重要的是，Promise 带有集成的错误处理。计算的结果可能是承诺被实现了一个值，或者它被拒绝了一个原因。所有组合函数都自动处理这个，并在承诺链中传播错误，因此您不需要在每个地方显式关注它 - 与纯回调实现相反。最终，您可以为所有发生的异常添加专用的错误回调。
更不用说必须将事物转换为 promises。
使用良好的 promise 库实际上很容易，参见 如何将现有的回调 API 转换为 promises？
.then(console.log)，因为console.log依赖于控制台上下文。这样会导致非法调用错误。请使用console.log.bind(console)或x => console.log(x)来绑定上下文。 - Tamas Hegedusconsole方法绑定了。当然，我只是说两种嵌套的行为完全相同，而不是任何一种都可以工作 :-P - Bergi除了已经建立的答案之外，使用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))
最后，如果您想达到超级大质量黑洞的水平，可以等待承诺:
async function callApis() {
let api1Result = await api();
let api2Result = await api2(api1Result);
let api3Result = await api3(api2Result);
return api3Result;
}
apiX方法中没有使用参数，那么最好完全跳过箭头函数：
api().then(api2).then(api3).then(r3 => console.log(r3))。 - oligofren除了其他答案之外，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
});
承诺只是回调函数的包装器
例如，您可以在Node.js中使用JavaScript本机承诺
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
Promise 允许程序员编写比使用回调函数更简单和易读的代码。
function f() {
step_a();
step_b();
step_c();
...
}
通常在每个步骤之间都会传递信息。
function f( x ) {
const a = step_a( x );
const b = step_b( a );
const c = step_c( b );
...
}
其中一些步骤可能需要（相对）长时间，因此有时您想并行执行其他事情。一种方法是使用线程。另一个方法是异步编程。（这两种方法都有优缺点，这里不会讨论）。这里，我们正在谈论异步编程。
在使用异步编程时实现上述功能的简单方法是提供回调函数，该函数在完成步骤后被调用。
// Each of step_* calls the provided function with its return value once complete.
function f() {
step_a( x,
function( a ) {
step_b( a,
function( b ) {
step_c( b,
...
);
},
);
},
);
}
这很难读。Promise 提供了一种简化代码的方法。
// Each of step_* returns a promise.
function f( x ) {
step_a( x )
.then( step_b )
.then( step_c )
...
}
async和await发挥作用的地方。在声明为async的函数中，可以使用await代替then。// Each of step_* returns a promise.
async function f( x )
const a = await step_a( x );
const b = await step_b( a );
const c = await step_c( b );
...
}
这无疑比使用回调函数更易读。
在JS中，我们可以使用promise来包装异步操作（例如数据库调用、AJAX调用）。通常，我们想要对检索到的数据运行一些附加逻辑。JS promise具有处理异步操作结果的处理程序函数。处理程序函数甚至可以在其中包含其他异步操作，这些操作可能依赖于前一个异步操作的值。
一个promise始终具有以下3种状态之一：
待定的promise可以通过值解决/履行或拒绝。然后会调用以下接受回调函数作为参数的处理程序方法：
Promise.prototype.then() ：当promise被解决时，将调用此函数的回调参数。Promise.prototype.catch() ：当promise被拒绝时，将调用此函数的回调参数。虽然上述方法仍然需要回调参数，但它们比仅使用回调要优秀得多，下面是一个例子，可以更好地说明问题：
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函数创建一个Promise对象，根据1秒后生成的随机数来决定该Promise是resolved还是rejected。then方法将被调用，并将resolved的值作为回调函数的参数传递。catch方法将被调用，并将rejected的值作为参数传递。catch和then方法返回的都是Promise对象，因此我们可以将它们链接在一起。它们使用Promise.resolve包装任何返回值，使用Promise.reject包装任何抛出的值（使用throw关键字）。所以任何返回的值都会被转换成一个Promise对象，我们可以在这个Promise对象上再次调用处理函数。catch方法处理在其之前发生的所有错误。