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