Promise理解

摘抄自这篇文章
一个 Promise 就是一个代表了异步操作最终完成或者失败的对象。大多数人都在使用由其他函数创建并返回的promise，因此，本教程将首先探讨返回promise的使用情况。

本质上，一个promise是某个函数返回的对象，你可以把回调函数绑定在这个对象上，而不是把回调函数当作参数传进函数。

比如，promise替代了下面这种旧式的函数，这种旧式函数需要两个回调函数，并最终调用处理成功事件或者处理失败事件的回调函数：

function successCallback(result) {
  console.log("It succeeded with " + result);
}

function failureCallback(error) {
  console.log("It failed with " + error);
}

doSomething(successCallback, failureCallback);

…新式函数返回一个你可以直接绑定回调函数的promise对象，来代替旧式的函数形式：

const promise = doSomething(); 
promise.then(successCallback, failureCallback);

…或者更简单的形式：

doSomething().then(successCallback, failureCallback);

我们把这个称为异步函数调用，这种形式有若干优点。我们将会逐一讨论。

保证
不像旧式函数那样传递回调函数，promise会带来一些保证：

在JavaScript事件队列的当前运行完成之前，回调函数永远不会被调用。
通过 .then 形式添加的回调函数，甚至都在异步操作完成之后才被添加的函数，都会被调用，如上所示。
通过多次调用 .then，可以添加多个回调函数，它们会按照插入顺序并且独立运行。
但是，promise最直接的好处就是链式调用。

链式调用
一个常见的需求就是连续执行两个或者多个异步操作，这种情况下，每一个后来的操作都在前面的操作执行成功之后，带着上一步操作所返回的结果开始执行。我们可以通过创造一个promise chain来完成这种需求。

见证奇迹的时刻：then函数会返回一个新的promise，跟原来的不同：

const promise = doSomething();
const promise2 = promise.then(successCallback, failureCallback);

或者

const promise2 = doSomething().then(successCallback, failureCallback);

第二个promise不仅代表doSomething()函数的完成，也代表了你传入的 successCallback 或者failureCallback 的完成，这也可能是其他异步函数返回的promise。这样的话，任何被添加给 promise2 的回调函数都会被排在 successCallback 或 failureCallback 返回的promise后面。

基本上，每一个promise代表了链式中另一个异步过程的完成。

在过去，做多重的异步操作，会导致经典的回调地狱：

doSomething(function(result) {
  doSomethingElse(result, function(newResult) {
    doThirdThing(newResult, function(finalResult) {
      console.log('Got the final result: ' + finalResult);
    }, failureCallback);
  }, failureCallback);
}, failureCallback);

通过现代的函数，我们把回调附加到被返回的promise上代替以往的做法，形成一个promise 链：

doSomething().then(function(result) {
  return doSomethingElse(result);
})
.then(function(newResult) {
  return doThirdThing(newResult);
})
.then(function(finalResult) {
  console.log('Got the final result: ' + finalResult);
})
.catch(failureCallback);

then里的参数是可选的，catch(failureCallback) 是 then(null, failureCallback) 的缩略形式。如下所示，也可以用 arrow functions（箭头函数）来表示：

doSomething()
.then(result => doSomethingElse(result))
.then(newResult => doThirdThing(newResult))
.then(finalResult => {
  console.log(`Got the final result: ${finalResult}`);
})
.catch(failureCallback);

注意：如果想要在回调中获取上个promise中的结果，上个promise中必须要返回结果。

catch之后的链式操作
在一个失败操作（即一个 catch）之后可以继续使用链式操作，即使链式中的一个动作失败之后还能有助于新的动作继续完成。请阅读下面的例子：

new Promise((resolve, reject) => {
    console.log('Initial');

    resolve();
})
.then(() => {
    throw new Error('Something failed');

    console.log('Do this');
})
.catch(() => {
    console.log('Do that');
})
.then(() => {
    console.log('Do this whatever happened before');
});

输出结果如下：

Initial
Do that
Do this whatever happened before

注意，由于“Something failed”错误导致了拒绝操作，所以“Do this”文本没有被输出。

错误传播
在之前的回调地狱示例中，你可能记得有3次failureCallback的调用，而在promise链中只有底部的一次调用。

doSomething()
.then(result => doSomethingElse(value))
.then(newResult => doThirdThing(newResult))
.then(finalResult => console.log(`Got the final result: ${finalResult}`))
.catch(failureCallback);

基本上，一个promise链式遇到异常就会停止，查看链式的底端，寻找catch处理程序来代替当前执行。在同步的代码执行之后，这是非常模型化的。

try {
  let result = syncDoSomething();
  let newResult = syncDoSomethingElse(result);
  let finalResult = syncDoThirdThing(newResult);
  console.log(`Got the final result: ${finalResult}`);
} catch(error) {
  failureCallback(error);
}

在ECMAScript 2017标准的async/await语法糖中，这种同步形式代码的整齐性得到了极致的体现：

async function foo() {
  try {
    let result = await doSomething();
    let newResult = await doSomethingElse(result);
    let finalResult = await doThirdThing(newResult);
    console.log(`Got the final result: ${finalResult}`);
  } catch(error) {
    failureCallback(error);
  }
}

这个例子是在promise的基础上构建的，例如，doSomething()与之前的函数是相同的。你可以在这里阅读更多的与这个语法相关的文章。

通过捕获所有的错误，甚至抛出异常和程序错误，promise解决了回调厄运金字塔的基本缺陷。这是异步操作的基本功能。

---

回想之前用nodejs做的博客网站中，用户登录的路由也用到了promise，当时还不是很理解，现在看就很清晰啦！
代码地址

 UserModel.getUserByName(name)
    .then(function (user) {
      if (!user) {
        req.flash('error', '用户不存在')
        return res.redirect('back')
      }
      // 检查密码是否匹配
      if (sha1(password) !== user.password) {
        req.flash('error', '用户名或密码错误')
        return res.redirect('back')
      }
      req.flash('success', '登录成功')
      // 用户信息写入 session
      delete user.password
      req.session.user = user
      // 跳转到主页
      res.redirect('/posts')
    })
    .catch(next)