promise讲解

promise 简介

Promise是ES6加入标准的一种异步编程解决方案，一般用来表示一个异步操做的最终完成 (或失败)。Promise标准的提出，解决了JavaScript地狱回调的问题。

语法

var p = new Promise( function(resolve, reject) {...} /* executor */  );
p.then(() => {}) // 成功resolve .catch(()=> {}); // 失败reject 复制代码

构造函数

Promise构造函数executor 函数， resolve 和 reject 两个函数做为参数传递给executor（executor 函数在Promise构造函数返回所建 promise 实例对象前被调用）。resolve 和 reject 函数被调用时，分别将promise的状态改成fulfilled（完成）或rejected（失败）。executor 内部一般会执行一些异步操做，一旦异步操做执行完毕(可能成功/失败)，要么调用resolve函数来将promise状态改为fulfilled，要么调用reject 函数将promise的状态改成rejected。若是在executor函数中抛出一个错误，那么该promise 状态为rejected。executor函数的返回值将被忽略。

描述

Promise对象在建立以后，并不必定会立刻就有值，只是一个代理结果，它存在三种状态：

• pending: 初始状态(等待状态)，既不是成功，也不是失败状态。
• fulfilled: 意味着操做成功完成。
• rejected: 意味着操做失败完成。

方法

Promise.all(iterable)

这个方法返回一个新的 promise 对象。通常该方法会接受一个iterable参数，里面是一个promise列表，当全部的promise都触发成功时才会触发成功，一旦有一个失败了，则会立刻中止其余promise的执行。当iterable里面的结果都执行成功了，这个新的promise对象会将全部的结果已数组的形式依次返回。当有一个失败是，这个新的promise对象会将失败的信息返回。

Promise.race(iterable)

当 iterable 参数里的任意一个子 promise 被成功或失败后，父 promise 立刻也会用子 promise 的成功返回值或失败详情做为参数调用父 promise 绑定的相应句柄，并返回该 promise 对象。

Promise.reject(rease)

返回一个状态为失败的 Promise 对象，并将给定的失败信息传递给对应的处理方法

Promise.resolve(value)

返回一个状态由给定 value 决定的 Promise 对象。若是该值是 thenable(即，带有 then 方法的对象)，返回的 Promise 对象的最终状态由 then 方法执行决定；不然的话(该 value 为空，基本类型或者不带 then 方法的对象),返回的 Promise 对象状态为 fulfilled，而且将该 value 传递给对应的 then 方法。一般而言，若是你不知道一个值是不是 Promise 对象，使用 Promise.resolve(value) 来返回一个 Promise 对象,这样就能将该 value 以 Promise 对象形式使用。

实例

枯燥的说明终于结束了，下面用一个具体的实例来展现各类状态和方法：

// 建立promise1，构造函数有2个参数resolve,reject
const p1 = new Promise((resolve, reject) => {  console.log('我一开始就会执行！')  setTimeout(() => {  resolve('timeout 1')  }, 1000) }) // promise2 const p2 = new Promise((resolve, reject) => {  setTimeout(() => {  resolve('timeout 2')  }, 2000) }) console.log(p1, p2, 'p1, p2状态') // Promise.race方法,任何一个成功或失败就会执行then方法 Promise.race([p1, p2]).then(res => {  console.log(res, 'race结果') }) // Promise.all方法 Promise.all([p1, p2]).then(res => {  console.log(res, 'all结果')  console.log('此时：', p1, p2, 'p1, p2状态') }) // Promise.reject方法测试 Promise.reject('失败').catch(err => console.log('Promise.reject:' + err)) // Promise.resolve方法测试 Promise.resolve(1).then(r => console.log('Promise.resolve的结果1：' + r)) Promise.resolve(p1).then(r => console.log('Promise.resolve的结果2：' + r)) 复制代码

上面的代码和执行结果简单的说明了Promise建立，存在状态和方法的使用。下面再详细介绍Promise的使用方法。

promise 的使用方法

本文一开始就提出，Promise能解决前端臭名昭著的地狱回调问题，那什么是地狱回调呢？这里简单拿一个场景和实现方法来解释一下：

场景

前端很常见是下面一个场景，咱们须要实现一个用户修改头像的功能。首先咱们须要将一张图片压缩并提交给后端，后端返回该图片保存的 url，前端拿保存的 url 和用户 id 提交给服务器来修改用户头像。

1. 异步一：加载图片
2. 异步二：压缩图片
3. 异步三：上传图片
4. 异步四：提交保存

大概代码实现：

// 读取头像，异步过程，成功以后执行回调函数
function readImg(callback) {  const img = new Image();  img.onload = function () {  callback && callback(img)  } }  // 压缩一张图片，压缩过程异步，成功以后执行回调函数 function compression(img, callback) {  zipImg(img, callback) } // 上次用户头像，异步请求 function uploadImg(img, callback) {  $.ajax({  url: '/upload',  data: img,  success: function (url) {  callback && callback(url)  }  }) } // 保存最终数据，用户头像，异步请求 function saveData(url, callback) {  $.ajax({  url: '/save',  data: {id, url},  success: function (res) {  callback && callback(res)  }  }) } // 保存函数 function submit() {  readImg(function (img) {  compression(img, function (img) {  uploadImg(img, function (url) {  saveData(url, function (res) {  console.log(res)  })  })  })  }) } 复制代码

上面的场景在咱们开发的过程当中很常见，由于js的异步特性，异步执行结果只能在回调函数里面才能拿到，因此就有了最终的回调地狱。这个过程异常极难排查，并且一层一层嵌套，代码极难维护也不美观。利用promise链式调用（chaining）的特色，咱们能够将上面的代码改为下面的形式：

function submit() {
 readImg().then(img => {  return compression(img)  }).then(img => {  return uploadImg(img)  }).then(url => {  return saveData(url)  }).then(res => {  console.log(res)  }).catch(err => {  console.log(err)  }) } 复制代码

能够看到代码结构不只变成平铺的了，异常处理也变得简单了，只须要最后catch一个异常，就能捕获整个过程的异常。

用法

promise 建立

变量的的方式建立:

const myFirstPromise = new Promise((resolve, reject) => {
 // ?作一些异步操做，最终会调用下面二者之一:  // resolve(someValue); // fulfilled  // ?或  // reject("failure reason"); // rejected }); myFirstPromise.then(res =>{  // 成功doSomething } ).catch(err => {  // 失败doSomething }) 复制代码

函数的方式建立：

const myFirstPromise = function() {
 return new Promise((resolve, reject) => {  // 一个异步过程  // resolve() 成功 fulfilled  // reject() 失败 rejected  }) } myFirstPromise().then(res =>{  // 成功doSomething } ).catch(err => {  // 失败doSomething }) 复制代码

使用场景

在异步时，给出异步后的结果：

const myFirstPromise = function() {
 return new Promise((resolve, reject) => {  setTimeout(() => {  resolve()  },1000)  }) } myFirstPromise.then(()=>{  console.log('一秒后！') }) 复制代码

多个异步都须要结果才往下执行时，使用promise.all:

Promise.all([func1(), func2(), func3()])
.then(([result1, result2, result3]) => { /* use result1, result2 and result3 */ }); 复制代码

顺序执行一组异步，拿到最后的结果，使用Promise.resolve和reduce函数结合来实现：

var funca = function (a) {
 return new Promise((resolve, reject) => {  setTimeout(() => {  console.log(a, 'result funca');  resolve(a + 1)  }, 1000)  }) } var funcb = function (result) {  return new Promise((resolve, reject) => {  setTimeout(() => {  console.log(result, 'result funcb')  resolve(2 + result)  }, 1000)  }) }  var funcc = function(result) {  return new Promise((resolve, reject) => {  setTimeout(() => {  console.log(result, 'result funcc')  resolve(3 + result)  }, 1000)  }) } var funcd = function(d) {  console.log(d, 'result funcd')  return d + 4 } const applyAsync = (acc,val) => acc.then(val); const composeAsync = (...dd) => x => dd.reduce(applyAsync, Promise.resolve(x)); const transformData = composeAsync(funca, funcb, funcc, funcd); transformData(1).then(result => console.log(result,'last result')).catch(e => console.log(e)); 复制代码

上面 3 个异步函数和一个同步函数，咱们利用Promise.resolve的特性，顺序执行了 3 个异步函数，最后在then里面取到了最后的执行结果。并且上面的函数是可复用的，能顺序执行任意数量的异步函数和同步函数。

常见错误写法

在编写 Promise 链时，须要注意如下示例中展现的几个错误：

// 错误示例，包含 3 个问题！
doSomething().then(function(result) {  doSomethingElse(result) // 没有返回 Promise 以及没有必要的嵌套 Promise  .then(newResult => doThirdThing(newResult)); }).then(() => doFourthThing()); // 最后，是没有使用 catch 终止 Promise 调用链，可能致使没有捕获的异常 复制代码

第一个错误是没有正确地将事物相链接。当咱们建立新 Promise 但忘记返回它时，会发生这种状况。所以，链条被打破，或者更确切地说，咱们有两个独立的链条竞争（同时在执行两个异步而非一个一个的执行）。这意味着 doFourthThing() 不会等待 doSomethingElse() 或 doThirdThing() 完成，而且将与它们并行运行，多是无心的。单独的链也有单独的错误处理，致使未捕获的错误。

第二个错误是没必要要地嵌套，实现第一个错误。嵌套还限制了内部错误处理程序的范围，若是是非预期的，可能会致使未捕获的错误。其中一个变体是 Promise 构造函数反模式，它结合了 Promise 构造函数的多余使用和嵌套。

第三个错误是忘记用 catch 终止链。这致使在大多数浏览器中不能终止的 Promise 链里的 rejection。

一个好的经验法则是老是返回或终止 Promise 链，而且一旦你获得一个新的 Promise，返回它。下面是修改后的平面化的代码：

doSomething()
.then(function(result) {  return doSomethingElse(result); }) .then(newResult => doThirdThing(newResult)) .then(() => doFourthThing()) .catch(error => console.log(error)); 复制代码

兼容性

大多数浏览器已经支持了promise，在babel的加持下，咱们无需担忧。

总结

1. Promise是 ES6加入标准的一种异步编程解决方案，一般用来表示一个异步操做的最终完成 (或失败)。
2. promise链式调用的特色，解决了 js 地狱回调的问题。
3. promise提供了一系列属性和方法。合理利用 Promise.all和 Promise.resolve能够解决很多问题。

写在最后

下期会结合本期的讲解，配合一些经典的promise面试题来更深刻的了解promise。毕竟promise过重要，太好用了。 后面会有async/await和promise的讲解。

参考资料：

promise 使用指南^[1]

相关阅读：

前端异步是什么？哪些状况下会发生异步？

知道html5 Web Worker标准吗？能实现JavaScript的多线程？

学习如逆水行舟，不进则退，前端技术飞速发展，若是天天不坚持学习，就会跟不上，我会陪着你们，天天坚持推送博文，跟你们一同进步，但愿你们能关注我，第一时间收到最新文章。

公众号前端每日面试题分享：

参考资料

[1]

promise使用指南: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Using_promises