node同步异步：三种解决回调地狱的方式

1.promisify

Promise 是一个构造函数，可以 new Promise() 得到一个 Promise 的实例；

1. 在 Promise 上，有两个函数，分别叫做 resolve（成功后的回调函数） 和 reject（失败后的回调函数）
2. 在 Promise 构造函数的 Prototype 属性上，有一个 .then() 方法，也就是说，只要是 Promise
   构造函数创建的实例，都可以访问到 .then() 方法
3. Promise 表示一个异步操作；每当我们 new 一个 Promise 的实例，这个实例，就表示一个具体的异步操作；
4. 既然 Promise 创建的实例，是一个异步操作，那么这个异步操作的结果，只能有两种状态：
5. 状态1：异步执行成功了，需要在内部调用 成功的回调函数 resolve 把结果返回给调用者； 状态2：异步执行失败了，需要在内部调用失败的回调函数 reject 把结果返回给调用者；
6. 由于 Promise 的实例，是一个异步操作，所以，内部拿到操作的结果后，无法使用 return
   把操作结果返回给调用者；这时候，只能使用回调函数的形式，来把成功或失败的结果，返回给调用者；
7. 可以在 new 出来的 Promise 实例上，调用 .then() 方法，【预先】为这个 Promise 异步操作，指定
   成功（resolve） 和 失败（reject） 回调函数；

/await关键字
1.它只能出现在异步函数中
2.await promise 它可以暂停异步函数的执行 等待promise对象返回结果后再向下执行函数

``示例如下

var p1 = new Promise(function (resolve, reject) {
    fs.readFile('./1.txt', 'utf-8', function (err, data) {
        if (err) {
            // console.log(err);
            reject(err);// 把容器的 Pending 状态变为 Rejected
        } else {
            // console.log(data);
            resolve(data);// 把容器的 Pending 状态变为 Resolved
        }
    })
});

var p2 = new Promise(function (resolve, reject) {
    fs.readFile('./2.txt', 'utf-8', function (err, data) {
        if (err) {
            reject(err);
        } else {
            resolve(data);
        }
    })
});

var p3 = new Promise(function (resolve, reject) {
    fs.readFile('./3.txt', 'utf-8', function (err, data) {
        if (err) {
            reject(err);
        } else {
            resolve(data);
        }
    })
});

// 读取成功调用 then 的第一个参数，即状态 Rejected
// 读取失败调用 then 的第二个参数，即状态 Resolved
p1
    .then(function (data) {
        console.log(data);
        return p2;
    }, function (err) {
        console.log(err);
    })
    .then(function (data) {
        console.log(data);
        return p3;
    })
    .then(function (data) {
        console.log(data);
    });
    .catch(err => {
        console.log('err:' + err)
	})

2.async/await

1.在普通函数定义的前面加上async关键字 普通函数就变成了异步函数
2.异步函数默认的返回值是promise对象
3.在异步函数内部使用throw关键字进行错误的抛出
await关键字
// 1.它只能出现在异步函数中
// 2.await promise 它可以暂停异步函数的执行 等待promise对象返回结果后再向下执行函数

async function p1 () {
	return 'p1';
}

async function p2 () {
	return 'p2';
}

async function p3 () {
	return 'p3';
}

async function run () {
	let r1 = await p1()
	let r2 = await p2()
	let r3 = await p3()
	console.log(r1)
	console.log(r2)
	console.log(r3)
}

run();

3.generator

Generator 函数是 ES6 提供的一种异步编程解决方案，语法行为与传统函数完全不同

特征：

1. function 命令与函数名之间有一个星号
2. 函数体内部使用 yield 语句定义不同的内部状态
   yield 表达式
   . Generator 函数内部提供了一种可以暂停执行的函数，yield 语句就是暂停标志

遍历器对象的 next 方法的运行逻辑如下：

1. 遇到 yield 语句就是暂停执行后面的操作，并将紧跟在 yield 后的表达式的值作为返回的对象的 value 值
2. 下次调用 next 方法继续向下执行后面的 yield 语句 直到 return 为止，将 return 的值赋值给 value，若无
   return 后面的值 value 都为 undefined，此时 done 值为 true，for of 遍历停止

注意：yield 表达式只能用在 Generator 函数里面，用在其他地方都会报错

function* helloWorldGenerator() {
  yield 'hello';
  yield 'world';
  return 'ending';
}

var hw = helloWorldGenerator();