Promise知识点

最新推荐文章于 2023-04-15 16:47:52 发布

不像话i

最新推荐文章于 2023-04-15 16:47:52 发布

阅读量323

点赞数

文章标签： javascript 开发语言 ecmascript es6

本文链接：https://blog.csdn.net/XiaoXiao2223/article/details/121052548

版权

1.简介

ES6将某一件事情可以发生异步的时候，分为2ge阶段unsettled未决阶段和settled已决阶段事情总是从未决阶段逐步发展到已决阶段，并且未决阶段有控制通往已决阶段的能力，可以决定事情最终走向的状态

ES6将程序分为3中状态：pending resolved rejected

pending状态：挂起（等待）处于未决阶段，表示事情还在挂起最终的结果还没有出现

resolved状态：已处理处于已决阶段，表示整个事情已经出现了结果，并且可以按照正常的逻辑进行下去的结果

rejected状态：已拒绝处于已决阶段，表示整个事情已经出现了结果，并且无法按照正常的逻辑进行下去的结果

把事情从pending状态推向resolved状态的过程中可能会传递一些数据，这些数据一般为真实有效数据

把事情从pending状态推向rejected状态的过程中可能会传递一些数据，这些数据一般为错误信息

当事情已经到达已决阶段后，通常要进行后续处理，不同的已决阶段，决定了不同的后续处理

resolved 这是一个正常的已决状态，后续处理表示为thenable

rejected 这是一个非正常的已决状态，后续处理表示为catchable

后续处理可能会有多个，因此就会形成任务队列，这些后续处理会按照顺序，当到达对应的状态依次执行

2.注意点:

未决阶段的处理函数是同步的，会立即执行
thenable和catchable是异步函数，就算会立即执行，也会加入至任务队列中的微队列中
then方法有两个参数分别为thenable和catchable,cathch只可以单独添加catchable函数
在未决阶段的处理函数中，如果发生未捕获的错误，会将状态推向rejected状态，并且会被catchable捕获
一旦状态推向已决阶段，无法在做任何改变
如果前面的promise的后续处理，返回的是一个promise，则返回的promise状态和后续处理返回的promise状态保持一致

3. promise的方法

3.1 实例方法

then(thenable,catchable)
catch(catchable)
finally() ES2018 ,没有参数，当promise为已决时运行该函数作用： 1. 测试promise 2. 对于异步操作完成以后不论结果的后续处理

3.2 原型方法

Promise是一个构造函数，自己身上有all、reject、resolve这几个眼熟的方法，原型上有then、catch等同样很眼熟的方法。

Promise的构造函数接收一个参数：函数，并且这个函数需要传入两个参数：

resolve ：异步操作执行成功后的回调函数
reject：异步操作执行失败后的回调函数

        const pro = new Promise((resolve,reject)=>{
            resolve(1)
            // reject(2)
        })
        pro.finally(()=>{
            console.log("promise已进入已决阶段")
        })

resolve()

reject()方法

        const pro = Promise.resolve(1)
        =>
        const pro = new Promise(resolve => {
            resolve(1)
        })
        console.log(pro)
        pro.then(result => {
            console.log(result)
        })

        const pro = Promise.reject(1)
        =>
        const pro = new Promise((resolve,reject) => {
            reject(1)
        })

        const pro = new Promise((resolve,reject)=>{
            resolve(123)
        })
        const pro2 = Promise.resolve(pro) 
        const pro2 = new Promise(resolve=>{
            resolve(pro)
        })
        console.log(pro,pro2)
        console.log(pro === pro2)

all(arr) 这个方法会返回一个promise对象（A）,如果arr数组中的所有promise对象状态全为resolve则A对象状态为resolve，如果有一个为reject状态则A对象为reject状态

        const proms = [];
        for(let i = 0 ; i < 10 ; i++){
           proms.push( new Promise((resolve,reject)=>{
            //    resolve(i)
            setTimeout(()=>{
                if(Math.random() < 0.9){
                    resolve(i)
                }else{
                    reject(i)
                }
            })
           }) )
        }
        console.log(proms)
        const pro = Promise.all(proms)
        pro.then(result => {
            console.log(result)
        },err=>{
            console.log(err)
        })

race(arr) 这个方法会返回一个promise对象（A）,如果arr数组中的有yi一个promise对象的结果先出现，则A对象会以先出现的状态为状态

        function getRandom(min,max){
            return Math.floor(Math.random() * (max -min ) + min)
        }
         const proms = [];
        for(let i = 0 ; i < 10 ; i++){
           proms.push( new Promise((resolve,reject)=>{
                setTimeout(()=>{
                    if(Math.random() < 0.5){
                        console.log(i,"完成")
                        resolve(i)
                    }else{
                        console.log(i,"失败")
                        reject(i)
                    }
                },getRandom(1000,5000))
           })
            )
        }
        const pro = Promise.race(proms)
        console.log(proms)
        pro.then(result => {
            console.log(result)
        },err=>{
            console.log(err)
        })