Promise(解决回调地狱)

Promise() 对象：
存在三种状态：

  //进行时 pending
  // 成功 resolve
   //失败 reject

执行语句：

     let promise=  new Promise((resolve, reject) => {
       //条件成立执行resolve()
            if(true){
             	resolve()
             }else{
              //条件不成立执行resolve()
             	reject()
             }
        })
        promise.then(res=>{
        //res是promise条件成立返回的结果
        }).catch(err=>{
        //err是promise条件不成立返回的结果
        })
        //========================================
         function fn1() {
            return new Promise((resolve, reject) => {
                if (Math.random() > 0.5) {
                    resolve('===返回值大于0.5')
                } else {
                    reject('返回值小于0.5===')
                }
            })
        }
          let f = fn1().then(res => {
            console.log(res);

        }).catch(res => {
            console.log(res);

        })

状态的改变 只能从 pending 转换为 resolve; 或者 从pending 转换为 reject； 如果处于pending状态，永远不知道下一步转换为什么状态

Promise() 接受一个函数作为参数； 函数存在两个参数（这两个参数是js原生提供的） 一个是resolve， 一个是reject

Promise()的执行机制：
如果Promise()执行成功，则会调用执行 resolve()； resolve()中的参数就是执行成功的结果，通过then() 进行接受， then() 参数是一个函数，函数的参数就是 resolve传递传递出来的数据

如果Promise()执行失败， 则会调用执行 reject(); reject()中的参数就是执行失败的错误信息， 通过 catch()进行接受， catch的参数一个函数。 函数的参数 err 就是reject 传递出来的错误信息

官网的解说：
resolve函数的作用是，将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；reject函数的作用是，将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。

Promise()基本结构：
有了Promise对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数； 因为这样， 可以通过Promise() 解决回调地狱的问题
js 的异常捕获

try{
   // 代码测试
}catch{
   // 异常捕获 
}finally{
   // finally 使用较少
  // 无论代码是否出错，此处的代码始终执行 
}

 try{
     // 代码测试
 }catch(err){
     // 异常捕获 
 }finally{
    // 无论代码是否出错，此处的代码始终执行 
 }

js的错误类型：
1.SyntaxError（语法错误） ***
2.ReferenceError（引用错误） ***
3.RangeError（范围错误）
4.TypeError（类型错误） ***
5.URLError（URL错误）
6.EvalError（eval错误）
7. Error(错误)
10个ajax请求 全部执行结束 然后在去做下一件事情 ； 如何判断10个请求都执行完成结束了呢？
Promise.all() 方法可以解决这个问题：
接受的参数是一个数组， 数组中的每个值是promise 实例对象， all()的状态是由参数的状态的决定 ； 所有的promise对象都成功则成功,则会返回一个数组，将成功的数据存放在数组之中，有一个失败则失败，则会返回第一个失败的信息，且 Promise.all() 也会是失败的状态

Promise.all()方法用于将多个 Promise 实例，包装成一个新的 Promise 实例。（返回的结果是一个Promise()对象）

function fn1() {
            return new Promise((resolve, reject) => {
                if (Math.random() > 0.5) {
                    resolve('===11返回值大于0.5')
                } else {
                    reject('11返回值小于0.5===')
                }
            })
        }

        function fn2() {
            return new Promise((resolve, reject) => {
                if (Math.random() > 0.5) {
                    resolve('===22返回值大于0.5')
                } else {
                    reject('22返回值小于0.5====')
                }
            })
        }
           let pa = Promise.all([fn1(), fn2()]).then(res => {
            console.log(1);

            console.log(res);

        }).catch(res => {
            console.log(2);

            console.log(res);

        });

全成功

参数中的promise实例对象中有失败的，则 Promise.all()就是失败的返回第一个失败的返回结果

Promise.race() 方法 的参数是一个数组， 数组中的每个值是 Promise() 实例对象； 最后返回一个新的Promise() 对象
状态 改变： fun1(), fun2(), fun3() 三个实例对象 谁的状态先改变（不管成功还是失败），则p的状态都会随之跟随改变 如果fun1(), fun2(), fun3() 三个实例对象 先改变的状态是成功，则成功，如果失败则失败