关于javascript: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) 
    })])