完美的异步？

ES6添加Promise大大的方便了异步的调用，ES7提出async，await来完善异步。人类就是在这样一步一步的进步!

async

先看看async这个函数：

async function name(argument) {
  statements
}

async函数就是在函数面前用async声明

• 当async函数在被声明的时候他会返回一个Promise
• 当async函数返回一个值时,这个值会当成Promise的resolve()的参数
• 当async函数抛出一个值时候,这个值会当成promise的reject()的参数

async function testAsync() {
  return 'success'
}
const t = testAsync()
t.then((a) => {
  console.log(a)
})
// success

async function testAsync() {
  throw 'fail'
}
const t = testAsync()
t.then((a) => {
  console.log(a)
}, (a) => {
  console.log(a)
})
// fail

• async函数中有个特殊字符await,await后面若是一个异步函数，则在异步函数完成之后继续执行

 function testSome(x) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(x)
    }, 1000)
  })
}
async function test() {
  let a = await testSome(1)
  console.log(a)
}
test()
// 1

你是否会会考虑

let a = await testSome(1)
console.log(a)

为什么会是1呢？那我们就要说说await

• await就像等待出征丈夫归来的良人，若是等到它后面函数的返回值,就把返回的值作为await运算的结果。

详情文档

说了这么多这货到底能干些什么呢？

首先要说的是没有他之前我们要这么写promise:

function yieldSome(a) {
  return new Promise((resolve) => {
    setTimeout(() => resolve(a + 1), a)
  }, 1000)
}
function yieldOne(a) {
  console.log(`yieldone: ${a}`)
  return yieldSome(a)
}
function yieldTwo(a) {
  console.log(`yieldTwo: ${a}`)
  return yieldSome(a)
}
function go() {
  console.time('do')
  const one = 1
  yieldOne(one)
    .then(two => yieldTwo(two))
    .then(result => {
      console.log(`result is ${result}`)
      console.timeEnd('end')
    })
}
go()

那现在我们可以这么写：

 async function go() {
    console.time('doIt')
    const time1 = 300
    const time2 = await step1(time1)
    const time3 = await step2(time2)
    const result = await step3(time3)
    console.log(`result is ${result}`)
    console.timeEnd("doIt")
}
go()

-------------------------------------------------------华丽的分割线