深度理解Promise--Promise的特色和方法详解

时间 2019-11-09

标签深度理解 promise 特色方法详解繁體版

原文原文链接

什么是promise？

Promise（承诺），在程序中的意思就是承诺我过一段时间（一般是一个异步操做）后会给你一个结果，是异步编程的一种解决方案。从语法上说，原生Promise 是一个对象，从它能够获取异步操做的消息。javascript

promise的特色

对象的状态不受外界影响。

promise有三种状态 pending（进行中） fulfilled（已成功） rejected（已失败），只有异步操做的结果，才能够决定当前是哪种状态，任何其余操做都没法改变这个状态。java

一旦从等待状态变成为其余状态就永远不能更改状态了。

promise只有两种状态改变：
pending（进行中）--> fulfilled（已成功）；
pending（进行中）--> rejected（已失败）。
当状态改变结束时称为resolve（已固定），一旦状态变为 resolved 后，就不能再次改变为Fulfilled。ios

一旦新建Promise就会当即执行，没法中途取消。
若是不设置回调函数callback，Promise内部抛出的错误，就不会反应到外部。
当处于pending状态时，没法得知目前进展到哪个阶段（刚刚开始仍是即将完成）。

promise实例操做

首先创造了一个Promise实例

let promise=new Promsie(function(resolve,rejec){
    if(/*异步执行成功*/){
        resolve(value);
    }else{
        reject(error);
    }
})
promise.then(function(){
    //回调执行成功以后的操做
},function(){
    //回调执行失败以后的操做，可选
});

Promise构造函数接受一个函数做为参数，该函数的两个参数分别是resolve和reject。它们是两个函数，由 JavaScript 引擎提供。当异步操做成功时（pending--fulfilled），调用resolve（value）函数把操做结果当成参数传出，当异步操做成功时（pending--rejected）调用 reject(error)函数把错误返回。Promise实例生成之后，用then方法分别指定resolved状态和rejected状态的回调函数。es6

下面看一下构造函数原型的方法

Promise.prototype.then()

Promise.prototype.then()做用是为 Promise 实例添加状态改变时的回调函数。接受两个回调函数做为参数。第一个回调函数是Promise对象的状态变为resolved时调用，第二个回调函数是Promise对象的状态变为rejected时调用。其中，第二个函数是可选的，不必定要提供。
而Promise.prototype.then()返回的是另外一个Promise对象，后面还能够接着调用then方法。

Promise.prototype.catch()

Promise.prototype.catch()则是.then(null, rejection)或.then(undefined, rejection)的别名，用于指定发生错误时的回调函数。 Promise 对象的错误具备“冒泡”性质，会一直向后传递，直到被捕获为止。也就是说，错误老是会被下一个catch语句捕获。
Promise.catch()方法返回的也是一个 Promise 对象，所以后面还能够接着调用then方法。

上述代码也能够理解成这样：ajax

getJSON('/posts.json').then(function(posts) {
      // ...
}).catch(function(error) {
  // 处理 getJSON 和 前一个回调函数运行时发生的错误
  console.log('发生错误！', error);
});

Promise.prototype.finally()

finally方法用于指定无论 Promise 对象最后状态如何，都会执行的回调函数。该方法是 ES2018 引入标准的。
finally方法的回调函数不接受任何参数，这意味着没有办法知道，前面的 Promise 状态究竟是fulfilled仍是rejected。这代表，finally方法里面的操做，应该是与状态无关的，不依赖于 Promise 的执行结果。

finally本质上是then方法的特例。编程

promise.then(()=>{}).catch(()=>{}).finally(() => {
      // 操做
});
// 等同于
promise.then(result => {
        // 操做
    return result;
}).catch( error => {
        // 操做
    throw error;
});

promise的链式调用

因为 .then每次调用返回的都是一个新的Promise实例，若是then中返回的是一个结果的话会把这个结果传递下一次then中的成功回调，因此能够链式调用该实例。
若是then中出现异常,会走下一个then的失败回调，catch 会捕获到没有捕获的异常。
在 then中使用了return，那么 return 的值会被Promise.resolve() 包装，then中也能够不传递参数，若是不传递会透到下一个then中。json
```
Promise.resolve(1).then(res => {
        console.log(res)
        return 2 //包装成 Promise.resolve(2)
}).catch(err => 3).then().then(res => console.log(res))
```

promise自身API

Promise.resolve()

将现有的对象转换（包装）成 promise对象。四种参数类型：axios

不带参数传递 --- 返回一个新的状态为resolve的promise对象。数组
```
let p = Priomse.resolve()   // p就是promise
```
参数是一个 Promise 实例--- 返回当前的promise实例
参数是带then方法的对象promise
```
let data = {
    then:function(resolve,reject){
        resovle('带then方法的对象')
    }
}
Promise.resolve(data).thne((res)=> console.log(res)) // '带then方法的对象'
```
返回一个新的promise，并直接执行then的方法，promise对象的状态就变为resolved，从而当即执行最后那个then方法指定的回调函数，输出 '带then方法的对象'。
参数是非空，非then方法的对象，非proimse的
```
let p = Promise.resolve('foo')
// 等价于
let p = new Promise(resolve => resolve('foo'))
p.then(res=>console.log(res)) //'foo'
```
返回一个新的状态为resolve的promise对象，因此then回调函数会当即执行。Promise.resolve方法的参数，会同时传给回调函数。

Promise.reject()

参数为非then对象时-----Promise.reject(reason)方法也会返回一个新的 Promise 实例，该实例的状态为rejected

let p  =  Promise.reject('error')
// 等价于
let p = new Primose((resolve,reject)=>reject('出错了')})
//处理错误的回调
p.then((null,res)=>console.log(res)) //'出错了'

参数是带then方法的对象 ---返回的并非then方法的回调函数，而是data对象自己

let data = {
    then:function(resolve,reject){
        reject('带then方法的对象出错了')
    }
}
Promise.resolve(data).thne((null,res)=> console.log(res)) // data 
//等同于
Promise.resolve(data).catch(res=> console.log(res)) // data

Promise.all()

该方法将多个promise实例，包装成一个新的promise实例。

let p = Promise.all([p1,p2,p3])

参数不必定为数组，但必须为一个可迭代Iterator ，且返回的每一个成员（p1,p2,p3）都是 Promise 实例，若是不是，就会先调用的Promise.resolve方法，将参数转为 Promise 实例，再进一步处理。

var p = Promise.all([1,2,3]);
var p2 = Promise.all([1,2,3, Promise.resolve(444)]);
var p3 = Promise.all([1,2,3, Promise.reject(555)]);
setTimeout(function() {
    console.log(p);// Promise { <state>: "fulfilled", <value>: Array[3] }
       console.log(p2); // Promise { <state>: "fulfilled", <value>: Array[4] }
    console.log(p3); // Promise { <state>: "rejected", <reason>: 555 }
});
p.then(function (posts) {
  // ..当有返回值的时候才会回调
}).catch(function(reason){
  // ...
});

当p1,p2,p3中得实例都改变成 fulfilled（已成功）时，此时p一、p二、p3的返回值组成一个数组，传递给p的回调函数。
当p1,p2,p3中得实例其中一项的改变成 rejected（已失败）时，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。
Promise.all()是异步解析,只有这当全部实例的状态都变成fulfilled，或者其中有一个变为rejected，才会调用Promise.all方法后面的回调函数then,catch方法。可是当且仅当传递的iterable为空时，Promise.all才会同步解析。
```
var p = Promise.all([]); 
console.log(p);//Promise { <state>: "fulfilled", <value>: Array[0] }
```
处理错误，常规状况下，当其中一个实例返回rejected，就会调用Promise.all的catch方法，返回第一个错误。但实际应用时，咱们想让全部的实例不论成功或失败就能够返回参数组成数组，这时就能够调用实例自身的catch方法来规避这种状况。
```
const p1 = new Promise((resolve, reject) => {
  resolve('hello'); //resolved
}).then(result => result).catch(e => e);

const p2 = new Promise((resolve, reject) => {
  throw new Error('报错了');//rejected
}).then(result => result).catch(e => e);

Promise.all([p1, p2])
.then(result => console.log(result))// ["hello", Error: 报错了]
.catch(e => console.log(e));
```
p1会resolved，p2首先会rejected，可是p2有本身的catch方法，该方法返回的是一个新的 Promise 实例，p2指向的其实是这个实例。该实例执行完catch方法后，也会变成resolved，致使Promise.all()方法参数里面的两个实例都会resolved，所以会调用then方法指定的回调函数，而不会调用catch方法指定的回调函数。

js原生实现Promise.all的原理

//在Promise类上添加一个all方法，接受一个传进来的promise数组
Promise.all = function (promiseArrs) { 
   return new Promise((resolve, reject) => { //返回一个新的Promise
    let arr = []; //定义一个空数组存放结果
    let i = 0;
    function handleData(index, data) { //处理数据函数
        arr[index] = data;
        i++;
        if (i === promiseArrs.length) { //当i等于传递的数组的长度时 
            resolve(arr); //执行resolve,并将结果放入
        }
    }
    for (let i = 0; i < promiseArrs.length; i++) { //循环遍历数组
        promiseArrs[i].then((data) => {
            handleData(i, data); //将结果和索引传入handleData函数
        }, reject)
    }
    })
}

若是说all体验很差，那咱们也能够本身作一个some方法，表示所有失败才算失败

Promise.some = function (promiseArrs) {
  return new Promise((resolve, reject) => {
  let arr = []; //定义一个空数组存放结果
  let i = 0;
  function handleErr(index, err) { //处理错误函数
      arr[index] = err;
      i++;
      if (i === promiseArrs.length) { //当i等于传递的数组的长度时 
        reject(err); //执行reject,并将结果放入
      }
  }
  for (let i = 0; i < promiseArrs.length; i++) { //循环遍历数组
      promiseArrs[i].then(resolve, (e) => handleErr(i, e))
  }
  })
}

Promise.allSettled -- 兼容性不友好

该方法和promise.all相似，就是解决all方法在处理错误时的不合理而出现的。其参数接受一个Promise的数组, 返回一个新的Promise, 惟一与all的不一样在于, 其不会进行短路, 也就是说当Promise所有处理完成后咱们能够拿到每一个Promise的状态, 而无论其是否处理成功。

和all相似，当自身实例有catch回调时，每一个实例状态变为fulfilled

const p3 = new Promise((resolve, reject) => {
  resolve('hello'); //resolved
}).then(result => result).catch(e => e);

const p4 = new Promise((resolve, reject) => {
  throw new Error('报错了');//rejected
}).then(result => result).catch(e => e);

Promise.allSettled([p3, p4])
.then(result => console.log(result))
.catch(e => console.log(e));
//.then的log
//[{status: "fulfilled", value: "hello"},{status: "fulfilled", reason: Error: 报错了 at <anonymous>:6:10 at     new Promise (<anonymous>) at <anonymous>:5:13}]

没有catch接收错误，返回自身的状态和回调参数

const p5 = new Promise((resolve, reject) => {
  resolve('hello'); //resolved
}).then(result => result)

const p6 = new Promise((resolve, reject) => {
  throw new Error('报错了');//rejected
}).then(result => result)

Promise.allSettled([p5, p6])
.then(result => console.log(result))
.catch(e => console.log(e));
//.then的log
//[{status: "fulfilled", value: "hello"},{status: "rejected", reason: Error: 报错了 at <anonymous>:6:10 at     new Promise (<anonymous>) at <anonymous>:5:13}]

Promise.race()

该方法一样是将多个 Promise 实例，包装成一个新的 Promise 实例，其余特色和all很像，和all的区别在于：race方法比如是赛跑，几个实例一块儿跑，谁先到就成功了，就resolve谁，或者谁跑到中途摔了出现异常情况失败了，就reject谁，不论成功仍是失败，就先捕获第一个完成的。

捕获第一个成功的实例回调函数

let p1 = Promise.resolve('1')
let p2 = Promise.resolve('2')
Promise.race([p1,p2]).then(res=>conseloe.log(res))// '1'

捕获第一个结果

let p1 = Promise.resolve("1");
  let p2 = Promise.reject("ERR2");
 Promise.race([p1,p2]).then(res=>conseloe.log(res)) //Promise {<resolved>: "1"}

捕获第一个错误

let p1 = Promise.reject("ERR1");
  let p2 = Promise.reject("ERR2");
 Promise.race([p1,p2]).catch(console.log) //Promise {<reject>: "ERR1"}

原生实现Promise.race()的设计原理

Promise._race = iterator  =>{
    return new Promise((resolve,reject)=>{
        iterator.forEach(item=>{
            Promise.resolve(item).then(resolve).catch(reject)
        })
    })
}

Promise.try-- 提案

在实际开发使用promise时，但愿通过promise包装后的函数内部代码让同步函数同步执行，异步函数异步执行，而且让它们具备统一的 API
例：当同步函数被promise包装后的执行顺序改变。

let fn = () =>console.log('同步1');
Promise.resolve().then(fn)
console.log('同步2')
//log后
//'同步2'
//'同步1'

Promise.try的应用
该方法是用来模拟try的代码块的，就像promise.catch模拟的是catch代码块。

理解 try catch finally

try catch是JavaScript的异常处理机制，把可能出错的代码放在try语句块中，若是出错了，就会被catch捕获来处理异常。若是不catch 一旦出错就会形成程序崩溃。finally：不管结果如何，容许在 try 和 catch 以后执行代码。

try {
        // 供测试的代码块
}
 catch(err) {
         //处理错误的代码块
} 
finally {
         //不管 try / catch 结果如何都执行的代码块
}

应用

let fn = () => console.log('同步1');
  Promise.try(fn);
  console.log('同步2');
  //'同步1'
  //'同步2'

解决让同步函数同步执行，异步函数异步执行现阶段方法

方法一：使用async匿名函数,会当即执行里面的async函数，所以若是f是同步的，就会获得同步的结果；若是f是异步的，就能够用then指定下一步，若是想捕获错误，使用catch方法。
```
let fn = () =>console.log('同步1');
 (async ()=>fn())()
 .then(resolve)
 .catch(err=>console.log(err))
 console.log('同步2')
 //log后
 //'同步1'
//'同步2'
```

方法二：使用promise当即执行的匿名函数

let fn = () =>console.log('同步1');
(
    () => new Promise(
       resolve => resolve(fn())
 ))()
console.log('同步2')
//log后
//'同步1'
       //'同步2'

over~有问题留言
拓展：

什么是Iterator ？
异步编程是什么？异步编程都有哪些解决方案？
如何使用promise实现ajax，封装axios？
如何使用纯原生js实现promise？

借鉴：
https://blog.csdn.net/sjw1039...
http://es6.ruanyifeng.com/#do...
https://developer.mozilla.org...