Promise知识点

1.简介

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

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

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

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

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

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

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

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

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

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

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

2.注意点:

1. 未决阶段的处理函数是同步的，会立即执行

2. thenable和catchable是异步函数，就算会立即执行，也会加入至任务队列中的微队列中

3. then方法有两个参数分别为thenable和catchable,cathch只可以单独添加catchable函数

4. 在未决阶段的处理函数中，如果发生未捕获的错误，会将状态推向rejected状态，并且会被catchable捕获

5. 一旦状态推向已决阶段，无法在做任何改变

6. 如果前面的promise的后续处理，返回的是一个promise，则返回的promise状态和后续处理返回的promise状态保持一致

3. promise的方法

3.1 实例方法

1. then(thenable,catchable)

2. catch(catchable)

3. 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已进入已决阶段")
        })

1. resolve()

2. 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)
   

3. 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)
           })

4. 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)
           })