promise的意义和用法

promise

promise 是一个 ES6 的语法，承诺的意思，是一个专门用来解决异步 回调地狱 的问题

回调地狱
当一个回调函数嵌套一个回调函数的时候就会出现一个嵌套结构，当嵌套的多了就会出现回调地狱的情况

比如我们发送三个 ajax 请求

• 第一个正常发送
• 第二个请求需要第一个请求的结果中的某一个值作为参数
• 第三个请求需要第二个请求的结果中的某一个值作为参数

ajax({
  url: '我是第一个请求',
  success (res) {
    // 现在发送第二个请求
    ajax({
      url: '我是第二个请求'，
      data: res,
      success (res2) {
        // 进行第三个请求
        ajax({
          url: '我是第三个请求',
          data: res2,
  		  success (res3) { 
            console.log(res3) 
          }
        })
      }
    })
  }
}

当嵌套越来越多的时候就可能会像下图一样

当代码成为这个结构以后，已经没有维护的可能了，所以我们要把代码写的更加的艺术一些

就需要用到promise

Promise 是ES6对异步编程的一种解决方案，比传统的解决方案（回调函数和事件）更合理更强大。
Promise 简单说就是一个容器，里面保存着一个尚未完成且预计在未来完成的异步操作。
Promise 是一个构造函数，用来创建一个Promise对象。
Promise对象代表一个异步操作，有三种状态：

• pending（进行中）
• fulfilled（成功）
• rejected（失败）

Promise 对象的状态改变有两种：

• 从 pending 变为 fulfilled
• 从 pending 变为 rejected

一旦状态改变，就不会再变，任何时候都可以得到这个结果。
有了Promise对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。

var p = new Promise(function(resolve, reject) {
  // do something ...
  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。
resolve 和 reject 是两个函数，由 JavaScript 引擎提供，不用自己部署。

resolve 函数的作用是，将Promise对象的状态从“进行中”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去。

reject 函数的作用是，将Promise对象的状态从“进行中”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。

p.then(function(value) {
  // success
}, function(error) {
  // failure  可选
});

Promise实例的then方法：
第一个参数是resolved状态的回调函数
第二个参数（可选）是rejected状态的回调函数
方法返回的是一个新的Promise实例

 function fn1(){
        return new Promise(function(resolve,reject){
            setTimeout(function(){
                resolve('成功')
            },2000)
        })        
    }    
    fn1()
    .then(function(res){
        console.log(res)
          return fn1()
    })
    .then(function(res2){
        console.log(res2)
    })

Promise实例的catch方法：
用于指定发生错误时的回调函数，可以捕获then里面的错误。

var p1 = new Promise(function(resolve, reject) {
        resolve('成功')
      })
      p1.then(
        function(res) {
          console.log(res)//成功
          alertt(123)
        },
        function(err) {
          console.log(err)
        }
      ).catch(function(e) {
        console.log(e)//ReferenceError: alertt is not defined at demo04.html:26
    
      })

throw new Error(‘出错啦’);

function fn1() {
        return new Promise(function(resolve, reject) {
          throw new Error('出错了')
        })
      }
      fn1()
        .then(
          function(res) {
            console.log(11)//不执行
            return fn1()
          },
          function(err) {
            console.log(err)//提示出错了
          }
        )
        .then(
          function(res2) {
            console.log(22)//22
          },
          function(err2) {
            console.log(err2)//不执行
          }
        )

Promise.all 可以将多个Promise实例包装成一个新的Promise实例。
1.它接受一个数组作为参数。
2.数组可以是Promise对象，也可以是其它值，只有Promise会等待状态改变。
3.当所有的子Promise都完成，该Promise完成，返回值是全部值的数组。
4.如果有任何一个失败，该Promise失败，返回值是第一个失败的子Promise的结果。

5.如果promise对象有多个时，那么按照书写顺序从左往右执行

var p1=new Promise(function(resolve,reject){
    resolve(111)
})    
var p2=new Promise(function(resolve,reject){
    // alertt('hello')
    resolve(222)
}) 
var p3=new Promise(function(resolve,reject){
    resolve(333)
}) 
Promise.all([p2,p1,p3]).then(function (arr){
    console.log(arr);//222，111，333
},function (error){
    console.log(error);//alertt is not defined
});

----逆战班