JavaScript的promise详解

promise是什么？

抽象解释：是js中进行异步编程的新的解决方案。
（旧的是纯回调的形式，会进入回调地狱）

要点：
1、语法上，promise是一个构造函数；功能上，promise对象用来封装一个异步操作并获取执行的结果。
2、它有三种状态，pending（打包中，创建promise对象后的状态） resolved（成功） rejected（失败）。
3、一个promise对象只能改变一次状态，成功或者失败后都会返回结果数据。
4、成功的结果数据一般称为value，失败的结果数据为reason

基本的流程图：

为什么要用promise？

如何使用promise？

      //1.创建一个新的promise对象
      //一个promise对应一个异步任务
        const p=new Promise((reseolve,reject)=>{//执行器函数
        //2.执行异步操作任务 
        setTimeout(()=>{
            const time=Date.now();
            if(time%2==0){
                reseolve('成功的数据,time='+time);// 成功调用resolve（value）
            }else{
                reject('失败的数据,time='+time);// 失败调用reject（reson）
            }
        },1000)
        })
        p.then(
        value=>{  //接受成功的value数据 onresolved
            console.log('成功的回调',value);
        },
        reason=>{//接受失败的reason数据 onrejected
            console.log('失败的回调',reason);
        }
        )

注意：
1.执行器在promise内部是立即同步回调，异步的操作是在执行器中执行的
2.Promise.prototype.then方法：指定用于得到成功value的成功回调和用于失败reason的失败回调。返回一个新的promise对象（promise链式调用的前提）

例：产生promise对象的几种方式

     const p1=new Promise((resolve,reject)=>{
                resolve(1);
            })
            const p2= Promise.resolve(2);//语法糖，简洁方法
            const p3= Promise.reject(3);

            //处理方式
            p1.then(value=>{console.log(value);})
            p2.then(value=>{console.log(value);})
            // p3.then(null,reson=>{console.log(reson);})
            p3.catch(reson=>{console.log(reason);})  //或者这种方式

Promise.all方法

   const pAll=Promise.all([p1,p2,p3]);
            pAll.then(
                values=>{
                    console.log('all onResolved',values);//都成功时调用，返回的是数组，顺序和传入的参数顺序有关
                },
                reason=>{
                    console.log('all onReject',reason);//有一个失败时就调用
                }
            )

Promise.race方法

//哪个结果获得的快，就返回那个结果，不管结果本身是成功状态还是失败状态。(取第一名)
   const pRace=Promise.race([p1,p2,p3]);
            pRace.then(
                value=>{
                    console.log('race onResolved',value);
                },
                reason=>{
                    console.log('race onReject',reason);
                }
            )

优点

1. 指定回调函数的方式更灵活：

旧的方式：必须在启动异步任务之前指定;

promise方式：启动异步任务=>返回promise对象=>给promise对象绑定回调函数(可以在返回了结果之后指定回调函数)
2. 可以解决回调地狱的问题（回调函数嵌套调用，就是外部回调函数异步执行的结果是嵌套的回调函数执行的条件。缺点：不便于阅读和异常处理）。解决方案是promise链式调用。

  //非嵌套关系
        //使用promise的链式调用解决回调地狱（伪代码）
        doSomething().then(function(result){
            return doSomethingElse(result)
        })
        .then(function(newResult){
            return doThirdThing(newResult)
        })
        .then(function(finalResult){
            console.log('最终结果:'+finalResult);
        })
        .catch(failureCallback) //异常传透 （统一的处理异常）

终极解决方案是async/await

          //async/await:回调地狱的终极解决方案(伪代码)
          async function request(){
              try{
                  let result=await doSomething();
                  let newResult=await doSomethingElse(result);
                  let finalResult=await doThirdThing(newResult);
                  console.log('最终结果:'+finalResult);
              }catch(error){
                failureCallback(error);
              }
          }

promise链式调用和async对比：前者虽然没有了嵌套，但是还是有回调函数的存在，后者则没有，是最优选择。