Promise由浅入深

Promise是什么？

　　1、Promise是ES6提供的进行异步编程的解决方案

　　2、Promise是一个构造函数，用来封装一个异步操作，可以获取其成功或失败的值

　　异步编程旧的操作都是回调函数的方式：（不利于阅读和异常处理）

　　　　1）fs 文件操作

      require('fs').readFile('./index.js', (err, data) => { })

　　　　2）ajax

      $.get('url', (data) => { })

 　　　　3）定时器

      setTimeout(() => { }, 1000);

读取文件时采用回调的方式和promise的区别：

  const util = require('util')
  const fs = require('fs')

  // 1、回调函数的写法
  fs.readFile('./resources/为学.md', (err, data) => {
    if (err) throw err
    console.log(data + '')
  })

  let readFile = util.promisify(fs.readFile) // 将回调函数风格的方法转为promise

  // 2、promise写法
  readFile('./resources/为学.md').then((data) => {
    console.log(data + '')
  })

  // 3、promise封装读取文件的方法
  function getFile(path) {
    return new Promise((resolve, reject) => {
      require('fs').readFile(path, (err, data) => {
        if (err) reject(err)
        resolve(data)
      })
    })
  }

  getFile('./resources/为学.md')
    .then((data) => {
      console.log(data + '')
    })
    .catch((err) => {
      console.log(err)
    })

promise的状态：

　　它的状态是实例对象中的 PromiseState 属性的值，共有3个：

　　　　pending　　　　　　未决定的

　　　　resolved/fulfilled　　成功

　　　　rejected　　　　　　失败

　　它的状态变化只有两种可能，一是由pending变为resolved，一是由pending变为rejected，并且一个promise对象的状态只能改变一次，不可能由成功变为失败或由失败变为成功

　　如何改变promise对象的状态：

　　　　1、调用reslove()，将promise的状态由pending变为resolved

　　　　2、调用reject()，将promise的状态由pending变为rejected

　　　　3、执行throw语句，可以写成throw new Error('出错啦')也可以写成throw ‘出错啦’，将promise的状态由pending变为rejected

　　promise对象的值：

　　它的值是实例对象中的 PromiseResult 属性，保存了promise对象成功/失败的结果，没有执行成功或者失败该属性值为undefined

　　　　PromiseResult只能由resolve()和reject()改变，保存它们传来的值，在实例对象中用then()接收resolve()的值，用catch()接收reject()的值，或者是用then()方法中两个回调函数，第一个接收resolve()的值，第二个接收reject()的值

API：

　　Promise(excutor){}

　　执行器函数（excutor函数）：(resolve,reject)=>{}

　　　　resolve函数：内部定义成功时调用的函数 value=>{}

　　　　reject函数：内部定义失败时调用的函数 err=>{}

　　注意：执行器函数会在Promise内部立即同步调用，异步操作在执行器中执行

　　then()方法

　　　　(onResolved,onRejected)=>{}

　　　　onResolved函数：成功的函数 (value)=>{}

　　　　onRejected函数：失败的函数 (err)=>{}

　　catch()方法

　　　　(onRejected)=>{}

　　　　onRejected函数：失败的函数 (err)=>{}

构造函数的方法：

　　Promise.resolve()

    /*
      如果传入的参数为非promise类型的对象，则返回的结果为成功的promise对象
      如果传入的参数为promise类型的对象，则返回的结果决定了resolve的结果
    */
    let p = Promise.resolve(111)
    console.log(p)

    let p1 = Promise.resolve(new Promise((resolve, reject) => {
      reject('错误')
    }))
    p1.catch(err => {
      console.error(err)
    })

　　Promise.reject()

    // 不管传入的是什么，都会返回失败的结果
    let p = Promise.reject(123)
    p.catch(err => { console.log(err) })
    console.log(p)
    // 即使传入的是一个成功的promise对象，返回的也依然是失败的结果，这个结果是成功的promise
    let p1 = Promise.reject(new Promise((resolve, reject) => {
      resolve(456)
    }))
    p1.catch(err => { console.log(err) })
    console.log(p1)

　　Promise.all()

    /*
      如果数组中的promise对象都是成功的状态，那么返回的状态也是成功的，返回的结果是这三个参数组成的数组
      如果数组中的promise对象有一个是失败的状态，那么返回的状态就是失败的，返回的结果是第一个失败的promise的结果
    */
    let p = new Promise((resolve, reject) => {
      resolve('成功')
    })
    let p1 = Promise.resolve('ok')
    let p2 = Promise.resolve('OK!')

    const result = Promise.all([p, p1, p2])
    console.log(result) // PromiseState 的值为 fulfilled    PromiseResult 的值为 ['成功', 'ok', 'OK!']

　　Promise.race()

    // race是赛跑的意思，返回的promise对象的状态和结果为数组中第一个执行完的promise的状态和结果
    let p = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve('成功')
      })
    })
    let p1 = Promise.reject('err')
    let p2 = Promise.resolve('OK!')

    let result = Promise.race([p, p1, p2])
    console.log(result) // 返回p1的状态和结果

Promise的几个问题：

　　1、只要promise的状态发生改变，即执行了resolve()或reject()或throw ''，它指定的多个成功/失败回调函数都会调用

    let p = new Promise((resolve, reject) => {
      // resolve('成功')
      // reject('错误')
      throw '错误'
    })

    p.catch(err => {
      console.log(err)
    })
    p.catch(err => {
      console.log(err)
    })

　　2、改变promise状态和指定回调函数谁先执行？正常情况下promise中都是异步任务，先执行then()方法再改变promise状态

    // 如果promise中是同步任务，那么再改变promise状态再指定回调函数（执行then()方法）；如果promise中是异步任务，那么先指定回调函数（先执行then()方法）再改变promise状态，这种情况居多
    let p = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve('成功')
      }, 100)
    })
    p.then(data => {
      console.log(data) // 此时是先指定回调函数再改变promise状态
    }, err => { console.log(err) })

　　3、如何先改变promise状态再指定回调函数

　　　　1）在执行器中直接调用 resolve()/reject()----同步任务

　　　　2）延迟更长的时间才调用 then()

　　4、什么时候能得到数据

　　　　1）如果先指定回调，那么当状态发生改变时回调函数就会调用，得到数据----异步任务

　　　　2）如果先改变状态，那么当指定回调时回调函数就会调用，得到数据----同步任务

x