Promise
产生：改善 Callback Hell 问题
什么样的方法可以用 Promise 重写
例 1:
mysql.query('SELECT 1 + 1 AS solution', function (err, rows, fields) {
if (err) {
throw err;
}
// 对查询结果进行操作
console.log('The solution is: ', rows[0].solution);
});
例 2：
fs.readFile('myfile.txt', function (err, file) {
if (err) {
throw err;
}
// 对file进行操作
});
如何将一个回调方法改为 Promise
Promisify
一般情况下，该方式首选。
const util = require('util');
const fs = require('fs');
const stat = util.promisify(fs.stat);
stat('.')
.then((stats) => {
// Do something with `stats`
})
.catch((error) => {
// Handle the error.
});
new Promise()
虽然所有的最终实现原理应该都是这样，但这种写法上的话，又再次出现了地狱回调的问题，可读性非常差。
const fs = require('fs');
const stat = (...args) =>
new Promise((resolve, reject) => {
fs.stat(...args, (err, stats) => {
if (err) {
reject(err);
}
else {
resolve(stats);
}
});
});
stat('.')
.then((stats) => {
// Do something with `stats`
})
.catch((error) => {
// Handle the error.
});
Defer
兼顾了可读性的一种写法。
const fs = require('fs');
const getDefer = () => {
const deferred = {};
deferred.promise = new Promise((resolve, reject) => {
deferred.resolve = resolve;
deferred.reject = reject;
});
return deferred;
};
const stat = (...args) => {
const deferred = getDefer();
fs.stat(...args, (err, stats) => {
if (err) {
deferred.reject(err);
}
else {
deferred.resolve(stats);
}
});
return deferred.promise;
};
stat('.')
.then((stats) => {
// Do something with `stats`
})
.catch((error) => {
// Handle the error.
});
如何调用 Promise 方法
直接执行
promiseFn()
.then()
.catch()
.then() // 此处的 .then 未经过异常捕获
.finally(); // 不管成功失败，最终都将执行
批量执行
Promise.all([promiseFn1(), promiseFn2()])
.then();
Promise.allSettled(); // 推荐
Promise.race();
Promise.any();
async / await
自 es7 时代新增的语法糖。其主要应用场景是对于 Promise 方法调用的再次封装。
什么样的方法应该用 async / await 包裹
示例：
// 原始代码
function query() {
return mysql.query('SELECT 1 + 1 AS solution').then((rows) => {
return rows[0].solution;
});
}
可使用该语法糖减少嵌套：
async function query() {
const [{ solution } = {}] = await mysql.query('SELECT 1 + 1 AS solution');
return solution;
}
什么样的方法不需要 async / await 包裹
示例：
async function query() {
// 一些同步操作
const result = await mysql.query('SELECT 1 + 1 AS solution');
return result;
// 或者直接：
// return await mysql.query('SELECT 1 + 1 AS solution');
}
其效果等同于：
function query() {
// 一些同步操作
return mysql.query('SELECT 1 + 1 AS solution');
}
并且，加上 async / await 包裹之后性能更低，因为多了一层无意义的语法糖嵌套。
并发执行
多个await命令后面的异步操作，如果不存在继发关系，最好让它们同时触发。
const foo = await getFoo();
const bar = await getBar();
上面代码中，getFoo和getBar是两个独立的异步操作（即互不依赖），被写成继发关系。这样比较耗时，因为只有getFoo完成以后，才会执行getBar，完全可以让它们同时触发。
// 写法一
let [foo, bar] = await Promise.all([getFoo(), getBar()]);
// 写法二
let fooPromise = getFoo();
let barPromise = getBar();
let foo = await fooPromise;
let bar = await barPromise;
上面两种写法，getFoo和getBar都是同时触发，这样就会缩短程序的执行时间。
p.s. 如果有多个 Promise 任务需要并发执行，建议不要使用或者慎重使用 Promise.all() 方法。
