怎么写异步代码？相对原始的callbacks而言，promises无疑是更好的选择。可掌握promises的概念及其用法可能不太容易， 而且很有可能你已经放弃它了。但经过一大波码农的努力，promise的美终于以一种可互操、可验证的方式现于世间。这一努力的结果就是Promises/A+规范，它以自己的方式影响了各种promises库，甚至DOM。

扯了这么多，promises到底是什么？写Node程序时它能帮上什么忙？

Promises是一个。。。抽象

我们先来聊聊promise的行为模式，让你对他是什么，能怎么用他有个直观的感受。在本文的后半段，我们会以Q为例讲一下在程序里怎么创建和使用promise。

那promise究竟是什么呢？请看定义：

promise是对异步编程的一种抽象。它是一个代理对象，代表一个必须进行异步处理的函数返回的值或抛出的异常。 – Kris Kowal on JSJ

callback是编写Javascript异步代码最最最简单的机制。可用这种原始的callback必须以牺牲控制流、异常处理和函数语义为代价，而我们在同步代码中已经习惯了它们的存在，不适应！Promises能带它们回来。

promise对象的核心部件是它的then方法。我们可以用这个方法从异步操作中得到返回值（传说中的履约值），或抛出的异常（传说中的拒绝的理由）。then方法有两个可选的参数，都是callback函数，分别是onFulfilled 和 onRejected：

var promise = doSomethingAync()
promise.then(onFulfilled, onRejected)

promise被解决时（异步处理已经完成）会调用onFulfilled 和 onRejected 。因为只会有一种结果，所以这两个函数中仅有一个会被触发。

从Callbacks 到 promises

看过这个promises的基础知识后，我们再来看一个经典的异步 Node callback：

readFile(function (err, data) {
  if (err) return console.error(err)
  console.log(data)
})

如果函数readFile返回的是 promise，我们可以这样写：

var promise = readFile()
promise.then(console.log, console.error)

乍一看这没什么实质性变化。但实际上现在我们得到了一个代表异步操作的值（promise）。我们可以传递promise，不管异步操作完成与否，所有能访问到promise的代码都可以用then使用这个异步操作的处理结果。而且我们还得到保证，异步操作的结果不会发生某种变化，因为promise只会被解决一次（或履约，或被拒）。

把then当成对promise解包以得到异步操作结果（或异常）的函数对理解promise更有帮助，不要把它当成只是带两个callback（onFulfilled 和 onRejected）的普通函数。详情请见此文

promise的链接及内嵌

then方法返回的还是promise。

var promise = readFile()
var promise2 = promise.then(readAnotherFile, console.error)

这个promise表示 onFulfilled 或 onRejected 的返回结果。既然结果只能是其中之一，所以不管是什么结果，promise都会转发调用:

var promise = readFile()
var promise2 = promise.then(function (data) {
  return readAnotherFile() // if readFile was successful, let's readAnotherFile
}, function (err) {
  console.error(err) // if readFile was unsuccessful, let's log it but still readAnotherFile
  return readAnotherFile()
})
promise2.then(console.log, console.error) // the result of readAnotherFile

因为then 返回的是 promise，所以promise可以形成调用链，避免出现callback大坑：

readFile()
  .then(readAnotherFile)
  .then(doSomethingElse)
  .then(...)

如果非要保持闭包，promise也可以嵌套：

readFile()
  .then(function (data) {
    return readAnotherFile().then(function () {
      // do something with `data`
    })
  })

Promise与同步函数

Promises有几种编写同步函数的办法。其中之一是用返回代替调用。在前面的例子中，返回readAnotherFile()是一个信号，表明在readFile完成之后做什么。

如果返回promise，它会在异步操作完成后发信号给下一个then。返回值并不是非promise不可，不管返回什么，都会传给下一个onFulfilled做参数：

readFile()
  .then(function (buf) {
    return JSON.parse(buf.toString())
  })
  .then(function (data) {
    // do something with `data`
  })

promise的错误处理

除了return，还可以用关键字throw 和 try/catch语法。这可以算是promises最强的一个特性了。下面我们来看一段同步代码：

try {
  doThis()
  doThat()
} catch (err) {
  console.error(err)
}

在上例中，如果doThis() 或 doThat()抛出了异常，异常会被捕获并输出错误日志。既然try/catch允许多个操作放到一起，我们就不用单独处理每个操作可能出现的错误。用promises的异步代码也可以这样：

doThisAsync()
  .then(doThatAsync)
  .then(null, console.error)

如果doThisAsync()没有成功，它的promise会被拒，处理链下一个then上的onRejected会被调用。在上例中就是函数console.error。而且跟 try/catch 一样， doThatAsync() 根本就不会被调用。对于原始的callback那种每一步里都要显式处理错误的方式而言，这是巨大的进步。

实际上它比这还要好！任何被抛出的异常，隐式的或显式的，then的回调函数中的也会处理：

doThisAsync()
  .then(function (data) {
    data.foo.baz = 'bar' // throws a ReferenceError as foo is not defined
  })
  .then(null, console.error)

上例中抛出的ReferenceError会被处理链中下一个onRejected捕获。相当漂亮！当然，这对显式抛出的异常也有效：

doThisAsync()
  .then(function (data) {
    if (!data.baz) throw new Error('Expected baz to be there')
  })
  .then(null, console.error)

对错误处理的重要提示

我们在前面已经说过了，promises模拟了try/catch。在try/catch中，可以不对异常做显式的处理，屏蔽它：

try {
  throw new Error('never will know this happened')
} catch (e) {}

对promise来说也是如此：

readFile()
  .then(function (data) {
    throw new Error('never will know this happened')
  })

要处理被屏蔽的错误，可以在promise处理链的最后加一个.then(null, onRejected):

readFile()
  .then(function (data) {
    throw new Error('now I know this happened')
  })
  .then(null, console.error)

各种函数库中还包括暴露被屏蔽错误的其他选项。比如Q中的done方法可以重新向上抛出错误。

promise的具体应用

前面的例子都是返回空方法，只是为了阐明Promises/A+中的then 方法。接下来我们要看一些更具体的例子。

将callbacks 变成 promises

你可能在想promise最初是从哪蹦出来的。Promise/A+规范中没有规定创建promise的API，因为它不会影响互操作性。因此不同promise库的实现可能是不同的。我们的例子用的是Q（npm install q）.

Node 核心异步函数不会返回promises；它们采用了callbacks的方式。然而用Q可以很容易地让它们返回promises：

var fs_readFile = Q.denodify(fs.readFile)
var promise = fs_readFile('myfile.txt')
promise.then(console.log, console.error)

Q 提供了一些辅助函数，可以将Node和其他环境适配为promise可用的。请参见 readme 和 API documentation 了解详情。

创建原始的promise

用Q.defer可以手动创建promise。比如将fs.readFile手工封装成promise的（基本上就是Q.denodify做的事情 ）

function fs_readFile (file, encoding) {
  var deferred = Q.defer()
  fs.readFile(file, encoding, function (err, data) {
    if (err) deferred.reject(err) // rejects the promise with `er` as the reason
    else deferred.resolve(data) // fulfills the promise with `data` as the value
  })
  return deferred.promise // the promise is returned
}
fs_readFile('myfile.txt').then(console.log, console.error)

做同时支持callbacks 和 promises 的APIs

我们已经见过两种将callback代码变成promise代码的办法了。其实还能做出同时提供promise和callback接口的APIs。下面我们就把fs.readFile变成这样的API：

function fs_readFile (file, encoding, callback) {
  var deferred = Q.defer()
  fs.readFile(function (err, data) {
    if (err) deferred.reject(err) // rejects the promise with `er` as the reason
    else deferred.resolve(data) // fulfills the promise with `data` as the value
  })
  return deferred.promise.nodeify(callback) // the promise is returned
}

如果提供了callback，当promise被拒或被解决时，会用标准Node风格的(err, result) 参数调用它。

fs_readFile('myfile.txt', 'utf8', function (er, data) {
  // ...
})

用promise执行并行操作

我们前面聊的都是顺序的异步操作。对于并行操作，Q提供了Q.all方法，它以一个promises数组作为输入，返回一个新的promise。 在数组中的所有操作都成功完成后，这个promise就会履约。如果任何一个操作失败，这个新的promise就会被拒。

var allPromise = Q.all([ fs_readFile('file1.txt'), fs_readFile('file2.txt') ])
allPromise.then(console.log, console.error)

不得不强调一下，promise在模仿函数。函数只有一个返回值。当传给Q.all两个成功完成的promises时，调用onFulfilled只会有一个参数（一个包含两个结果的数组）。你可能会对此感到吃惊；然而跟同步保持一致是promise的一个重要保证。如果你想把结果展开成多个参数，可以用Q.spread。

在Node.js 中用 Q 实现Promise – Callbacks之外的另一种选择