【第4-3章】async await

function* generator(a) {
    yield console.log(a);
    let b = 111+222;
    yield a+b;
    let d = yield 765+3
    console.log(`d=${d}`)
    return 1234567
}
let gen = generator(333)
gen.next() // value:333,done:false,
gen.next() // value:666,done:false
gen.next() // value:768,done:false
gen.next(123) // d = 123 value:1234567(return为1234567，若函数没有return返回值则返回值为undefined),done:true
//next()函数的参数当做上一个yield语句的返回值。

function* foo() {
    yield 1;
    yield 2;
    yield 3;
    yield 4;
    yield 5;
}

for(let v of foo()) {
    console.log(v)
}
// 1 2 3 4 5 

let obj = {
    fun:function() {

    },
    fun1: function* () {

    }
}
// 等同于
let obj = {
    fun () {

    },
    *fun1 () {

    }
}

async function fn1 () {
    let a = Promise.reject(100)
    // Uncaught (in promise) 100
    const res = await a 
// 不执行，await相当于promise.then，
// 所以上面代码变为Promise.reject(100).then(()=>{})无法处理上面的reject，直接报错
    console.log(res)  
}
fn1() // Uncaught (in promise) 100

async function fn1 () {
    let a = Promise.reject(100)
    // Uncaught (in promise) 100
    try{
        const res = await a // 不执行，await相当于promise.then，所以无法处理上面的reject，直接报错
        console.log(res)  
    }
    catch(e) {
        console.log(`e=${e}`) // e=100
    }
}
fn1() // e=100

async function fn1 () {
    return 100 // 相当于 return Promise.resolve(100)
}
fn1 == 100 // false，async返回一个promise，所以写值相当于promise.resolve(100)
fn1().then((n)=>{ // async方法因为返回的是promise所以可以加then
    console.log(`n=${n}`) // 100
})

async function fn1 () {
    let a = await 100 // 正常情况下，await命令后面是一个 Promise 对象，返回该对象的结果。如果不是 Promise 对象，就直接返回对应的值。
   // a.then()报错
   // await虽然跟着一个promise对象，但返回结果可不一定是promise。
    console.log(a) // 100
}

// await如果赋值了，这个值返回的then中的参数
async function fna() {
    let a = await Promise.resolve(100) 
// 理解为Promise.resolve(100).then()中then的参数
// then中参数为100，所以a为100
}

function timeout(ms) {
    return new Promise((resolve) => {
      console.log('resolve=',resolve)
      setTimeout(()=>{resolve(100)}, ms);
    });
  }
  
  async function asyncPrint(value, ms) {
    let a = await timeout(ms);
    console.log('a='+a)
    console.log(value);
  }  //a =100

async function fn1() {
    const p4 = Promise.reject('err1')
    const res = await p4
    console.log(res)
}
fn1() // Uncaught (in promise) err1
// 解决方法： 加try catch捕获

async function fn1() {
    console.log(1)
    await console.log(2)

        await console.log(3)

            await setTimeout(()=>{console.log(4)},3000)
            console.log(5)

                await console.log(6)
                console.log(7)
}
fn1() 
console.log(8) // 1 2 8 3 5 6 7 4
// 先执行fn1() 
// 执行console.log(1)
// 执行console.log(2)
// 执行第一个 await ,await后面部分为回调（异步操作），所以函数执行完毕，退出执行同步代码
// 执行console.log(8)
// 同步代码执行完毕，执行回调函数，即第一个await后面部分
// 执行console.log(3)
// 执行第二个 await
// 后面的部分为第二个await的回调，执行回调
// 执行setTimeout(()=>{console.log(3)},3000) ，定时器三秒启动
// 执行第三个await ，同样后面部分是第三个await的回调
// 执行console.log(5)
// 后面和上面同理，执行console.log(6)
// 执行第四个await，后面内容一样是它的回调
// 执行console.log(7)