Promise的使用

Promise 特性是异步编程的一种解决方案，对象代表了未来将要发生的事件，通过Promise，可以避免回调函数的层层嵌套
Promise有两个特征

1. 对象的状态代表异步操作结果，一共有三种状态，
   pending:进行中
   resolved:已成功
   rejected:已失败,
   只有异步操作的结果能够决定对象的状态
2. 对象状态一旦改变，就不能再被改变，且状态只能从pending改变为resolved以及pending改变为rejected

Promise对象通过Promise构造函数生成，构造函数接收一个函数为参数，Promise对象建立后就会立即执行参数函数，此函数以resolve，reject两个函数作为参数，执行resolve函数可使Promise对象状态更改为resolved，执行reject函数可使Promise对象状态更改为rejected，

    new Promise((resolve, reject) => {});
    new Promise((resolve, reject) => {
        resolve()
    });
    new Promise((resolve, reject) => {
        reject()
    })

then()

Promise对象可以通过then()方法来执行resolve(),reject()回调，同时返回一个新Promise对象,其中reject()参数可选

promise.then(resolve, reject)

 var obj;
var resolvePromise = new Promise((resolve, reject) => {
        var param = {};
        obj = param;
        resolve(param);
    });

需要注意的是resolve和reject并不会终止Promise的执行

new Promise((resolve, reject) => {      
        resolve();
        console.log("Promise没有停止执行")
    });

catch()

Promise可以通过catch来执行指定发生错误时的回调函数同时返回一个新Promise对象

new Promise((resolve, reject) => {      
        reject("发生错误");
        
    }).catch(error=>{console.log(error)});

then方法指定的回调函数发生错误，也会被catch捕获

new Promise((resolve, reject) => {      
        resolve("resolve");    
    }).then(info => {
        var result = wrong+info
    }).catch(err=>{
        console.log("打印错误信息")
        console.log(err)
    })

如果Promise已经resolved，那么之后的错误将不再捕捉

new Promise((resolve, reject) => {      
        resolve("resolve");  
        var result = wrong  
    }).catch(err=>{
        console.log("打印错误信息")
        console.log(err)
    })

catch方法中还能再次抛出错误

new Promise((resolve, reject) => {       
        var result = wrong 
        resolve()
    }).catch(err=>{
        console.log("打印错误信息")
        console.log(err)
        let obj = {}
        obj.err.size = 0;
    }).catch(err=>{
        console.log("再一次捕捉错误，打印错误信息")
        console.log(err)
    })

finally()

promise最后不管状态如何，都会执行finally()

new Promise((resolve, reject) => {       
        var result = wrong 
        resolve()
    }).catch(err=>{
        console.log("打印错误信息")
        console.log(err)
        let obj = {}
        obj.err.size = 0;
    }).catch(err=>{
        console.log("再一次捕捉错误，打印错误信息")
        console.log(err)
    }).finally(info=>{
        console.log("finally都会执行")
    })

Promise.all()

Promise.all()用于将多个Promise实例包装成一个Promise

Promise.all([new Promise((resolve, reject) => {     
    }), new Promise((resolve, reject) => {     
    }), new Promise((resolve, reject) => { 
    })])

1. 只有所有的Promise对象的状态为resolved时，才会返回一个resolved状态的Promise，同时值为方法中所有的promise的返回值包装的数组

Promise.all([new Promise((resolve, reject) => { 
        resolve()    
    }), new Promise((resolve, reject) => {   
        resolve()   
    }), new Promise((resolve, reject) => { 
        resolve() 
    })])

2.只要方法中有一个Promise被rejected,Promise.all()将返回一个状态为rejected，值为第一个被rejected的Promise对象的值

Promise.all([new Promise((resolve, reject) => { 
        resolve()    
    }), new Promise((resolve, reject) => {   
        reject("第一个被rejected的值")   
    }), new Promise((resolve, reject) => { 
        reject("第二个被rejected的值") 
    })])

3 参数中的Promise对象定义了catch方法，被rejected后会触发自生catch(),不会触发Promise.all()的catch()

Promise.all([new Promise((resolve, reject) => { 
        resolve()    
    }), new Promise((resolve, reject) => {   
        reject("被rejected")   
    }).catch(info=>{
        console.log("Promise的catch")
    }), new Promise((resolve, reject) => { 
        resolve() 
    })]).catch(info=>{
        console.log("promise.all()的catch")
    })

4参数中的Promise对象没有定义了catch方法，被rejected后会触发Promise.all()的catch()

Promise.all([new Promise((resolve, reject) => { 
        resolve()    
    }), new Promise((resolve, reject) => {   
        reject("被rejected")   
    }), new Promise((resolve, reject) => { 
        resolve() 
    })]).catch(info=>{
        console.log("promise.all()的catch")
    })

Promise.race()

Promise.all()用于将多个Promise实例包装成一个Promise,最先改变状态Promise实例对象的决定Promise.all()返回的实例

Promise.all([new Promise((resolve, reject) => { 
       setTimeout(()=>{resolve("promise1")},1000)     
    }), new Promise((resolve, reject) => {   
        setTimeout(()=>{resolve("promise2")},5000) 
    }), new Promise((resolve, reject) => { 
        setTimeout(()=>{resolve("promise3")},500) 
    })])