async、await

1、async 函数返回一个Promise对象，这个Promise对象不只有resolve状态，还有reject状态（如果async函数内部出错）

onLoad:  function (options) {
    async function list(){
      return 'aaa'
    }
    console.log(list())
  },

输出

Promise {<resolved>: "aaa"}

2、await 就是异步等待，后面应该跟一个Promise对象，如果不是Promise对象，那么会被转成一个立即 resolve 的Promise

3、await 等待的是一个Promise对象，会将Promise对象的resolve状态的值返回，而不是返回Promise对象

onLoad: async function (options) {
    const aa = await this.promise1()   //没有await
    console.log(aa)
  },

  promise1(){
    return new Promise((resolve, reject) => {
      resolve('aaaa')
    })
  },

输出 Promise对象

Promise {<resolved>: "aaaa"}

onLoad: async function (options) {
    const aa =  await this.promise1()   //有await
    console.log(aa)
  },

  promise1(){
    return new Promise((resolve, reject) => {
      resolve('aaaa')
    })
  },

输出 Promise对象resolve的值

aaaa

4、程序中只要有Promise对象返回reject状态，就会抛出异常，有await(等待一个异常)会阻止下边代码的执行，没有await下边代码会正常执行（最后再抛出异常）

    异常最后抛出；异常中会附带reject的值；会抛出多个异常，如果存在多个reject状态的Promise对象

onLoad: async function (options) {
    const aa = await this.promise1()   //没有await
    console.log(aa)
  },

  promise1() {
    return new Promise((resolve, reject) => {
      reject('aaaa')
    })
  },

最后抛出异常，没有await，下边程序正常执行

Promise {<rejected>: "aaaa"}
Uncaught (in promise) aaaa

5、await 等待的Promise对象返回了reject状态，程序就会抛出异常，await后边的程序不会执行

onLoad: async function (options) {
    const aa = await this.promise1()
    console.log(aa)
  },

  promise1() {
    return new Promise((resolve, reject) => {
      reject('aaaa')
    })
  },

程序抛出异常，有await，await下边的程序不会执行

Uncaught (in promise) aaaa

6、await并不是等待他里边的代码执行完成之后，才执行下边的代码， await的意思早晚会执行，只是遇到等待的promise对象返回reject状态时，await后边的代码才不会执行

function testSometing() {
    console.log("执行testSometing");
    return "testSometing";
}

async function testAsync() {
    console.log("执行testAsync");
    return Promise.resolve("hello async");
}

async function test() {
    console.log("test start...");
    const v1 = await testSometing();//关键点1
    console.log(v1);
    const v2 = await testAsync();
    console.log(v2);
    console.log(v1, v2);
}

test();

var promise = new Promise((resolve)=> { console.log("promise start.."); resolve("promise");});//关键点2
promise.then((val)=> console.log(val));

console.log("test end...")

输出结果

test start...
执行testSometing
promise start..
test end...
testSometing
执行testAsync
promise
hello async
testSometing hello async

7、async 中需要有直接的return，如果没有直接的return（流水线上没有return），调用async函数会返回undefined，等于没有发现return

async __handleImg(){
      setTimeout(res=>{
        return 'aaaaaaa'
      }, 5000)
  },

调用

__checkAuth() {
    console.log(this.__handleImg())
    this.__handleImg()
    .then(res=>{
       console.log(res) 
    })
}

输出

Promise {<resolved>: undefined}
undefined

8、async 的云函数，只会执行直接的return（流水线上的return），非直接的return（异步中的return）不会执行

// 云函数入口函数
exports.main = async (event, context) => {
  let {
    sharerOpenid
  } = event

  share.where({
    sharerOpenid
  }).get()
  .then(res=>{
    if(res.data.length === 0){
      return share.add({    //非直接的return（异步中的return），不会执行
        data: {
          sharerOpenid
        }
      })
    }
  })
  .catch(err=>{
    console.log(err)
  })

}

9、await 后边的函数需要有直接的return，如果没有直接的return（流水线上没有return），await这个函数会返回undefined，等于没有发现return

 __imgCheck(){
    wx.showToast({
      title: 'await异步中return',
      success: res=>{
        return new Promise((resolve,reject)=>{
          console.log('bbbbbbbbbbbbbbb')
          resolve('1111')
        })
      }
    })
  },

调用

let result = await this.__imgCheck()
console.log(result)
console.log('aaaaaaa')

输出

undefined
aaaaaaa
bbbbbbbbbbbbbbb

执行顺序：先执行流水线上的，再执行临时储物台上的

流水线上：console.log(result)=>undefined, console.log('aaaaaaa')=>aaaaaaa

临时储物台上：执行了__imgCheck()，将函数中的Promise对象放到了临时储物台，console.log('bbbbbbbbbbbbbbb')=>bbbbbbbbbbbbbbbbbb

10、await 后边的函数有直接的return，await才会等待函数中的代码执行完成后，再执行下边的代码

__imgSecCheck(url){
    return new Promise((resolve, reject) => {
      resolve('1111')
      console.log('bbbbbbbbbbbbbbb')
    })
  },

调用

let result = await this.__imgCheck()
console.log(result)
console.log('aaaaaaa')

输出

bbbbbbbbbbbbbbb
1111
aaaaaaa

执行顺序：先执await函数中的代码(先流水线，后临时储物台)，有了结果后，再执行下边的代码

函数中的代码：console.log('bbbbbbbbbbbbbbb')=>bbbbbbbbbbbbbbbbbb，console.log(result)=>1111

有了结果，再执行下边的代码：console.log('aaaaaaa')=>aaaaaaa