Promise、async、await 关键字

Promise：

　　异步调用工具类，其作用是简化异步调用。每个 Promise 对象，有 pending、fulfilled、rejected 三种状态。Promise

　　构造函数，提供 resolve 和 reject 两个函数来修改Promise 对象的状态，resolve 可以将状态改为 fulfilled，而 reject

       可以将状态改为 rejected。

<script>
      var data = ['001', '小明', '数学']
      var score = 90

      function afterResolve(data) {
        console.log('通过 ' + data[1])
      }
      function afterReject(info) {
        console.log('不通过 ' + info.toString())
      }

      var pms1 = new Promise((resolve, reject) => {
        if (score >= 60) {
          resolve(data)
        } else if (0 <= score && score < 60) {
          reject(new Date())
        } else {
          throw 'score exception'
        }
      })
        .then(afterResolve)
        .catch(afterReject)

      console.log('我可能在 afterResolve 和 afterReject 前执行')
    </script>

　　如上，要么 resolve 将状态改为 fulfilled 后，会自动执行 afterResolve，要么 reject 将状态改为 rejected 或者函数返回，状态也会是rejected，自动执行afterReject。这两个函数的执行都是由 Promise 对象 pms1 自行控制，编程者无法确定它何时执行，也即是异步执行的，所以这里极有可能输出

我可能在 afterResolve 和 afterReject 前执行
通过 小明

解决这个问题，可以使用 async、await 关键字，并对代码进行如下修改

<script>
      var data = ['001', '小明', '数学']
      var score = 90

      function afterResolve(data) {
        console.log('通过 ' + data[1])
      }
      function afterReject(info) {
        console.log('不通过 ' + info.toString())
      }

      function getPromise() {
        return new Promise((resolve, reject) => {
          if (score >= 60) {
            resolve(data)
          } else if (0 <= score && score < 60) {
            reject(new Date())
          } else {
            throw 'score exception'
          }
        })
          .then(afterResolve)
          .catch(afterReject)
      }

      async function testAwait() {
        await getPromise()
        console.log('我等在 afterResolve 和 afterReject 后执行')
      }

      testAwait()

　getPromise() 函数返回 Promise 对象， await 等待 Promise 对象 处理完自己的全部逻辑后，才继续执行打印，输出

通过 小明
我等在 afterResolve 和 afterReject 后执行