其他分享
首页 > 其他分享> > 斗胆谈谈Promise

斗胆谈谈Promise

作者:互联网

1.Promise概念

1.1为什么需要promise?

promise是ES6异步编程新的解决方案,它可以用来解决回调地狱的问题,回调地狱就是许多回调函数嵌套,导致代码太乱了,不易读,也不太好看。如下代码(读文件是异步操作,需要回调函数不停嵌套,透露出一股恶心劲)

fs.readFile('./1.html',(err,data)=>{
    if(err) throw err;
    fs.readFile('./2.html',(err,data1)=>{
        if(err) throw err;
        fs.readFile('./3.html',(err,data2)=>{
            if(err) throw err;
            fs.readFile('./4.html',)
        })
    })

})

1.2promise是什么?

promise其实就是一个构造函数,它里面包含一些属性和方法,支持链式调用。

promise其中一个属性PromiseState代表它的状态,它只有三种状态:

fulfilled/resolved(成功)

rejected (失败)

pending (进行中,最初的状态)

其中只会有两种情况的状态变化:

pending -> fulfilled/resolved

pending->rejected

就是只能从初始变为成功,或者从初始变为失败,成功和失败之间不能再互相转化了。

下面我们通过具体的使用来了解。

2.Promise使用

2.1创建promise

上代码(最简单的promise使用,定义一个成功的promise)

let p = new Promise((resolve,reject)=>{
            resolve('ok')
        })
console.log(p);

输出P是一个promise实例,它的状态是成功的,PromiseResult是promise的另一个属性,代表promise的值。

定义一个失败的promise

let p = new Promise((resolve,reject)=>{
            reject('fail')
        })
 console.log(p);

 输出结果是P是一个promise但他的状态是rejected失败的,promise的值就是传入的值

 2.2promise的方法

then():

then方法的参数可以传入两个回调函数,当promise状态变为成功( fulfilled)时,执行第一个参数接受的回调函数,状态变为失败(rejected)执行第二个参数接收的回调函数,注意then方法返回的仍然是一个promise对象,所以在then方法之后可以继续调用then方法

上代码

let p = new Promise((resolve,reject)=>{
            reject('fail')
        })
        p.then((value)=>{
            console.log('成功',value);
        },(reason)=>{
            console.log('失败',reason);

        })

当一个rejected状态的promise调用.then时执行的是第二个参数的回调函数,所以输出失败,值就是通过reject()传入的值

 let p = new Promise((resolve,reject)=>{
            resolve('ok')
           
        })
        p.then((value)=>{
            console.log('成功',value);
        },(reason)=>{
            console.log('失败',reason);

        })
        

 同理,当一个resolve状态的promise调用.then时,执行的是第一个参数的回调函数,输出成功,value值就是通过resolve()传入的值

 那我们说then返回的也是一个promise对象,若then里面的回调函数返回的是非promise的数值那么then返回的就是resolved/fulfilled状态的promise,

如果then里面的回调函数返回的是promise类型,则回调函数返回的promise的成功与否直接决定了then方法返回的promise的结果和状态(有些绕,看代码就清楚了)

上代码(回调函数返回非promise)

let p = new Promise((resolve,reject)=>{
            resolve('ok')
           
        })
        const res = p.then((value)=>{
            console.log('成功',value);
        },(reason)=>{
            console.log('失败',reason);})
            
        console.log(res);
p是resolved状态的,那么执行then里面的第一个回调函数,打印成功,回调函数并没有返回一个新的promise,因此p.then返回的就是一个状态为fulfilled的promise,值为undifined,因为没有新的promise对象。

 回调函数返回promise

 let p = new Promise((resolve,reject)=>{
            resolve('ok')
           
        })
        const res = p.then((value)=>{
            return new Promise((resolve,reject)=>{
                resolve('new Promise')

            })  
        },(reason)=>{
            console.log('失败',reason);})

        console.log(res);

因为成功的回调函数返回了一个新的promise,他决定了then返回的promise的状态和值也是成功的,值就是传入的新值

let p = new Promise((resolve,reject)=>{
            resolve('ok')
           
        })
        const res = p.then((value)=>{
            return new Promise((resolve,reject)=>{
                reject('fail Promise')

            })  
        },(reason)=>{
            console.log('失败',reason);})

        console.log(res);

 

若回调函数返回的是失败的promise,则then返回的也是失败的promise,值就是传入的值

catch()

promise还有一个特点是可以进行异常穿透,就是已经失败了,就不要总是定义失败(reject)的回调函数了,只要在最后指定一个失败的回调catch()就好了,捕获失败结果,返回值就第一个失败的值,这样代码就更清晰了。

 let p1 = new Promise((resolve,reject)=>{
            reject('fail')
           
        })
        p1.then((value)=>{
            console.log('成功',value);

        }).catch(e=>
            {
            console.log('失败',e);
        })

失败的promis执行catch(),then方法里面不用再写失败的回调了

 如果.then后面还有.then,许许多多.then也不怕,catch仍然能抓到第一个失败的值

 let p1 = new Promise((resolve,reject)=>{
            resolve('ok')
           
        })
        p1.then(value=>{
            console.log('111');
            

        }).then(value=>{
            console.log('222');
            throw('ERROR')
        }).then(value=>{
            console.log('333');
            
        }).catch(reason=>{
            console.log('失败',reason)
        })

成功的promise会继续执行.then方法,直到catch捕获到了第一个失败,就不再继续执行了,不会输出33333

 all()

promise.all传入的是一个promise类型的数组,它的返回值也是一个promise,他的状态由数组决定,若promise数组里均为resolved状态的,那么promise.all返回的就是resolved状态的,值就是由所有传入值组成的数组,若promise数组中有一个失败了,那么promise.all返回的就是reject状态的,值就是失败的传入的值

上代码(promise全为成功状态)

let p1 = new Promise((resolve,reject)=>{
            resolve('ok')
           
        })
        let p2 = new Promise((resolve,reject)=>{
            resolve('success')
           
        })
        let p3 = new Promise((resolve,reject)=>{
            resolve('nice')
           
        })
        const res = Promise.all([p1,p2,p3])

        console.log(res);

有一个为失败状态

  let p1 = new Promise((resolve,reject)=>{
            resolve('ok')
           
        })
        let p2 = new Promise((resolve,reject)=>{
            reject('fail')
           
        })
        let p3 = new Promise((resolve,reject)=>{
            resolve('nice')
           
        })
        const res = Promise.all([p1,p2,p3])

        console.log(res);

 race()

promise.all传入的也是一个primise数组,返回值是一个promise,只是它的状态和值是由最先发生变化的promise状态和值决定的,就像赛跑先到先得

        let p1 = new Promise((resolve,reject)=>{
            resolve('ok')
           
        })
        let p2 = new Promise((resolve,reject)=>{
            reject('fail')
           
        })
        let p3 = new Promise((resolve,reject)=>{
            resolve('nice')
           
        })
        const res = Promise.race([p1,p2,p3])

        console.log(res);

 P1先到,是成功的,值是ok,则all方法返回的promise是成功的值为ok

若P1变为异步了,则p2先到那么结果一定会是一个返回失败的promise

        let p1 = new Promise((resolve,reject)=>{
            setTimeout(()=>{
                resolve('ok')
            })
        })
        let p2 = new Promise((resolve,reject)=>{
            reject('fail')
           
        })
        let p3 = new Promise((resolve,reject)=>{
            resolve('nice')
           
        })
        const res = Promise.race([p1,p2,p3])

        console.log(res);

4.async await

async是一个函数,返回结果是一个promise对象

1.如果函数里面return的不是一个promise,那promise的结果就是成功的,值就是return的数值

2.如果函数里面return的是一个promise,那async的Promise就是return的promise

3.抛出异常,返回的就是失败的promise对象

(这个很像对于then方法那个表述)

await右边表达式一般为promise对象

1.右边是promise对象,await返回值是promise成功值

2.右边是其他值,直接将此值作为await的返回值(很少用)

注意二者常常结合使用简化promise操作

await必须写在async里面,但是async可以没有await

上代码

        async function main(){
            let p = new Promise((resolve,reject)=>{
                resolve('ok')
                // reject('error')
            })
            try{
                let res = await p;
                console.log(res);
            }catch(e){
                console.log(e);
            }
            
        }
        main()

await返回的是promise的成功值,所以需要用try catch捕获失败的情况,输出ok,以后就可以用这样的方法简化promise操作,只需要awaitpromise成功的值即可

标签:斗胆,resolve,console,new,谈谈,Promise,reject,promise
来源: https://blog.csdn.net/weixin_43946748/article/details/121568393