promise

promise实例

promise是js用来将异步的代码，转为同步执行的一种方法，直译的意思是承诺，它的参数是一个函数，它有三种状态、padding执行中，resolve已完成，reject失败，并且padding的状态转为了成功或者失败后，都不可逆。默认情况下，实例内是padding状态，函数的两个参数是resolve和reject。

new Promise((resolve,reject)=>{
    // ...
    resolve() // 成功
})

then()

then()方法接收两个函数作为参数，第一函数是当promise实例调用resolve()时执行，第二个函数是当实例调用reject()时或者实例内报错时执行。两个函数都只接收一个返回值，就是实例内调用resolve()或reject()传过来的。

new Promise((resolve,reject)=>{
    console.log(1)
    resolve(2)
}).then((resolveData)=>{
    console.log(resolveData)
})
// 打印1，2

new Promise((resolve,reject)=>{
    console.log(1)
    reject(2)
}).then((resolveData)=>{
    console.log('resolveData-'+resolveData)
},(rejectData)=>{
    console.log('rejectData'+rejectData)
})
// 打印1，rejectData-2

new Promise((resolve,reject)=>{
    console.log(1)
    throw new Error('2')
}).then((resolveData)=>{
    console.log(resolveData)
},(rejectData)=>{
    console.log('rejectData-'+rejectData)
})
// 打印1，rejectData-2

catch()

catch()方法接受一个函数作为参数，当promise实例报错，切then()方法只接收一个参数时，catch里的回调会执行，当then方法里面两个回调函数里的任意一个函数里面报错，也会执行，接收错误作为参数

new Promise(()=>{
    console.log('1')
    throw new Error("2")
}).then(()=>{})
.catch((error)=>{
    console.log('catch-'+error)
})
// 打印1，catch-Error: 2

new Promise((resolve)=>{
    console.log(1)
    resolve('3')
}).then((resolveData)=>{
    console.log(2)
    throw new Error(resolveData)
}).catch((error)=>{
    console.log(error)
})
// 打印1,2,Error: 3

new Promise((resolve,reject)=>{
    console.log(1)
    reject('3')
}).then(
()=>{},
(resolveData)=>{
    console.log(2)
    throw new Error(resolveData)
}).catch((error)=>{
    console.log(error)
})
// 打印1,2,Error: 3

finally()

直译的意思是最后，这个方法无论promise实例或者方法返回什么，都会执行，报错了也会执行，且没有返回值

new promise((resolve)=>{
    console.log(1)
    resolve()
}).finally(()=>{
    console.log(2)
})
// 打印1,2

new Promise((resolve, reject) => {
    throw new Error('报错了')
}).finally(() => {
    console.log(2)
})
// 打印2，Error：报错了

all()

all方法处理多个promise，它接受一个数组参数，里面每一项是一个promise实例，后面接其他promise实例方法，当每个实例都返回resolve时，它才执行成功逻辑，并返回实例传过来的值的集合，当其中有一个实例返回reject时，它都执行失败逻辑，并返回失败的值

Promise.all([new Promise((resolve) => {
    resolve(1)
}), new Promise((resolve) => {
    resolve(2)
})]).then((resolveData) => {
    console.log('then-resolveData' + JSON.stringify(resolveData))
}, (rejectData) => {})
// 打印then-resolveData[1,2]

Promise.all(
    [new Promise((resolve, reject) => {
        resolve(1)
    }),
    new Promise((resolve, reject) => {
        reject(2)
    })]
).then(
    (resolveData) => {
    },
    (err) => {
        console.log('err:' + JSON.stringify(err))
    })
// 打印err:2

race()

race方法也是接受一个数组，数组里面每一项都是promise实例，但和all方法刚好相反，当一个实例中返回resolve时，就会执行成功逻辑。只有当全部都reject时才会执行失败逻辑

Promise.race([
    new Promise((resolve, reject) => {
        resolve(1)
    }),
    new Promise((resolve, reject) => {
        resolve(2)
    })
]).then((resolveData) => {
    console.log(resolveData)
},
    (rejectData) => {
        console.log(rejectData)
    })
// 打印1

Promise.race([
    new Promise((resolve, reject) => {
        reject(1)
    }),
    new Promise((resolve, reject) => {
        reject(2)
    })
]).then((resolveData) => {
    console.log('resolveData:' + resolveData)
},
    (rejectData) => {
        console.log('rejectData:' + rejectData)
    })
// 打印1