async/await初始

async/await是用来解决异步的，常用的解决异步方法是用Promise，如下：

function foo() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(1)
    }, 2000)
  })
}

foo().then(res => {
  console.log(res); // 2s后输出1
})

但是如果有很多个.then，那么看起来逻辑也很复杂了，所以可以使用async、await来解决异步，如下：

function foo1() {
 return new Promise((resolve) => {
    setTimeout(() => {
      resolve(1)
    }, 2000)
  })
}

function foo2() {
 return new Promise((resolve) => {
    setTimeout(() => {
      resolve(2)
    }, 2000)
  })
}

async function foo() {
  const result1 = await foo1();
  console.log(result1); // 2s后打印1
  const result2 = await foo2();
  console.log(result2); // 4s后打印2
}

console.log(foo()); // [<pending>]

如上，发现await后面总是跟着Promise，并且async函数返回的是一个Promise。
当await后面不跟Promise的时候，会立即执行，不会阻碍后面的代码。

async function foo() {
  await setTimeout(() => {
    console.log(1)
  }, 2000);
  console.log(2);
}
foo(); // 2, 1

async、await相当于是generator的语法糖，generator函数是一种特殊的函数，前面会带有一个*，它里面可以使用yield来对函数内部的执行暂停，然后返回一个{value, done}类型的对象，value表示yield后面的值，如果是函数的话会立即执行函数，将函数的返回值给value，done则表示是否走到头了，当走到最后一层的时候，done为true，value为return的值。

function * foo() {
  yield 1;
  yield foo1();
  return 4;
}

function foo1() {
  console.log(2)
  return 3;
}

const gen = foo();
console.log(gen); // 生成器对象
const result = gen.next();
console.log(result, result.value); // { value: 1, done: false } 1
const result1 = gen.next();
console.log(result1, result1.value); // 2 { value: 3, done: false } 3
const result2 = gen.next();
console.log(result2, result2.value); // { value: 4, done: true } 4

可以通过next去传递参数，第一次传递参数没用，只有从第二次开始有用.从yield左边接收参数；

function* foo() {
  const num = yield foo1(1);
  const num1 = yield foo1(num);
  const num2 = yield foo1(num1);
}

function foo1(num) {
  return num*2;
}

const gen = foo();
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next(2)); // num = 2, { value: 4, false }
console.log(gen.next(4)); // num1 = 4, { value: 8, false }
console.log(gen.next()); // { value: undefine, true }