1、回调函数(callback)

      setTimeout(() => {        // callback 函数体      })复制代码

缺点：回调地狱，不能用try catch捕获错误，不能return

回调地狱的根本问题在于：

• 缺乏顺序性：回调地狱导致的调试困难，和大脑的思维方式不符
• 嵌套函数存在耦合性，一旦有所改动，就会牵一发而动全身，即（控制反转）
• 嵌套函数过多的话，很难处理错误

ajax('XXX1', () => {// callback 函数体ajax('XXX2', () => {// callback 函数体ajax('XXX3', () => {// callback 函数体})})
})复制代码

优点：解决了同步的问题（只要有一个任务耗时很长，后面的任务都必须排队等着，会拖延整个程序的执行）

2、Promise

Promise就是为了就觉callback的问题而产生的。

Promise实现了链式调用，也就是说每次then后返回的都是一个全新Promise，如果我们在then中return，return的结果会被Promise.resolve()包装

优点：解决了回调地狱的问题

ajax('XXX1').then(res => {// 操作逻辑return ajax('XXX2')}).then(res => {// 操作逻辑return ajax('XXX3')}).then(res => {// 操作逻辑})复制代码

缺点：无法取消Promise，错误需要通过回调函数来捕获

3、Generator

特点：可以控制函数的执行，可以配合co函数库使用

function *fetch() {yield ajax('XXX1', () => {})yield ajax('XXX2', () => {})yield ajax('XXX3', () => {})
}
let it = fetch()
let result1 = it.next()
let result2 = it.next()
let result3 = it.next()复制代码

4、Async/await

async、await是异步的终极解决方案

优点是：代码清晰，不用像Promise写一大堆then链，处理了回调地狱的问题

缺点：await将异步代码改造成同步代码，如果多个异步操作没有依赖性而使用await会导致性能上的降低。

async function test() {// 以下代码没有依赖性的话，完全可以使用 Promise.all 的方式// 如果有依赖性的话，其实就是解决回调地狱的例子了await fetch('XXX1')await fetch('XXX2')await fetch('XXX3')
}复制代码

下面来看一个使用await的例子：

let a = 0
let b = async () => {a = a + await 10console.log('2', a) // -> '2' 10
}
b()
a++
console.log('1', a) // -> '1' 1复制代码

对于以上代码你可能会有疑惑，让我来解释下原因

• 首先函数b先执行，在执行到await 10之前变量 a 还是0，因为 await 内部实现了generator，generator 会保留堆栈中东西，所以这时候 a = 0 被保存了下来
• 因为await 是异步操作，后来的表达式不返回 Promise 的话，就会包装成 Promise.resolve(返回值)，然后会去执行函数外的同步代码
• 同步代码执行完毕后开始执行异步代码，将保存下来的值拿出来适用，这时候 a = 0 + 10

上述解释中提到了await 内部实现了 generator ，其实 await 就是 generator 加上 Promise 的语法糖，且内部实现了自动执行generator。详情可参考然阮一峰的ES6 es6.ruanyifeng.com/#docs/array