上一章介绍的 Promise 虽然可以将异步程序用看起来像同步程序的方式来撰写,但写法还是与实际的同步程序有不小的差异。也因为 Promise 有这样的问题,所以后来的 ES2017 引入了「async / await」语法,可以完全地以同步程序的写法使用异步程序。
「async / await」是 Promise 和产生器的语法糖
在前面的章节中,我们有看过以下的程序:
async function infiniteLoop() {
while (1) {
}
}
infiniteLoop();
console.log("Hello!");
「async / await」语法的功能是用 ES6 添加的 Promise 和产生器来实现的。加上 async 关键字的函数,会变成异步函数,其主体会变成产生器函数的主体(不过我们无法直接在异步函数中使用 yield 关键字),而异步函数的主体中会再创建 Promise 对象实体来将产生器函数产生出来的迭代器的迭代结果当作「正确值」回传出来(用 resolve 函数)。异步函数则会将这个 Promise 对象回传出来。
如下:
function infiniteLoop() {
const generator = function* () {
while (1) {
}
};
return new Promise<void>(function (resolve) {
const iterator = generator();
const result = iterator.next();
resolve(result.value);
});
}
infiniteLoop();
console.log("Hello!");
以上程序,会在第 10 行陷入无穷循环。注意,Hello! 文字并不会被输出,因为传入 Promise 对象构造器的回呼函数是会被同步运行的,换句话说它不会等到 JavaScript 线程进入事件循环后才被调用。
透过上面的转换说明,我们可以知道原先这个 infiniteLoop 异步函数的回传值类型为 Promise<void>。所以若要明确地写出 infiniteLoop 异步函数的回传值类型,就会变成以下这样:
async function infiniteLoop(): Promise<void> {
while (1) {
}
}
infiniteLoop();
console.log("Hello!");
我们试着让异步函数回传随便的值出来看看,程序如下:
async function f(): Promise<number> {
return 123;
}
f()
.then((value) => {
console.log(value);
})
.catch((err) => {
console.error(err);
});
console.log("Hello!");
以上程序的输出结果为:
123
传入 Promise 对象实体的 then 方法的回呼函数需要透过微任务来调用,所以它在 JavaScript 线程进入事件循环后才会被运行,因此 Hello! 文字会在 123 之前输出。
以上程序,用 Promise 对象和产生器转换如下:
function f() {
const generator = function* () {
return 123;
};
return new Promise<number>(function (resolve) {
const iterator = generator();
const result = iterator.next();
resolve(result.value);
});
}
f()
.then((value) => {
console.log(value);
})
.catch((err) => {
console.error(err);
});
console.log("Hello!");
您可能会有这样的疑问:为什么要用到产生器?这是因为 await 关键字要依靠产生器的 yield 关键字功能来实作。
await 关键字可以用来「等待」一个 Promise 对象实体结束运行,并将「正确值」直接回传;将「错误值」直接用 throw 关键字抛出。例如:
async function f(): Promise<number> {
return 123;
}
try {
const value = await f();
console.log(value);
} catch (err) {
console.error(err);
}
console.log("Hello!");
当然,以上程序是无法编译的,因为我们无法在产生器函数之外使用 yield 关键字(await 关键字需要被转换为 yield 关键字),所以 await 关键字必须要用在异步函数之中。
为了让以上程序能够成功编译,可以将其改写如下:
async function f(): Promise<number> {
return 123;
}
async function main(): Promise<void> {
try {
const value = await f();
console.log(value);
} catch (err) {
console.error(err);
}
console.log("Hello!");
}
main();
以上程序的输出结果为:
Hello!
以上程序,用 Promise 对象和产生器转换如下:
function f() {
const generator = function* () {
return 123;
};
return new Promise<number>(function (resolve) {
const iterator = generator();
const result = iterator.next();
resolve(result.value);
});
}
function main() {
const generator = function* () {
try {
const value = yield f();
console.log(value);
} catch (err) {
console.error(err);
}
console.log("Hello!");
};
return new Promise<void>(function (resolve, reject) {
const iterator = generator();
const nextStep = (result: IteratorResult<Promise<number>>) => {
if (result.done) {
resolve(result.value);
} else {
let p;
if (result.value instanceof Promise) {
p = result.value;
} else {
p = Promise.resolve(result.value);
}
p
.then((value) => {
nextStep(iterator.next(value));
})
.catch((err) => {
nextStep(iterator.throw(err));
});
}
};
nextStep(iterator.next());
});
}
main();
以上程序的第 6 行到第 12 行,是因为我们知道第 2 行到第 4 行的产生器函数内没有使用到 yield 关键字(换句话说原本的异步函数主体中并没有使用到 await 关键字),而撰写出来的「async(无 await)转 Promise 和产生器」的结果。实际上,「async / await」语法的实作方式会更接近于程序第 28 行到第 54 行撰写的「async / await 转 Promise 和产生器」的结果。
来详细看一下程序第 28 行到第 54 行到底在做什么吧!
Promise 对象的构造器回呼函数中,在调用产生器函数创建迭代器后,会先调用第一次的 next 方法(程序第 53 行)。next 方法的回传结果会经过一个特定的进程(在此为 nextStep 函数)来处理。
在 nextStep 函数中,首先会去判断 next 方法的回传结果是否已经是最终结果(done 字段值为 true),如果是的话,就将 value 字段值当作此 Promise 对象实体的「正确值」。如果 next 方法的回传结果尚不是最终的(因为有使用 yield 关键字),就会判断 value 字段值是否为一个 Promise 对象实体(也就是说,await 关键字的右边不一定要是一个 Promise 对象实体)。如果 value 字段值不是一个 Promise 对象实体,就会产生一个 Promise 对象实体,并让 value 字段值作为其「正确值」。
接着会去调用这个 Promise 对象实体的 then 方法和 catch 方法。如果这个 Promise 对象实体是回传「正确值」,then 方法的回呼函数就会被运行(程序第 44 行),会利用迭代器的 next 方法,使 yield 关键字继续运行,并且回传原本这个「正确值」。也就是说,await 关键字可以直接将其右边的 Promise 对象实体的「正确值」回传到左边。
如果 Promise 对象实体是回传「错误值」,catch 方法的回呼函数就会被运行(程序第 47 行),会利用迭代器的 throw 方法,将「错误值」交到正在暂停的 yield 关键字的位置来抛出。也就是说,await 关键字可以被写在 try 区块中,来处理其 Promise 对象实体的「错误值」。
了解「async / await」语法的原理后,我们就自然而然地会用它了!
异步函数与无穷循环
再重新回来看这个例子:
async function infiniteLoop() {
while (1) {
}
}
infiniteLoop();
console.log("Hello!");
以上的 infiniteLoop 会运行一个无穷循环,它是一个异步函数,但 Hello! 文字在 infiniteLoop 函数被调用之后就永远不会被运行到……为什么?
首先,我们要知道异步函数并不会让 JavaScript 打开一个新的线程来运行它。再来,异步函数主体中的程序叙述,因为是在 Promise 对象的构造器的回呼函数被调用时运行,所以并不会在一个新的微任务中被运行,换句话说,它实际是被同步运行的!
但是,当异步函数中有使用 await 关键字时,此 await 关键字后的程序叙述就会被分配到新的微任务中被运行。也就是说,异步函数主体中,await 关键字前的叙述会被同步运行,而 await 关键字后的叙述则会被异步运行(在新的微任务中运行)。
举例来说:
async function infiniteLoop() {
const n = await 1;
while (1) {
}
}
infiniteLoop();
console.log("Hello!");
以上程序,仅仅是在第 2 行插入看似没有什么用的 await 关键字的叙述,就能让 Hello! 文字成功输出在主控台中。这就是因为 await 关键字后的叙述是异步运行的!
用「async / await」语法取代 Promise 的 then、catch 和 finally 方法
学会「async / await」语法之后,我们就再也没有必要用 Promise 的 then、catch 和 finally 方法来撰写「看起来像同步」的异步程序啦!改用「async / await」语法可以让代码更好写,也更加容易阅读。
例如:
import fs = require("node:fs");
import path = require("node:path");
const INPUT_PATH = "input";
const OUTPUT_FOLDER = "folder";
const OUTPUT_NAME = "output";
const pStat = () => new Promise((resolve, reject) => {
fs.stat(INPUT_PATH, (err, stats) => {
if (err) {
return reject(err);
}
resolve(stats);
});
});
const pMkdir = () => new Promise((resolve, reject) => {
fs.mkdir(OUTPUT_FOLDER, { recursive: true }, (err) => {
if (err) {
return reject(err);
}
resolve();
});
});
const pCopyFile = () => new Promise((resolve, reject) => {
const outputPath = path.join(OUTPUT_FOLDER, OUTPUT_NAME);
fs.copyFile(INPUT_PATH, outputPath, (err) => {
if (err) {
return reject(err);
}
resolve();
});
});
const pUnlink = () => new Promise((resolve, reject) => {
fs.unlink(INPUT_PATH, (err) => {
if (err) {
return reject(err);
}
resolve();
});
});
pStat()
.then((stats) => {
console.log(stats);
return pMkdir();
})
.then(() => {
return pCopyFile();
})
.then(() => {
return pUnlink();
})
.then(() => {
console.log("Done!");
})
.catch((err) => {
console.error(err);
});
以上程序可以改写为:
import fs = require("node:fs");
import path = require("node:path");
const INPUT_PATH = "input";
const OUTPUT_FOLDER = "folder";
const OUTPUT_NAME = "output";
const pStat = () => new Promise((resolve, reject) => {
fs.stat(INPUT_PATH, (err, stats) => {
if (err) {
return reject(err);
}
resolve(stats);
});
});
const pMkdir = () => new Promise((resolve, reject) => {
fs.mkdir(OUTPUT_FOLDER, { recursive: true }, (err) => {
if (err) {
return reject(err);
}
resolve();
});
});
const pCopyFile = () => new Promise((resolve, reject) => {
const outputPath = path.join(OUTPUT_FOLDER, OUTPUT_NAME);
fs.copyFile(INPUT_PATH, outputPath, (err) => {
if (err) {
return reject(err);
}
resolve();
});
});
const pUnlink = () => new Promise((resolve, reject) => {
fs.unlink(INPUT_PATH, (err) => {
if (err) {
return reject(err);
}
resolve();
});
});
async function main() {
try {
const stats = await pStat();
console.log(stats);
await pMkdir();
await pCopyFile();
await pUnlink();
console.log("Done!");
} catch (err) {
console.error(err);
}
}
main();
promisify
因为「async / await」要和 Promise 对象实体搭配使用,才能将异步程序撰写成「看起来同步」的代码,所以原先的异步程序必须要先转成 Promise 对象实体才行。
例如以下程序就是在做这件事情:
const pStat = () => new Promise((resolve, reject) => {
fs.stat(INPUT_PATH, (err, stats) => {
if (err) {
return reject(err);
}
resolve(stats);
});
});
虽然撰写这样的代码来制作 Promise 对象实体并不难,但数量一多的话也还是挺麻烦的。还好 Node.js 内置的 util 模块,有提供 promisify 函数,可以将任何最后一个参数的类型为 (err: any, value: any) => void 的函数作为 promisify 函数的第一个参数,promisify 函数就会回传用来产生其 Promise 对象实体的函数。此函数前面几个参数会变成 promisify 函数最后一个参数的函数的前面几个参数。
以下是一个完整的例子:
import fs = require("node:fs");
import path = require("node:path");
import util = require("node:util");
const INPUT_PATH = "input";
const OUTPUT_FOLDER = "folder";
const OUTPUT_NAME = "output";
const pStat = util.promisify(fs.stat);
const pMkdir = util.promisify(fs.mkdir);
const pCopyFile = util.promisify(fs.copyFile);
const pUnlink = util.promisify(fs.unlink);
async function main() {
try {
const stats = await pStat(INPUT_PATH);
console.log(stats);
await pMkdir(OUTPUT_FOLDER, { recursive: true });
const outputPath = path.join(OUTPUT_FOLDER, OUTPUT_NAME);
await pCopyFile(INPUT_PATH, outputPath);
await pUnlink(INPUT_PATH);
console.log("Done!");
} catch (err) {
console.error(err);
}
}
main();
有没有觉得当 TypeScript 代码写成以上这样后,顿时完全没有异步程序的影子了呢?
总结
JavaScript 的事件循环、回呼、Promise 和「async/await」语法是 JavaScript 编程语言观念中最难的部份,虽然这个系列文章主要是在学习 TypeScript,但我们还是花了三个章节(或四个章节,如果产生器那章也算的话)的篇幅来弄清楚它们,因为它们实在是很重要!
我们现在使用 Node.js 提供的模块时,都是先用 import 关键字来「假声明」要 require 的模块,再用 typeof 关键字来取得这个模块的定义,以便知道实际调用 require 函数时所回传的值的类型。然而这个方式用在 TypeScript 的编译目标是 ES6 或是以上的版本的情况下就会出问题。所以在下一章节中,我们要来学习 TypeScript 的模块系统,顺便解决掉这个问题。
下一章:模块。
