async await 使用+基础+原理

async/await用法

其实你要实现一个东西之前，最好是先搞清楚这两样东西

这个东西有什么用？ 这个东西是怎么用的？

有什么用？

async/await的用处就是：用同步方式，执行异步操作，怎么说呢？举个例子 比如我现在有一个需求：先请求完接口1，再去请求接口2，我们通常会这么做

function request(num) { // 模拟接口请求return new Promise(resolve => {setTimeout(() => {resolve(num * 2)}, 1000)})
}

request(1).then(res1 => {console.log(res1) // 1秒后 输出 2request(2).then(res2 => {console.log(res2) // 2秒后 输出 4})
}) 

或者我现在又有一个需求：先请求完接口1，再拿接口1返回的数据，去当做接口2的请求参数，那我们也可以这么做

request(5).then(res1 => {console.log(res1) // 1秒后 输出 10request(res1).then(res2 => {console.log(res2) // 2秒后 输出 20})
}) 

其实这么做是没问题的，但是如果嵌套的多了，不免有点不雅观，这个时候就可以用async/await来解决了

async function fn () {const res1 = await request(5)const res2 = await request(res1)console.log(res2) // 2秒后输出 20
}
fn() 

是怎么用？

还是用刚刚的例子 需求一：

async function fn () {await request(1)await request(2)// 2秒后执行完
}
fn() 

需求二：

async function fn () {const res1 = await request(5)const res2 = await request(res1)console.log(res2) // 2秒后输出 20
}
fn() 

其实就类似于生活中的排队，咱们生活中排队买东西，肯定是要上一个人买完，才轮到下一个人。而上面也一样，在async函数中，await规定了异步操作只能一个一个排队执行，从而达到用同步方式，执行异步操作的效果，这里注意了：await只能在async函数中使用，不然会报错哦 刚刚上面的例子await后面都是跟着异步操作Promise，那如果不接Promise会怎么样呢？

function request(num) { // 去掉PromisesetTimeout(() => {console.log(num * 2)}, 1000)
}

async function fn() {await request(1) // 2await request(2) // 4// 1秒后执行完同时输出
}
fn() 

可以看出，如果await后面接的不是Promise的话，有可能其实是达不到排队的效果的 说完await，咱们聊聊async吧，async是一个位于function之前的前缀，只有async函数中，才能使用await。那async执行完是返回一个什么东西呢？

async function fn () {}
console.log(fn) // [AsyncFunction: fn]
console.log(fn()) // Promise {<fulfilled>: undefined} 

可以看出，async函数执行完会自动返回一个状态为fulfilled的Promise(不一定是成功态，但是肯定是个promise)，也就是成功状态，但是值却是undefined，那要怎么才能使值不是undefined呢？很简单，函数有return返回值就行了

async function fn (num) {return num
}
console.log(fn) // [AsyncFunction: fn]
console.log(fn(10)) // Promise {<fulfilled>: 10}
fn(10).then(res => console.log(res)) // 10 

可以看出，此时就有值了，并且还能使用then方法进行输出

总结

总结一下async/await的知识点

• await只能在async函数中使用，不然会报错
• async函数返回的是一个Promise对象，有无值看有无return值
• await后面最好是接Promise，虽然接其他值也能达到排队效果
• async/await作用是用同步方式，执行异步操作

什么是语法糖？

前面说了，async/await是一种语法糖，诶！好多同学就会问，啥是语法糖呢？我个人理解就是，语法糖就是一个东西，这个东西你就算不用他，你用其他手段也能达到这个东西同样的效果，但是可能就没有这个东西这么方便了。

回归正题，async/await是一种语法糖，那就说明用其他方式其实也可以实现他的效果，我们今天就是讲一讲怎么去实现async/await，用到的是ES6里的迭代函数——generator函数

generator函数

基本用法

generator函数跟普通函数在写法上的区别就是，多了一个星号*，并且只有在generator函数中才能使用yield，什么是yield呢，他相当于generator函数执行的中途暂停点，比如下方有3个暂停点。而怎么才能暂停后继续走呢？那就得使用到next方法，next方法执行后会返回一个对象，对象中有value 和 done两个属性

• value：暂停点后面接的值，也就是yield后面接的值
• done：是否generator函数已走完，没走完为false，走完为true

function* gen() {yield 1yield 2yield 3
}
const g = gen()
console.log(g.next()) // { value: 1, done: false }
console.log(g.next()) // { value: 2, done: false }
console.log(g.next()) // { value: 3, done: false }
console.log(g.next()) // { value: undefined, done: true } 

可以看到最后一个是undefined，这取决于你generator函数有无返回值

function* gen() {yield 1yield 2yield 3return 4
}
const g = gen()
console.log(g.next()) // { value: 1, done: false }
console.log(g.next()) // { value: 2, done: false }
console.log(g.next()) // { value: 3, done: false }
console.log(g.next()) // { value: 4, done: true } 

yield后面接函数

yield后面接函数的话，到了对应暂停点yield，会马上执行此函数，并且该函数的执行返回值，会被当做此暂停点对象的value

function fn(num) {console.log(num)return num
}
function* gen() {yield fn(1)yield fn(2)return 3
}
const g = gen()
console.log(g.next()) 
// 1
// { value: 1, done: false }
console.log(g.next())
// 2
//{ value: 2, done: false }
console.log(g.next()) 
// { value: 3, done: true } 

yield后面接Promise

前面说了，函数执行返回值会当做暂停点对象的value值，那么下面例子就可以理解了，前两个的value都是pending状态的Promise对象

function fn(num) {return new Promise(resolve => {setTimeout(() => {resolve(num)}, 1000)})
}
function* gen() {yield fn(1)yield fn(2)return 3
}
const g = gen()
console.log(g.next()) // { value: Promise { <pending> }, done: false }
console.log(g.next()) // { value: Promise { <pending> }, done: false }
console.log(g.next()) // { value: 3, done: true } 

其实我们想要的结果是，两个Promise的结果1 和 2，那怎么做呢？很简单，使用Promise的then方法就行了

const g = gen()
const next1 = g.next()
next1.value.then(res1 => {console.log(next1) // 1秒后输出 { value: Promise { 1 }, done: false }console.log(res1) // 1秒后输出 1const next2 = g.next()next2.value.then(res2 => {console.log(next2) // 2秒后输出 { value: Promise { 2 }, done: false }console.log(res2) // 2秒后输出 2console.log(g.next()) // 2秒后输出 { value: 3, done: true }})
}) 

next函数传参

generator函数可以用next方法来传参，并且可以通过yield来接收这个参数，注意两点

• 第一次next传参是没用的，只有从第二次开始next传参才有用
• next传值时，要记住顺序是，先右边yield，后左边接收参数

function* gen() {const num1 = yield 1console.log(num1)const num2 = yield 2console.log(num2)return 3
}
const g = gen()
console.log(g.next()) // { value: 1, done: false }
console.log(g.next(11111))
// 11111
//{ value: 2, done: false }
console.log(g.next(22222)) 
// 22222
// { value: 3, done: true } 

Promise+next传参

前面讲了

yield后面接Promise next函数传参

那这两个组合起来会是什么样呢？

function fn(nums) {return new Promise(resolve => {setTimeout(() => {resolve(nums * 2)}, 1000)})
}
function* gen() {const num1 = yield fn(1)const num2 = yield fn(num1)const num3 = yield fn(num2)return num3
}
const g = gen()
const next1 = g.next()
next1.value.then(res1 => {console.log(next1) // 1秒后同时输出 { value: Promise { 2 }, done: false }console.log(res1) // 1秒后同时输出 2const next2 = g.next(res1) // 传入上次的res1next2.value.then(res2 => {console.log(next2) // 2秒后同时输出 { value: Promise { 4 }, done: false }console.log(res2) // 2秒后同时输出 4const next3 = g.next(res2) // 传入上次的res2next3.value.then(res3 => {console.log(next3) // 3秒后同时输出 { value: Promise { 8 }, done: false }console.log(res3) // 3秒后同时输出 8 // 传入上次的res3console.log(g.next(res3)) // 3秒后同时输出 { value: 8, done: true }})})
}) 

实现 async await

其实上方的generator函数的Promise+next传参，就很像async/await了，区别在于

• gen函数执行返回值不是Promise，asyncFn执行返回值是Promise
• gen函数需要执行相应的操作，才能等同于asyncFn的排队效果
• gen函数执行的操作是不完善的，因为并不确定有几个yield，不确定会嵌套几次

那我们怎么办呢？我们可以封装一个高阶函数，接收一个generator函数，并经过一系列处理，返回一个具有async函数功能的函数

function generatorToAsync(generatorFn) {// 经过一系列处理return 具有async函数功能的函数
} 

返回值Promise

之前我们说到，async函数的执行返回值是一个Promise，那我们要怎么实现相同的结果呢

function* gen() {

}

const asyncFn = generatorToAsync(gen)

console.log(asyncFn()) // 期望这里输出 Promise 

其实很简单，generatorToAsync函数里做一下处理就行了

function* gen() {

}
function generatorToAsync (generatorFn) {return function () {return new Promise((resolve, reject) => {})}
}

const asyncFn = generatorToAsync(gen)

console.log(asyncFn()) // Promise 

加入一系列操作

咱们把之前的处理代码，加入generatorToAsync函数中

function fn(nums) {return new Promise(resolve => {setTimeout(() => {resolve(nums * 2)}, 1000)})
}
function* gen() {const num1 = yield fn(1)const num2 = yield fn(num1)const num3 = yield fn(num2)return num3
}
function generatorToAsync(generatorFn) {return function () {return new Promise((resolve, reject) => {const g = generatorFn()const next1 = g.next()next1.value.then(res1 => {const next2 = g.next(res1) // 传入上次的res1next2.value.then(res2 => {const next3 = g.next(res2) // 传入上次的res2next3.value.then(res3 => {// 传入上次的res3resolve(g.next(res3).value)})})})})}
}

const asyncFn = generatorToAsync(gen)

asyncFn().then(res => console.log(res)) // 3秒后输出 8 

可以发现，咱们其实已经实现了以下的async/await的结果了

async function asyncFn() {const num1 = await fn(1)const num2 = await fn(num1)const num3 = await fn(num2)return num3
}
asyncFn().then(res => console.log(res)) // 3秒后输出 8 

完善代码

上面的代码其实都是死代码，因为一个async函数中可能有2个await，3个await，5个await ，其实await的个数是不确定的。同样类比，generator函数中，也可能有2个yield，3个yield，5个yield，所以咱们得把代码写成活的才行

function generatorToAsync(generatorFn) {return function() {const gen = generatorFn.apply(this, arguments) // gen有可能传参// 返回一个Promisereturn new Promise((resolve, reject) => {function go(key, arg) {let restry {res = gen[key](arg) // 这里有可能会执行返回reject状态的Promise} catch (error) {return reject(error) // 报错的话会走catch，直接reject}// 解构获得value和doneconst { value, done } = resif (done) {// 如果done为true，说明走完了，进行resolve(value)return resolve(value)} else {// 如果done为false，说明没走完，还得继续走// value有可能是：常量，Promise，Promise有可能是成功或者失败return Promise.resolve(value).then(val => go('next', val), err => go('throw', err))}}go("next") // 第一次执行})}
}

const asyncFn = generatorToAsync(gen)

asyncFn().then(res => console.log(res)) 

这样的话，无论是多少个yield都会排队执行了，咱们把代码写成活的了

示例

async/await版本

async function asyncFn() {const num1 = await fn(1)console.log(num1) // 2const num2 = await fn(num1)console.log(num2) // 4const num3 = await fn(num2)console.log(num3) // 8return num3
}
const asyncRes = asyncFn()
console.log(asyncRes) // Promise
asyncRes.then(res => console.log(res)) // 8 

使用generatorToAsync函数的版本

function* gen() {const num1 = yield fn(1)console.log(num1) // 2const num2 = yield fn(num1)console.log(num2) // 4const num3 = yield fn(num2)console.log(num3) // 8return num3
}

const genToAsync = generatorToAsync(gen)
const asyncRes = genToAsync()
console.log(asyncRes) // Promise
asyncRes.then(res => console.log(res)) // 8 

async await ssh

经常有人说async函数是generator函数的语法糖，那么到底是怎么样一个糖呢？让我们来一层层的剥开它的糖衣。 有的同学想说，既然用了generator函数何必还要实现async呢？ 这篇文章的目的就是带大家理解清楚async和generator之间到底是如何相互协作，管理异步的。

// 示例

const getData = () => new Promise(resolve => setTimeout(() => resolve("data"), 1000))
async function test() {
const data = await getData()
console.log('data: ', data);
const data2 = await getData()
console.log('data2: ', data2);
return 'success'
}
// 这样的一个函数 应该再1秒后打印data 再过一秒打印data2 最后打印success
test().then(res => console.log(res)) 

对于这个简单的案例来说，如果我们把它用generator函数表达，会是怎么样的呢？

function* testG() {
// await被编译成了yield
const data = yield getData()
console.log('data: ', data);
const data2 = yield getData()
console.log('data2: ', data2);
return 'success'
}
// 我们知道，generator函数是不会自动执行的，每一次调用它的next方法，会停留在下一个yield的位置。
// 利用这个特性，我们只要编写一个自动执行的函数，就可以让这个generator函数完全实现async函数的功能。
const getData = () => new Promise(resolve => setTimeout(() => resolve("data"), 1000))
var test = asyncToGenerator(
function* testG() {
// await被编译成了yield
const data = yield getData()
console.log('data: ', data);
const data2 = yield getData()
console.log('data2: ', data2);
return 'success'
}
)
test().then(res => console.log(res)) 

那么大体上的思路已经确定了， asyncToGenerator接受一个generator函数，返回一个promise， 关键就在于，里面用yield来划分的异步流程，应该如何自动执行

如果是手动执行

在编写这个函数之前，我们先模拟手动去调用这个generator函数去一步步的把流程走完，有助于后面的思考。

function* testG() {
// await被编译成了yield
const data = yield getData()
console.log('data: ', data);
const data2 = yield getData()
console.log('data2: ', data2);
return 'success'
}
// 我们先调用testG生成一个迭代器
// 返回了一个迭代器
var gen = testG()
// 然后开始执行第一次next
// 第一次调用next 停留在第一个yield的位置
// 返回的promise里 包含了data需要的数据
var dataPromise = gen.next()
// 这里返回了一个promise，就是第一次getData()所返回的promise，注意
const data = yield getData()
// 这段代码要切割成左右两部分来看，第一次调用next，其实只是停留在了yield getData()这里，
// data的值并没有被确定。
// 那么什么时候data的值会被确定呢？
// 下一次调用next的时候，传的参数会被作为上一个yield前面接受的值
// 也就是说，我们再次调用gen.next('这个参数才会被赋给data变量')的时候
// data的值才会被确定为'这个参数才会被赋给data变量'

gen.next('这个参数才会被赋给data变量')
// 然后这里的data才有值
const data = yield getData()
// 然后打印出data
console.log('data: ', data);
// 然后继续走到下一个yield
const data2 = yield getData()

// 然后往下执行，直到遇到下一个yield，继续这样的流程...
// 这是generator函数设计的一个比较难理解的点，但是为了实现我们的目标，还是得去学习它~
// 借助这个特性，如果我们这样去控制yield的流程，是不是就能实现异步串行了？

function* testG() {
// await被编译成了yield
const data = yield getData()
console.log('data: ', data);
const data2 = yield getData()
console.log('data2: ', data2);
return 'success'
}
var gen = testG()
var dataPromise = gen.next()
console.log(dataPromise)
dataPromise.value.then((value1) => {
// data1的value被拿到了 继续调用next并且传递给data
var data2Promise = gen.next(value1)
// console.log('data: ', data);
// 此时就会打印出data
data2Promise.value.then((value2) => {
// data2的value拿到了 继续调用next并且传递value2
gen.next(value2)
// console.log('data2: ', data2);
// 此时就会打印出data2
})
})
// 这样的一个看着像callback hell的调用，就可以让我们的generator函数把异步安排的明明白白。 

实现

// 有了这样的思路，实现这个高阶函数就变得很简单了。 // 先整体看一下结构，有个印象，然后我们逐行注释讲解。

function asyncToGenerator (generatorFunc) {return function () {const gen = generatorFunc.apply(this, arguments)return new Promise((resolve, reject) => {function step(key, arg) {let generatorResulttry {generatorResult = gen[key](arg)} catch {return reject(error)}const {value, done} = generatorResultif (done) {return resolve(value)} else {return Promise.resolve(value).then(val => step('next', val), err => step('throw',err))}}step('next')})}
} 

接下来逐行讲解。

function asyncToGenerator(generatorFunc) {
// 返回的是一个新的函数
return function() {
// 先调用generator函数 生成迭代器
// 对应 var gen = testG()
const gen = generatorFunc.apply(this, arguments)
// 返回一个promise 因为外部是用.then的方式 或者await的方式去使用这个函数的返回值的
// var test = asyncToGenerator(testG)
// test().then(res => console.log(res))
return new Promise((resolve, reject) => {
// 内部定义一个step函数 用来一步一步的跨过yield的阻碍
// key有next和throw两种取值，分别对应了gen的next和throw方法
// arg参数则是用来把promise resolve出来的值交给下一个yield
function step(key, arg) {
let generatorResult
// 这个方法需要包裹在try catch中
// 如果报错了 就把promise给reject掉 外部通过.catch可以获取到错误
try {
generatorResult = gen[key](arg)
} catch (error) {
return reject(error)
}
// gen.next() 得到的结果是一个 { value, done } 的结构
const { value, done } = generatorResult
if (done) {
// 如果已经完成了 就直接resolve这个promise
// 这个done是在最后一次调用next后才会为true
// 以本文的例子来说 此时的结果是 { done: true, value: 'success' }
// 这个value也就是generator函数最后的返回值
return resolve(value)
} else {
// 除了最后结束的时候外，每次调用gen.next()
// 其实是返回 { value: Promise, done: false } 的结构，
// 这里要注意的是Promise.resolve可以接受一个promise为参数
// 并且这个promise参数被resolve的时候，这个then才会被调用
return Promise.resolve(
// 这个value对应的是yield后面的promise
value
).then(
// value这个promise被resove的时候，就会执行next
// 并且只要done不是true的时候 就会递归的往下解开promise
// 对应gen.next().value.then(value => {
// gen.next(value).value.then(value2 => {
// gen.next()
//
// // 此时done为true了 整个promise被resolve了
// // 最外部的test().then(res => console.log(res))的then就开始执行了
// })
// })
function onResolve(val) {
step("next", val)
},
// 如果promise被reject了 就再次进入step函数
// 不同的是，这次的try catch中调用的是gen.throw(err)
// 那么自然就被catch到 然后把promise给reject掉啦
function onReject(err) {
step("throw", err)
},
)
}
}
step("next")
})
}
} 

// 本文用最简单的方式实现了asyncToGenerator这个函数，这是babel编译async函数的核心，当然在babel中，generator函数也被编译成了一个很原始的形式，本文我们直接以generator替代。

ES6 系列之 Babel 将 Async 编译成了什么样子

本文就是简单介绍下 Async 语法编译后的代码。 Async

const fetchData = (data) => new Promise((resolve) => setTimeout(resolve, 1000, data + 1))
const fetchValue = async function () {
var value1 = await fetchData(1);
var value2 = await fetchData(value1);
var value3 = await fetchData(value2);
console.log(value3)
};
fetchValue();
// 大约 3s 后输出 4 

Babel

// 我们直接在 Babel 官网的 Try it out 粘贴上述代码，然后查看代码编译成什么样子：

"use strict";
function _asyncToGenerator(fn) {
return function() {
var gen = fn.apply(this, arguments);
return new Promise(function(resolve, reject) {
function step(key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
return Promise.resolve(value).then(
function(value) {
step("next", value);
},
function(err) {
step("throw", err);
}
);
}
}
return step("next");
});
};
}

var fetchData = function fetchData(data) {
return new Promise(function(resolve) {
return setTimeout(resolve, 1000, data + 1);
});
};

var fetchValue = (function() {
var _ref = _asyncToGenerator(
/*#__PURE__*/ regeneratorRuntime.mark(function _callee() {
var value1, value2, value3;
return regeneratorRuntime.wrap(
function _callee$(_context) {
while (1) {
switch ((_context.prev = _context.next)) {
case 0:
_context.next = 2;
return fetchData(1);

case 2:
value1 = _context.sent;
_context.next = 5;
return fetchData(value1);

case 5:
value2 = _context.sent;
_context.next = 8;
return fetchData(value2);

case 8:
value3 = _context.sent;

console.log(value3);

case 10:
case "end":
return _context.stop();
}
}
},
_callee,
this
);
})
);

return function fetchValue() {
return _ref.apply(this, arguments);
};
})();

fetchValue(); 

_asyncToGenerator

这次我们重点来看看 _asyncToGenerator 函数：

function _asyncToGenerator(fn) {
return function() {
var gen = fn.apply(this, arguments);
return new Promise(function(resolve, reject) {
function step(key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
return Promise.resolve(value).then(
function(value) {
step("next", value);
},
function(err) {
step("throw", err);
}
);
}
}
return step("next");
});
};
} 

以上这段代码主要是用来实现 generator 的自动执行以及返回 Promise。 当我们执行 fetchValue() 的时候，执行的其实就是 _asyncToGenerator 返回的这个匿名函数，在匿名函数中，我们执行了

var gen = fn.apply(this, arguments);
// 这一步就相当于执行 Generator 函数，举个例子：
function* helloWorldGenerator() {
yield 'hello';
yield 'world';
return 'ending';
}
var hw = helloWorldGenerator(); 

var gen = fn.apply(this, arguments) 就相当于 var hw = helloWorldGenerator();，返回的 gen 是一个具有 next()、throw()、return() 方法的对象。 // 然后我们返回了一个 Promise 对象，在 Promise 中，我们执行了 step(“next”)，step 函数中会执行：

try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
// step("next") 就相当于 var info = gen.next()，返回的 info 对象是一个具有 value 和 done 属性的对象：
// {value: Promise, done: false}
// 接下来又会执行：
if (info.done) {
resolve(value);
} else {
return Promise.resolve(value).then(
function(value) {
step("next", value);
},
function(err) {
step("throw", err);
}
);
} 

value 此时是一个 Promise，Promise.resolve(value) 依然会返回这个 Promise，我们给这个 Promise 添加了一个 then 函数，用于在 Promise 有结果时执行，有结果时又会执行 step(“next”, value)，从而使得 Generator 继续执行，直到 info.done 为 true，才会 resolve(value)。

// 不完整但可用的代码

(function() {
var ContinueSentinel = {};

var mark = function(genFun) {
var generator = Object.create({
next: function(arg) {
return this._invoke("next", arg);
}
});
genFun.prototype = generator;
return genFun;
};

function wrap(innerFn, outerFn, self) {
var generator = Object.create(outerFn.prototype);

var context = {
done: false,
method: "next",
next: 0,
prev: 0,
sent: undefined,
abrupt: function(type, arg) {
var record = {};
record.type = type;
record.arg = arg;

return this.complete(record);
},
complete: function(record, afterLoc) {
if (record.type === "return") {
this.rval = this.arg = record.arg;
this.method = "return";
this.next = "end";
}

return ContinueSentinel;
},
stop: function() {
this.done = true;
return this.rval;
}
};

generator._invoke = makeInvokeMethod(innerFn, context);

return generator;
}

function makeInvokeMethod(innerFn, context) {
var state = "start";

return function invoke(method, arg) {
if (state === "completed") {
return { value: undefined, done: true };
}

context.method = method;
context.arg = arg;

while (true) {
state = "executing";

if (context.method === "next") {
context.sent = context._sent = context.arg;
}

var record = {
type: "normal",
arg: innerFn.call(self, context)
};

if (record.type === "normal") {
state = context.done ? "completed" : "yield";

if (record.arg === ContinueSentinel) {
continue;
}

return {
value: record.arg,
done: context.done
};
}
}
};
}

window.regeneratorRuntime = {};

regeneratorRuntime.wrap = wrap;
regeneratorRuntime.mark = mark;
})();

"use strict";

function _asyncToGenerator(fn) {
return function() {
var gen = fn.apply(this, arguments);
return new Promise(function(resolve, reject) {
function step(key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
return Promise.resolve(value).then(
function(value) {
step("next", value);
},
function(err) {
step("throw", err);
}
);
}
}
return step("next");
});
};
}

var fetchData = function fetchData(data) {
return new Promise(function(resolve) {
return setTimeout(resolve, 1000, data + 1);
});
};

var fetchValue = (function() {
var _ref = _asyncToGenerator(
/*#__PURE__*/
regeneratorRuntime.mark(function _callee() {
var value1, value2, value3;
return regeneratorRuntime.wrap(
function _callee$(_context) {
while (1) {
switch ((_context.prev = _context.next)) {
case 0:
_context.next = 2;
return fetchData(1);

case 2:
value1 = _context.sent;
_context.next = 5;
return fetchData(value1);

case 5:
value2 = _context.sent;
_context.next = 8;
return fetchData(value2);

case 8:
value3 = _context.sent;

console.log(value3);

case 10:
case "end":
return _context.stop();
}
}
},
_callee,
this
);
})
);

return function fetchValue() {
return _ref.apply(this, arguments);
};
})();

fetchValue(); 

上边两个章节中最重要的就是这个

function _asyncToGenerator(fn) {return function() {var gen = fn.apply(this, arguments);return new Promise(function(resolve, reject) {function step(key, arg) {try {var info = gen[key](arg);var value = info.value;} catch (error) {reject(error);return;}if (info.done) {resolve(value);} else {return Promise.resolve(value).then(function(value) {step("next", value);},function(err) {step("throw", err);});}}return step("next");});};
} 

最后

最近还整理一份JavaScript与ES的笔记，一共25个重要的知识点，对每个知识点都进行了讲解和分析。能帮你快速掌握JavaScript与ES的相关知识，提升工作效率。

有需要的小伙伴，可以点击下方卡片领取，无偿分享