JavaScript Promise：简介
通过集合保持井井有条根据您的偏好保存和分类内容。

Promise 简化了延迟和异步计算。Promise 表示一个尚未完成的操作。

Jake Archibald

开发者们，为 web 开发史上一个关键时刻做好准备。

[开始击鼓]

Promise 已经来到 JavaScript!

[烟花绽放，闪光纸片如雨般落下，人群沸腾]

此时你会属于以下类别之一

人们在你周围欢呼，但你不确定这一切有什么大惊小怪的。也许你甚至不确定“promise”是什么。你想耸耸肩，但闪光纸片的重量压在你的肩膀上。如果是这样，请别担心，我花了很长时间才弄明白我为什么要关心这些东西。你可能想从开头开始。
你挥拳欢呼！是时候了吧？你以前用过这些 Promise，但让你困扰的是，所有实现都有略微不同的 API。官方 JavaScript 版本的 API 是什么？你可能想从术语开始。
你已经知道这件事了，并且你嘲笑那些像这是新闻一样跳上跳下的人。花点时间沉浸在你的优越感中，然后直接前往API 参考。

浏览器支持和 Polyfill

浏览器支持

来源

为了使缺少完整 promise 实现的浏览器符合规范，或者向其他浏览器和 Node.js 添加 promise，请查看polyfill（压缩后 2k）。

这一切有什么大惊小怪的？

JavaScript 是单线程的，这意味着两个脚本位不能同时运行；它们必须一个接一个地运行。在浏览器中，JavaScript 与许多其他东西共享一个线程，这些东西因浏览器而异。但通常 JavaScript 与绘制、更新样式和处理用户操作（例如突出显示文本和与表单控件交互）在同一个队列中。这些事物中的一项活动会延迟其他活动。

作为人类，你是多线程的。你可以用多个手指打字，你可以同时开车和谈话。我们必须处理的唯一阻塞函数是打喷嚏，所有当前的活动都必须暂停，直到喷嚏结束。这非常烦人，尤其是在你开车并试图交谈时。你不想编写会“打喷嚏”的代码。

你可能已经使用事件和回调来解决这个问题。以下是事件

var img1 = document.querySelector('.img-1');

img1.addEventListener('load', function() {
  // woo yey image loaded
});

img1.addEventListener('error', function() {
  // argh everything's broken
});

这根本不“打喷嚏”。我们获取图像，添加几个侦听器，然后 JavaScript 可以停止执行，直到其中一个侦听器被调用。

不幸的是，在上面的示例中，事件可能发生在我们开始侦听它们之前，因此我们需要使用图像的“complete”属性来解决这个问题

var img1 = document.querySelector('.img-1');

function loaded() {
  // woo yey image loaded
}

if (img1.complete) {
  loaded();
}
else {
  img1.addEventListener('load', loaded);
}

img1.addEventListener('error', function() {
  // argh everything's broken
});

这不会捕获在我们有机会侦听它们之前就出错的图像；不幸的是，DOM 没有为我们提供一种方法来做到这一点。此外，这正在加载一个图像。如果我们想知道何时加载了一组图像，事情会变得更加复杂。

事件并不总是最好的方法

事件非常适合在同一对象上可能发生多次的事情 - keyup、touchstart 等。对于这些事件，你并不真正在意在你附加侦听器之前发生了什么。但是当涉及到异步成功/失败时，理想情况下你想要这样的东西

img1.callThisIfLoadedOrWhenLoaded(function() {
  // loaded
}).orIfFailedCallThis(function() {
  // failed
});

// and…
whenAllTheseHaveLoaded([img1, img2]).callThis(function() {
  // all loaded
}).orIfSomeFailedCallThis(function() {
  // one or more failed
});

这就是 promise 所做的，但名称更好。如果 HTML 图像元素有一个返回 promise 的 "ready" 方法，我们可以这样做

img1.ready()
.then(function() {
  // loaded
}, function() {
  // failed
});

// and…
Promise.all([img1.ready(), img2.ready()])
.then(function() {
  // all loaded
}, function() {
  // one or more failed
});

在最基本的情况下，promise 有点像事件侦听器，除了

一个 promise 只能成功或失败一次。它不能成功或失败两次，也不能从成功切换到失败，反之亦然。
如果 promise 已经成功或失败，并且你稍后添加了成功/失败回调，则会调用正确的回调，即使事件发生在更早的时候。

这对于异步成功/失败非常有用，因为你不太关心某件事变为可用的确切时间，而更关心对结果做出反应。

Promise 术语

Domenic Denicola 校对了本文的初稿，并在术语方面给我打了“F”。他把我留堂，强迫我抄写 States and Fates 100 遍，并给我的父母写了一封担心的信。尽管如此，我仍然会把很多术语搞混，但以下是基础知识

Promise 可以是

已兑现 (fulfilled) - 与 promise 相关的操作成功
已拒绝 (rejected) - 与 promise 相关的操作失败
等待中 (pending) - 尚未兑现或拒绝
已敲定 (settled) - 已兑现或拒绝

规范还使用术语 thenable 来描述类似 promise 的对象，因为它具有 then 方法。这个术语让我想起了前英格兰足球队经理 Terry Venables，所以我将尽可能少地使用它。

Promise 已经来到 JavaScript!

Promise 以库的形式存在已有一段时间，例如

以上库和 JavaScript Promise 共享一个通用的标准化行为，称为 Promises/A+。如果你是 jQuery 用户，他们也有类似的东西，称为 Deferreds。但是，Deferreds 不符合 Promise/A+ 标准，这使得它们略有不同且不太有用，因此请注意。jQuery 也有 Promise 类型，但这只是 Deferred 的一个子集，并且存在相同的问题。

尽管 promise 实现遵循标准化的行为，但它们的总体 API 各不相同。JavaScript Promise 在 API 上与 RSVP.js 相似。以下是如何创建 promise

var promise = new Promise(function(resolve, reject) {
  // do a thing, possibly async, then…

  if (/* everything turned out fine */) {
    resolve("Stuff worked!");
  }
  else {
    reject(Error("It broke"));
  }
});

promise 构造函数接受一个参数，一个带有两个参数的回调，resolve 和 reject。在回调中执行某些操作（可能是异步的），然后如果一切正常则调用 resolve，否则调用 reject。

与普通的 JavaScript 中的 throw 类似，习惯上（但不是必需的）使用 Error 对象进行拒绝。Error 对象的好处是它们捕获堆栈跟踪，使调试工具更有帮助。

以下是如何使用该 promise

promise.then(function(result) {
  console.log(result); // "Stuff worked!"
}, function(err) {
  console.log(err); // Error: "It broke"
});

then() 接受两个参数，一个用于成功情况的回调，另一个用于失败情况的回调。两者都是可选的，因此你可以仅为成功或失败情况添加回调。

JavaScript Promise 最初在 DOM 中以 “Futures” 的形式出现，重命名为 “Promises”，最终移至 JavaScript。在 JavaScript 而不是 DOM 中拥有它们非常棒，因为它们将在非浏览器 JS 上下文（如 Node.js）中可用（它们是否在其核心 API 中使用它们是另一个问题）。

尽管它们是 JavaScript 功能，但 DOM 并不害怕使用它们。事实上，所有新的带有异步成功/失败方法的 DOM API 都将使用 promise。这已经发生在 Quota Management、Font Load Events、ServiceWorker、Web MIDI、Streams 等中。

与其他库的兼容性

JavaScript Promise API 会将任何具有 then() 方法的东西视为类似 promise 的（或 promise 术语中的 thenable 叹气），因此如果你使用返回 Q promise 的库，那没关系，它将与新的 JavaScript Promise 很好地配合使用。

尽管正如我所提到的，jQuery 的 Deferreds 有点……没有帮助。值得庆幸的是，你可以将它们转换为标准 promise，这值得尽快完成

var jsPromise = Promise.resolve($.ajax('/whatever.json'))

在这里，jQuery 的 $.ajax 返回一个 Deferred。由于它具有 then() 方法，因此 Promise.resolve() 可以将其转换为 JavaScript Promise。但是，有时 deferreds 会将多个参数传递给它们的回调，例如

var jqDeferred = $.ajax('/whatever.json');

jqDeferred.then(function(response, statusText, xhrObj) {
  // ...
}, function(xhrObj, textStatus, err) {
  // ...
})

而 JS Promise 忽略除第一个之外的所有参数

jsPromise.then(function(response) {
  // ...
}, function(xhrObj) {
  // ...
})

值得庆幸的是，这通常是你想要的，或者至少让你能够访问你想要的东西。另外，请注意 jQuery 不遵循将 Error 对象传递到 rejection 中的约定。

复杂的异步代码变得更简单

好了，让我们编写一些代码。假设我们想要

启动微调器以指示加载
获取故事的一些 JSON，其中为我们提供了标题和每个章节的 URL
将标题添加到页面
获取每个章节
将故事添加到页面
停止微调器

……但也要在沿途出现问题时告知用户。我们也希望在那时停止微调器，否则它会一直旋转，变得头晕，并撞到其他 UI。

当然，你不会使用 JavaScript 来传递故事，以 HTML 形式提供更快，但是当处理 API 时，这种模式非常常见：多次数据获取，然后在全部完成后执行某些操作。

首先，让我们处理从网络获取数据

Promise 化 XMLHttpRequest

旧的 API 将会更新以使用 promise，如果可以向后兼容的方式进行更新。XMLHttpRequest 是主要候选对象，但与此同时，让我们编写一个简单的函数来发出 GET 请求

function get(url) {
  // Return a new promise.
  return new Promise(function(resolve, reject) {
    // Do the usual XHR stuff
    var req = new XMLHttpRequest();
    req.open('GET', url);

    req.onload = function() {
      // This is called even on 404 etc
      // so check the status
      if (req.status == 200) {
        // Resolve the promise with the response text
        resolve(req.response);
      }
      else {
        // Otherwise reject with the status text
        // which will hopefully be a meaningful error
        reject(Error(req.statusText));
      }
    };

    // Handle network errors
    req.onerror = function() {
      reject(Error("Network Error"));
    };

    // Make the request
    req.send();
  });
}

现在让我们使用它

get('story.json').then(function(response) {
  console.log("Success!", response);
}, function(error) {
  console.error("Failed!", error);
})

现在我们可以发出 HTTP 请求，而无需手动键入 XMLHttpRequest，这太棒了，因为我越少看到 XMLHttpRequest 令人恼火的驼峰式大小写，我的生活就会越快乐。

链式调用

then() 不是故事的结局，你可以将 then 链接在一起以转换值或一个接一个地运行其他异步操作。

转换值

你可以通过简单地返回新值来转换值

var promise = new Promise(function(resolve, reject) {
  resolve(1);
});

promise.then(function(val) {
  console.log(val); // 1
  return val + 2;
}).then(function(val) {
  console.log(val); // 3
})

作为一个实际示例，让我们回到

get('story.json').then(function(response) {
  console.log("Success!", response);
})

响应是 JSON，但我们当前将其接收为纯文本。我们可以更改我们的 get 函数以使用 JSON responseType，但我们也可以在 promise 领域中解决它

get('story.json').then(function(response) {
  return JSON.parse(response);
}).then(function(response) {
  console.log("Yey JSON!", response);
})

由于 JSON.parse() 接受单个参数并返回转换后的值，因此我们可以创建一个快捷方式

get('story.json').then(JSON.parse).then(function(response) {
  console.log("Yey JSON!", response);
})

实际上，我们可以非常轻松地创建一个 getJSON() 函数

function getJSON(url) {
  return get(url).then(JSON.parse);
}

getJSON() 仍然返回一个 promise，该 promise 获取 URL，然后将响应解析为 JSON。

异步操作排队

你还可以链接 then 以按顺序运行异步操作。

当你从 then() 回调中返回某些内容时，这有点神奇。如果你返回值，则使用该值调用下一个 then()。但是，如果你返回类似 promise 的内容，则下一个 then() 会等待它，并且仅在该 promise 敲定（成功/失败）时才被调用。例如

getJSON('story.json').then(function(story) {
  return getJSON(story.chapterUrls[0]);
}).then(function(chapter1) {
  console.log("Got chapter 1!", chapter1);
})

在这里，我们向 story.json 发出异步请求，这为我们提供了一组要请求的 URL，然后我们请求其中的第一个。这是 promise 真正开始从简单回调模式中脱颖而出的时候。

你甚至可以创建一个快捷方式方法来获取章节

var storyPromise;

function getChapter(i) {
  storyPromise = storyPromise || getJSON('story.json');

  return storyPromise.then(function(story) {
    return getJSON(story.chapterUrls[i]);
  })
}

// and using it is simple:
getChapter(0).then(function(chapter) {
  console.log(chapter);
  return getChapter(1);
}).then(function(chapter) {
  console.log(chapter);
})

在调用 getChapter 之前，我们不会下载 story.json，但是下次（或多次）调用 getChapter 时，我们重用 story promise，因此 story.json 只获取一次。太棒了，Promise!

错误处理

正如我们之前看到的，then() 接受两个参数，一个用于成功，一个用于失败（或 promise 术语中的 fulfill 和 reject）

get('story.json').then(function(response) {
  console.log("Success!", response);
}, function(error) {
  console.log("Failed!", error);
})

你也可以使用 catch()

get('story.json').then(function(response) {
  console.log("Success!", response);
}).catch(function(error) {
  console.log("Failed!", error);
})

catch() 没什么特别之处，它只是 then(undefined, func) 的语法糖，但它更具可读性。请注意，上面的两个代码示例的行为不相同，后者等效于

get('story.json').then(function(response) {
  console.log("Success!", response);
}).then(undefined, function(error) {
  console.log("Failed!", error);
})

区别是微妙的，但非常有用。Promise rejection 跳到下一个带有 rejection 回调的 then()（或 catch()，因为它是等效的）。对于 then(func1, func2)，将调用 func1 或 func2，永远不会同时调用两者。但是对于 then(func1).catch(func2)，如果 func1 rejection，则两者都将被调用，因为它们是链中的单独步骤。以下列为例

asyncThing1().then(function() {
  return asyncThing2();
}).then(function() {
  return asyncThing3();
}).catch(function(err) {
  return asyncRecovery1();
}).then(function() {
  return asyncThing4();
}, function(err) {
  return asyncRecovery2();
}).catch(function(err) {
  console.log("Don't worry about it");
}).then(function() {
  console.log("All done!");
})

上面的流程与普通的 JavaScript try/catch 非常相似，在“try”中发生的错误会立即转到 catch() 块。这是上面的流程图（因为我喜欢流程图）

遵循蓝色线条表示 promise 兑现，红色线条表示 promise 拒绝。

JavaScript 异常和 Promise

Rejection 在 promise 被显式拒绝时发生，但如果在构造函数回调中抛出错误，也会隐式发生

var jsonPromise = new Promise(function(resolve, reject) {
  // JSON.parse throws an error if you feed it some
  // invalid JSON, so this implicitly rejects:
  resolve(JSON.parse("This ain't JSON"));
});

jsonPromise.then(function(data) {
  // This never happens:
  console.log("It worked!", data);
}).catch(function(err) {
  // Instead, this happens:
  console.log("It failed!", err);
})

这意味着在 promise 构造函数回调中完成所有与 promise 相关的工作非常有用，因此错误会自动捕获并变为 rejection。

在 then() 回调中抛出的错误也是如此。

get('/').then(JSON.parse).then(function() {
  // This never happens, '/' is an HTML page, not JSON
  // so JSON.parse throws
  console.log("It worked!", data);
}).catch(function(err) {
  // Instead, this happens:
  console.log("It failed!", err);
})

实践中的错误处理

对于我们的故事和章节，我们可以使用 catch 向用户显示错误

getJSON('story.json').then(function(story) {
  return getJSON(story.chapterUrls[0]);
}).then(function(chapter1) {
  addHtmlToPage(chapter1.html);
}).catch(function() {
  addTextToPage("Failed to show chapter");
}).then(function() {
  document.querySelector('.spinner').style.display = 'none';
})

如果获取 story.chapterUrls[0] 失败（例如，http 500 或用户离线），它将跳过所有后续的成功回调，其中包括 getJSON() 中尝试将响应解析为 JSON 的回调，并且还跳过将 chapter1.html 添加到页面的回调。相反，它会移动到 catch 回调。因此，如果之前的任何操作失败，则会将“Failed to show chapter”添加到页面中。

与 JavaScript 的 try/catch 类似，错误被捕获，后续代码继续执行，因此微调器始终处于隐藏状态，这正是我们想要的。上面变成了非阻塞异步版本

try {
  var story = getJSONSync('story.json');
  var chapter1 = getJSONSync(story.chapterUrls[0]);
  addHtmlToPage(chapter1.html);
}
catch (e) {
  addTextToPage("Failed to show chapter");
}
document.querySelector('.spinner').style.display = 'none'

你可能只想 catch() 用于日志记录目的，而无需从错误中恢复。为此，只需重新抛出错误。我们可以在我们的 getJSON() 方法中执行此操作

function getJSON(url) {
  return get(url).then(JSON.parse).catch(function(err) {
    console.log("getJSON failed for", url, err);
    throw err;
  });
}

因此，我们已经设法获取了一个章节，但我们想要所有章节。让我们实现这一点。

并行和顺序：兼得两者之长

异步思考并不容易。如果你正在努力起步，请尝试编写代码，就好像它是同步的一样。在这种情况下

try {
  var story = getJSONSync('story.json');
  addHtmlToPage(story.heading);

  story.chapterUrls.forEach(function(chapterUrl) {
    var chapter = getJSONSync(chapterUrl);
    addHtmlToPage(chapter.html);
  });

  addTextToPage("All done");
}
catch (err) {
  addTextToPage("Argh, broken: " + err.message);
}

document.querySelector('.spinner').style.display = 'none'

这行得通！但它是同步的，并且会在下载内容时锁定浏览器。为了使异步工作，我们使用 then() 使事情一个接一个地发生。

getJSON('story.json').then(function(story) {
  addHtmlToPage(story.heading);

  // TODO: for each url in story.chapterUrls, fetch &amp; display
}).then(function() {
  // And we're all done!
  addTextToPage("All done");
}).catch(function(err) {
  // Catch any error that happened along the way
  addTextToPage("Argh, broken: " + err.message);
}).then(function() {
  // Always hide the spinner
  document.querySelector('.spinner').style.display = 'none';
})

但是我们如何循环遍历章节 URL 并按顺序获取它们呢？这不起作用

story.chapterUrls.forEach(function(chapterUrl) {
  // Fetch chapter
  getJSON(chapterUrl).then(function(chapter) {
    // and add it to the page
    addHtmlToPage(chapter.html);
  });
})

forEach 不知道异步，因此我们的章节将以它们下载的任何顺序出现，这基本上就是《低俗小说》的编写方式。这不是《低俗小说》，所以让我们修复它。

创建序列

我们想将我们的 chapterUrls 数组转换为 promise 序列。我们可以使用 then() 来做到这一点

// Start off with a promise that always resolves
var sequence = Promise.resolve();

// Loop through our chapter urls
story.chapterUrls.forEach(function(chapterUrl) {
  // Add these actions to the end of the sequence
  sequence = sequence.then(function() {
    return getJSON(chapterUrl);
  }).then(function(chapter) {
    addHtmlToPage(chapter.html);
  });
})

这是我们第一次看到 Promise.resolve()，它创建一个 promise，该 promise 解析为你给它的任何值。如果你将 Promise 的实例传递给它，它将简单地返回它（注意：这是对规范的更改，某些实现尚未遵循）。如果你将类似 promise 的东西（具有 then() 方法）传递给它，它会创建一个真正的 Promise，该 Promise 以相同的方式 fulfill/reject。如果你传入任何其他值，例如 Promise.resolve('Hello')，它会创建一个 promise，该 promise 以该值 fulfill。如果你在没有值的情况下调用它，如上所述，它会以“undefined” fulfill。

还有 Promise.reject(val)，它创建一个 promise，该 promise 以你给它的值（或 undefined）reject。

我们可以使用 array.reduce 来整理上面的代码

// Loop through our chapter urls
story.chapterUrls.reduce(function(sequence, chapterUrl) {
  // Add these actions to the end of the sequence
  return sequence.then(function() {
    return getJSON(chapterUrl);
  }).then(function(chapter) {
    addHtmlToPage(chapter.html);
  });
}, Promise.resolve())

这与之前的示例执行相同的操作，但不需要单独的“sequence”变量。我们的 reduce 回调为数组中的每个项目调用。“sequence”第一次是 Promise.resolve()，但对于其余调用，“sequence”是我们从上一次调用返回的任何内容。array.reduce 对于将数组简化为单个值非常有用，在本例中，该值是一个 promise。

让我们将所有内容放在一起

getJSON('story.json').then(function(story) {
  addHtmlToPage(story.heading);

  return story.chapterUrls.reduce(function(sequence, chapterUrl) {
    // Once the last chapter's promise is done…
    return sequence.then(function() {
      // …fetch the next chapter
      return getJSON(chapterUrl);
    }).then(function(chapter) {
      // and add it to the page
      addHtmlToPage(chapter.html);
    });
  }, Promise.resolve());
}).then(function() {
  // And we're all done!
  addTextToPage("All done");
}).catch(function(err) {
  // Catch any error that happened along the way
  addTextToPage("Argh, broken: " + err.message);
}).then(function() {
  // Always hide the spinner
  document.querySelector('.spinner').style.display = 'none';
})

就这样，我们得到了同步版本的完全异步版本。但我们可以做得更好。目前，我们的页面以下列方式下载

浏览器非常擅长一次下载多项内容，因此我们通过一个接一个地下载章节来损失性能。我们想要做的是同时下载所有章节，然后在所有章节都到达后处理它们。值得庆幸的是，有一个 API 可以做到这一点

Promise.all(arrayOfPromises).then(function(arrayOfResults) {
  //...
})

Promise.all 接受一个 promise 数组，并创建一个 promise，当所有 promise 都成功完成时，该 promise 就会 fulfill。你会得到一个结果数组（promise fulfill 的任何内容），其顺序与你传入的 promise 相同。

getJSON('story.json').then(function(story) {
  addHtmlToPage(story.heading);

  // Take an array of promises and wait on them all
  return Promise.all(
    // Map our array of chapter urls to
    // an array of chapter json promises
    story.chapterUrls.map(getJSON)
  );
}).then(function(chapters) {
  // Now we have the chapters jsons in order! Loop through…
  chapters.forEach(function(chapter) {
    // …and add to the page
    addHtmlToPage(chapter.html);
  });
  addTextToPage("All done");
}).catch(function(err) {
  // catch any error that happened so far
  addTextToPage("Argh, broken: " + err.message);
}).then(function() {
  document.querySelector('.spinner').style.display = 'none';
})

根据连接情况，这可能比逐个加载快几秒钟，并且代码比我们的第一次尝试少。章节可以以任何顺序下载，但它们会以正确的顺序显示在屏幕上。

但是，我们仍然可以提高感知性能。当第一章到达时，我们应该将其添加到页面中。这使用户可以在其余章节到达之前开始阅读。当第三章到达时，我们不会将其添加到页面中，因为用户可能没有意识到第二章丢失了。当第二章到达时，我们可以添加第二章和第三章，等等。

为此，我们同时获取所有章节的 JSON，然后创建一个序列以将它们添加到文档中

getJSON('story.json')
.then(function(story) {
  addHtmlToPage(story.heading);

  // Map our array of chapter urls to
  // an array of chapter json promises.
  // This makes sure they all download in parallel.
  return story.chapterUrls.map(getJSON)
    .reduce(function(sequence, chapterPromise) {
      // Use reduce to chain the promises together,
      // adding content to the page for each chapter
      return sequence
      .then(function() {
        // Wait for everything in the sequence so far,
        // then wait for this chapter to arrive.
        return chapterPromise;
      }).then(function(chapter) {
        addHtmlToPage(chapter.html);
      });
    }, Promise.resolve());
}).then(function() {
  addTextToPage("All done");
}).catch(function(err) {
  // catch any error that happened along the way
  addTextToPage("Argh, broken: " + err.message);
}).then(function() {
  document.querySelector('.spinner').style.display = 'none';
})

就这样，两者兼得！交付所有内容所需的时间相同，但用户可以更快地获得第一部分内容。

在这个简单的示例中，所有章节都几乎同时到达，但是一次显示一个章节的好处将在更多、更大的章节中被放大。

使用 Node.js 风格的回调或事件执行上述操作的代码量大约是原来的两倍，但更重要的是，它不像现在这样容易理解。但是，这并不是 promise 故事的结局，当与 ES6 的其他功能结合使用时，它们会变得更加容易。

奖励环节：扩展功能

自从我最初撰写本文以来，使用 Promise 的能力已大大扩展。自 Chrome 55 以来，异步函数允许以同步方式编写基于 promise 的代码，但不会阻塞主线程。你可以在我的异步函数文章中阅读有关这方面的更多信息。主要浏览器广泛支持 Promise 和异步函数。你可以在 MDN 的 Promise 和异步函数参考文档中找到详细信息。

非常感谢 Anne van Kesteren、Domenic Denicola、Tom Ashworth、Remy Sharp、Addy Osmani、Arthur Evans 和 Yutaka Hirano 校对了本文并提出了更正/建议。

还要感谢 Mathias Bynens 更新了文章的各个部分。

JavaScript Promise：简介 通过集合保持井井有条 根据您的偏好保存和分类内容。

浏览器支持和 Polyfill

这一切有什么大惊小怪的？

事件并不总是最好的方法

Promise 术语

Promise 已经来到 JavaScript!

与其他库的兼容性

复杂的异步代码变得更简单

Promise 化 XMLHttpRequest

链式调用

转换值

异步操作排队

错误处理

JavaScript 异常和 Promise

实践中的错误处理

并行和顺序：兼得两者之长

创建序列

奖励环节：扩展功能

JavaScript Promise：简介
通过集合保持井井有条根据您的偏好保存和分类内容。