es6 Promise对象 学习笔记

Promise是一个对象，从它可以获取异步操作的消息。

Promise对象有以下两个特点

1、对象的状态不受外部影响。

     Promise代表一个异步操作，有三种状态：pending(进行中)、fulfilled(已成功)和rejected(已失败)。

2、一旦状态发生改变，就不会在变，任何时候都能获取到这个结果。 

    Promise的状态改变只有两种可能，pending 变成 fulfilled 或者 pending 变成 rejected。一旦发生改变，状态就会凝固。

 

基本用法

let promise=new Promise((resolve,reject)=>{
    ...
})

Promise对象是一个构造函数，用来生成promise实例

Promise对象接受一个函数，该函数有两个参数：resolve,reject，由js引擎部署。

resolve函数的作用是，将Promise对象的状态从pending转为fulfilled（resolve）,在异步操作成功时调用，并将异步操作的结果作为参数传递出去。

reject函数的作用是，将Promise对象的状态从pending转为reject,在异步操作失败时调用，并将异步操作的错误作为参数传递出去。

Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数

promise.then(function(){
    //success
},function(){
    //fail
})

then方法接受两个回调函数作为参数，第一个回调函数是promise状态变为成功的时候调用的，第二个回调函数是promise状态变为失败的时候调用的，其中第二个函数是可选的。这两个函数都接受Promise对象传出的值作为参数

Promise新建后就会立即执行

 

Promise.prototype.then()

then方法返回的是一个新的Promise实例，所以可以用链式方法,

new Promise((resolve,reject)=>{
    resolve('hello')
}).then((data)=>{
    console.log(data) //'hello'
    return 'world'
}).then((data)=>{
    console.log(data) //'world'
})

在链式方法中，第一个then方法的返回值会作为参数传给下一个then方法

 

Promise.prototype.catch()

catch方法 其实就是.then(null.rejection)的别名，用于指定发生错误时的回调函数

Promise 对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一个catch语句捕获。

一般来说，不要在then方法里面定义 Reject 状态的回调函数（即then的第二个参数），总是使用catch方法。

跟传统的try/catch代码块不同的是，如果没有使用catch方法指定错误处理的回调函数，Promise 对象抛出的错误不会传递到外层代码，即不会有任何反应

 

Promise.prototype.finally()

finally()方法用于指定不管Promise对象最后状态如何，都会执行的操作。该方法不接受任何参数，里面的操作与状态无关，不依赖于Promise的执行结果。

new Promise((resolve,reject)=>{
   ...
}).then(data=>{}).catch(data=>{}).finally(()=>{})

 

Promise.all()

Promise.all方法用于将多个 Promise 实例，包装成一个新的 Promise 实例。Promise.all方法的参数可以不是数组，但必须具有 Iterator 接口，且返回的每个成员都是 Promise 实例。

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

只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。

只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。

注意，如果作为参数的 Promise 实例，自己定义了catch方法，那么它一旦被rejected，并不会触发Promise.all()的catch方法。

var p = new Promise( ( resolve, reject ) => {
    reject( 123 )
} ).catch( data => {
    return data
} )

Promise.all( [ 1, 2, p ] ).then( data => {
    console.log( data ) //[1,2,123]
} ).catch(data=>{
    console.log(data)  
})

//上面的代码中,promise.all接受一个数组作为参数，数组中 前两个元素不是promise实例，所以调用了Promise.resolve()方法,先转为Promise实例。

//因为 数组里的第三个元素 定义了catch方法,所以出发了这个实例的catch方法，而没有触发 promise.all()方法的catch方法

 

Promise.race()

Promise.race方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例。

const p = Promise.race([p1, p2, p3]);

上面代码中，只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数 

Promise.race方法的参数与Promise.all方法一样，如果不是 Promise 实例，就会先调用下面讲到的Promise.resolve方法，将参数转为 Promise 实例，再进一步处理。

 

Promise.resolve()

Promise.resolve()的作用是将现有对象转为Promise对象。

Promise.resolve等价于下面的写法。

Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))

Promise.resolve方法的参数分成四种情况。

1、参数是一个 Promise 实例 

      如果参数是 Promise 实例，那么Promise.resolve将不做任何修改、原封不动地返回这个实例。

2、参数是一个thenable对象

      thenable对象指的是具有then方法的对象，比如下面这个对象。

let thenable = {
  then: function(resolve, reject) {
    resolve(42);
  }
};

Promise.resolve方法会将这个对象转为 Promise 对象，然后就立即执行thenable对象的then方法。 

3、参数不是具有then方法的对象，或根本就不是对象

     如果参数是一个原始值，或者是一个不具有then方法的对象，则Promise.resolve方法返回一个新的 Promise 对象，状态为resolved。

const p = Promise.resolve('Hello');

p.then(function (s){
  console.log(s)
});
// Hello

4、不带有任何参数

Promise.resolve方法允许调用时不带参数，直接返回一个resolved状态的 Promise 对象。 

 

Promise.reject()

Promise.reject(reason)方法也会返回一个新的 Promise 实例，该实例的状态为rejected。

注意，Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。这一点与Promise.resolve方法不一致。

const thenable = {
  then(resolve, reject) {
    reject('出错了');
  }
};

Promise.reject(thenable)
.catch(e => {
  console.log(e === thenable) //true
})

 

Promise.try()