Promise对象

3、Promise.prototype.then()

作用：为Promise实例添加状态改变时的回调函数

Promise实例具有then方法 即then方法是定义在原型对象Promise.prototype上的

then方法返回的是一个新的Promise实例

getJSON("/post/1.json").then(function(post){   
                    return getJSON(post.commentURL);   /*第一个 then方法指定的回调函数返回的是另一个Promise对象*/
                }).then(function funcA(comments){
                    console.log("Resolved:",comments);/*新的Promise对象的状态发生变化，为resolved时 调用funcA*/
                },function funB(err){
                    console.log("Rejected:",err);/*为rejected时 调用funcB*/
                });

第一个then方法返回的是一个新的Promise对象，第二个then方法指定的回调函数就会等这个新的Promise对象状态发生改变，如果变为Resolved就调用funcA，如果为rejected，就调用funcB

 

4、Promise.prototype.catch()

作用：用于指定发生错误时的回调函数

Promise.prototype.catch()方法是.then（null，rejection）的别名

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

如果Promise状态已经变成Resolved，在抛出错误就无效

promise对象的错误具有“冒泡”性质，会一直向后传递，知道被捕获为止

getJSON("/post/1.json").then(function(post){
                    return getJSON(post.commentURL);
                }).then(function(comments){
                    //some code 
                }).catch(function(error){
                    //处理前面3个Promise产生的错误
                }）;

一共有三个Promise对象：getJSON产生一个，两个then各产生一个，其中任何一个抛出的错误都会被最后一个catch捕获。

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

catch方法返回的也是一个promise对象，因此后面还可以接着调用then方法，catch方法中还可以再抛出错误

 

5、Promise.all()

作用：将多个Promise实例包装成一个新的Promise实例

var P = Promise.all([p1,p2,p3]);

Promise.all方法接受一个数组作为参数，p1,p2,p3都是Promise对象的实例（如果不是Promise实例，就调用Promise.resolve方法，将参数转为Promise实例）

Promise.all方法的参数不一定是数组，但必须具有Iterator接口，且返回的每个成员都是Promise实例

P的状态由p1,p2,p3决定：

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

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

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

 const p2 = new Promise((resolve,reject)=>{
                    throw new Error('报错了');
                })
     .then(result=>result)
     .catch(e=>e);      //p2自己的catch捕获错误，产生一个新的promise实例

 Promise.all([p1,p2])   //p2指向的是catch完之后的新的promise
   .then(result=>console.log(result))
    .catch(e=>console.log(e));

 

6、Promise.race（）

作用：将多个Promise实例包装成一个新的Promise实例（如果不是Promise实例，就调用Promise.resolve方法，将参数转为Promise实例）

var P = Promise.all([p1,p2,p3]);

只要p1,p2,p3中有一个实例率先改变状态，P的状态就跟着改变。那个率先改变的Promise实例的返回值就传递给P的回调函数

const p = Promise.race([
                    fetch('/resource-that-may-take-a-while'),
                    new Promise(function(resolve,reject){
                        setTimeout(()=>reject(new Error('request timeout')),5000)
                    })
                    ]);
                p.then(response=>console.log(response));
                p.catch(error=>console.log(error));

若5秒之内丰田车方法无法返回结果，变量P的状态就会变为Rejected，从而触发catch方法指定的回调函数

7、Promise.resolve()

作用：将现有的对象转为Promise对象

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

讲jQuery生成的deferred对象转为新的Promise对象。

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

参数的四种情况：

a、参数是一个Promise实例

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

b、参数是一个thenable对象

thenable对象指的是具有then方法的对象

let thenable = {    /*thanable是一个具有then方法的对象*/
                    then:function(resolve,reject){
                        resolve(42);
                    }
                };
                let p1 = Promise.resolve(thenable);  /*将thenable对象转为Promise对象*/
                p1.then(function(value){
                    console.log(value);      // 42
                }); 

c、参数不是具有then方法的对象或者根本不是对象

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

var p = Promise.resolve('Hello');
                p.then(function(s){
                    console.log(s)                    //Hello
                });

Hello不是（判断方法：字符串对象不具有then方法）异步操作，返回的Promise实例的状态从生成起就是Resolved，所以回调含赎回立即执行 

d、不带有任何参数

Promise.resolve方法允许在调用时不带有参数，而且直接返回一个Resolved状态的Promise对象

！！！立即resolve的Promise对象式子本轮“事件循环”（event loop）结束时，而不是在下一轮“事件循环”开始时

setTimeout(function(){
     console.log('three');    //下一轮“事件循环”开始时执行
  },0);
Promise.resolve().then(function(){
      console.log('two');               //本轮“事件循环”结束时
 });
console.log('one');                    //立即执行

输出： one   

            two 

            three 

8、Promise.reject()

作用：返回一个新的Promise实例，状态为Rejected

var p = Promise.reject('出错了')；

等价于
 var p = new Promise((resolve,reject) => reject('出错了'))

注意：

Promise.reject（）方法的参数会将原封不动的作为reject的理由变成后续方法的参数

9、附加方法

• done（）

作用：done方法总是处于毁掉练的尾端，保证抛出任何可能出现的错误

asyncFunc()
   .then(f1)
    .catch(r1)
     .then(f2)
      .done();

• finally（）

作用：指定不管Promise对象最后状态如何都会执行的操作