我们先前所练习的 TypeScript 程序几乎都只是把程序叙述写在 index.ts 文件中,虽然我们已经会使用函数、类别来分割不同功能的程序,但当程序愈写愈多的时候,这样的作法还是会让程序变得难以维护。这时就需要用到 TypeScript 提供的「模块」系统了。
浅谈 JavaScript 的模块系统
试想一下,若要在一个网页中加入很多个 JavaScript 文件进来,每个 JavaScript 文件都是一个 JavaScript 模块,都拥有独立的功能。这些 JavaScript 文件要怎么样撰写才不会被彼此影响?
举例来说,a.js 文件提供了一个 f 函数,b.js 文件也提供了一个 f 函数。
function f() {
console.log("A");
}
function f() {
console.log("B");
}
那么以下网页中的 JavaScript 程序应该会怎么运行?
<!DOCTYPE html>
<html>
<head>
<meta charset=UTF-8>
<script src="a.js"></script>
<script src="b.js"></script>
</head>
<body>
<script>
f();
</script>
</body>
</html>
答案是,当浏览器加载以上 HTML 的第 10 行时,最后(最近)被加载的 f 函数会被运行到。以上网页,b.js 文件会比 a.js 文件还要晚被加载,所以会运行到 b.js 文件的 f 函数。
但如果将网页改成:
<!DOCTYPE html>
<html>
<head>
<meta charset=UTF-8>
<script src="a.js"></script>
<script src="b.js" defer></script>
</head>
<body>
<script>
f();
</script>
</body>
</html>
以上网页,当浏览器加载以上 HTML 的第 10 行时,最后(最近)被加载的 f 函数是 a.js 文件的 f 函数,因为 b.js 文件被加上 defer 属性,它需要等到整个网页都读取完成后才会被加载。
由此可见,以上的 a.js 文件和 b.js 文件是会互相影响的,所以我们需要用不同的方式来实作它们的程序才行。最直觉的方式,就是将每个模块中的内容都用一层函数包起来,然后把要暴露(export)出去的属性都放进一个对象回传出来,再把这个对象指派给一个变量来保存,该变量的名称便是模块名称。
例如:
function aFunction() {
return {
f: function f() {
console.log("A");
}
};
}
var A = aFunction();
function bFunction() {
return {
f: function f() {
console.log("B");
}
};
}
var B = bFunction();
<!DOCTYPE html>
<html>
<head>
<meta charset=UTF-8>
<script src="a.js"></script>
<script src="b.js"></script>
</head>
<body>
<script>
A.f();
B.f();
</script>
</body>
</html>
以上的作法,可不理会 a.js 文件和 b.js 文件的加载顺序,因为两个 f 函数此时已有各自的「命名空间」(namespace),并不会发生冲突。
事实上,我们还可以将 aFunction 函数和 bFunction 函数「匿名化」,如下:
var A = (function () {
return {
f: function f() {
console.log("A");
}
};
})();
var B = (function () {
return {
f: function f() {
console.log("B");
}
};
})();
这样的函数又被称为「立即被调用的函数」(Immediately Invoked Function Expression, IIFE),可以确保原先的 aFunction 函数和 bFunction 函数不能直接被外部程序调用,也不会与外部程序发生冲突。这种 JavaScript 的模块撰写方式称为「模块样式」(Module Pattern)。
不过「模块样式」顶多就是切分命名空间罢了,并无法处理模块与模块之间的相依关系(如重复引用等)。所以后来 JavaScript 生态圈又演化出了 CommonJS 和 AMD (Asynchronous Module Definition)两种主要的模块系统,前者直接被 Node.js 内置(我们在前面的章节用的 require 函数就是 CommonJS 的东西),后者则是可以在网页浏览器引用额外的 JavaScript 文件来支持。
ES6 出来之后,使用 TypeScript 来开发 JavaScript 程序,可以完全抛开模块样式、CommonJS 和 AMD,因为 TypeScript 可以直接将 ES6 的模块系统编译成其它的模块系统。换句话说,我们只需要学会 ES6 的模块系统就好了!
ES6 的模块系统
export 关键字
利用 ES6 之后加入的 export 关键字,我们可以将一个 TypeScript 的 .ts 文件变成一个 TypeScript 模块。export 关键字可以被用在最外层的 var、let、const、function、class、interface、enum、type 关键字前,使该项目暴露到模块外(换句话说就是可以被模块外的程序使用)。
例如:
export function f() {
console.log("A");
}
export 关键字也可以不必与上述的 var、let 等关键字搭配使用,而是可以直接在其后接上一组大括号 {},来放入要暴露的名称,如果有多个名称就用逗号 , 隔开。
例如:
export function f() {
console.log("A1");
}
function f2() {
console.log("A2");
}
function f3() {
console.log("A3");
}
function f4() {
console.log("A4");
}
export {
f2
};
export {
f3,
f4,
};
这边要注意的是,export 关键字在一个 .ts 文件中是可以被使用多次的!
如果要改变暴露出去的名称,可以在大括号 {} 中用 as 关键字来设置,设置方式如下:
export function f() {
console.log("A1");
}
function f2() {
console.log("A2");
}
function f3() {
console.log("A3");
}
function f4() {
console.log("A4");
}
export {
f2 as ff
};
export {
f3 as fff,
f4 as ffff,
};
import 关键字
我们在前面的章节学的 import 关键字用法其实并不属于 ES6 的用法,而是 TypeScript 针对 ES5 以下使用 CommonJS 模块系统提供的用法,姑且先把它忘了吧!
利用 ES6 之后加入的 import 关键字,我们可以在 TypeScript 中引用 TypeScript(或是具有 TypeScript 的 .d.ts 定义档的 JavaScript)的模块。
引用方式如下:
import * as 自定义模块名称 from "模块文件路径(不含.ts扩展名)";
注意这边的路径,如果是相对路径的话,要用 ./ 或 ../ 来开头,不然会被当作是要引用 JavaScript 环境中的模块。
例如以下这个 a.ts:
export function f() {
console.log("A1");
}
function f2() {
console.log("A2");
}
function f3() {
console.log("A3");
}
function f4() {
console.log("A4");
}
export { f2 as ff };
export {
f3 as fff,
f4 as ffff,
};
可以这样来引用:
import * as A from "./a";
A.f();
A.ff();
A.fff();
A.ffff();
由于 Node.js 尚未完整支持 ES6 的模块系统,因此如果 TypeScript 的编译目标是设置为 ES6 或是以上的版本的话,还需要在 tsconfig.json 设置档中的 compilerOptions 字段中加上 module 字段,并将字段值设为 CommonJS 字符串,才能够让编译出来的 JavaScript 模块在 Node.js 中正常使用。
以上程序运行时会输出:
A2
A3
A4
提醒一下,这边的引用 a.ts 文件的路径是填 ./a,而不是 a。另外,我们不需要将 a.ts 加进 tsconfig.json 设置档中的 files 字段的数组中,因为 TypeScript 会自动编译 import 关键字引用的 .ts 文件。
如果我们只是想引用模块中的部份项目的话,可以将 * as 自定义模块名称 改写为一组大括号 {},里面填入要引用的名称,如果有多个名称就用逗号 , 隔开。
例如:
import { f, ff } from "./a";
f();
ff();
如果想要改变名称,就使用 as 关键字,用法如下:
import { f as f1, ff as f2 } from "./a";
f1();
f2();
import 关键字也可以用来引用非模块的 TypeScript 文件。
例如以下这个 b.ts:
function f() {
console.log("B");
}
f();
可以这样来引用:
import "./b";
这边要注意的是,在 index.ts 中,是无法调用 b.ts 的 f 函数的哦!另外,像这样 import 关键字没有搭配 from 关键字来使用时,除了能够引用任何的(模块或是非模块)TypeScript 程序外,还可以引用任何的 JavaScript 程序。
重复暴露(Re-export)
export 关键字也可以搭配 from 关键字来用,可以直接将指定的模块提供的名称再暴露出去,无法直接用 * as 自定义模块名称。例如:
import { f as f1, ff as f2 } from "./a";
export { fff as f3, ffff as f4 } from "./a";
f1();
f2();
如果想要将整个模块更换名称后再暴露,要写成以下这个样子:
import { f as f1, ff as f2 } from "./a";
import * as A from "./a";
f1();
export { A };
预设暴露(Default Export)
作用在 function 关键字前或是 class 关键字前的 export 关键字,其后可以加上 default 关键字,来将该函数或是类别当作预设的暴露对象。一个 TypeScript 模块只能有一个预设的暴露对象。
例如:
export function f() {
console.log("A");
}
替函数 f 加上 default 关键字,如下:
export default function f() {
console.log("A");
}
当我们要引用 TypeScript 模块的预设暴露对象时,就用如下的 import 关键字语法:
import f from "./a";
f();
再举一个例子:
export default function f() {
console.log("A1");
}
function f2() {
console.log("A2");
}
function f3() {
console.log("A3");
}
function f4() {
console.log("A4");
}
export { f2 as ff };
export {
f3 as fff,
f4 as ffff,
};
import * as A from "./a";
import f from "./a";
f();
A.ff();
A.fff();
A.ffff();
注意这边由于 a.ts 的函数 f 是用 export default 来暴露,因此它在 index.ts 的 A 模块名称之下的名称是 default(要用 A.default() 来调用),而不是 f。
除了函数和类别之外,export default 关键字也可以用在定数或者任意名称上。
例如:
export default "magiclen.org";
import m from "./c";
console.log(m);
以上程序会输出 magiclen.org。
再例如:
const n = 123456;
export default n;
import m from "./c";
console.log(m);
以上程序会输出 123456。
在网页上使用 TypeScript 编译出来的 JavaScript 模块
现在有以下两个文件:
export function f() {
console.log("A");
}
export function f() {
console.log("B");
}
ES6 模块系统
若将 a.ts 和 b.ts 文件编译成 ES6 的 JavaScript 模块,要如何直接在网页浏览器上使用它们呢?请看以下的 HTML 网页范例:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8"/>
</head>
<body>
<script type="module">
import * as A from "./a.js";
import * as B from "./b.js";
A.f();
B.f();
</script>
</body>
</html>
在 HTML 网页中添加 script 元素,并加上 type="module" 属性,接着就可以在这个 script 元素中撰写 ES6 的 JavaScript 程序了。直接用 import 关键字即可引用 JavaScript 模块。
AMD 模块系统
若要使网页兼容比较旧,不支持 ES6 的网页浏览器,可以将 a.ts 和 b.ts 文件编译成 AMD 的 JavaScript 模块,只要修改 tsconfig.json 设置文件中 compilerOptions 字段的 module 字段的值为 AMD 字符串即可。当然,记得也要将编译目标改为 ES5 或是以下的版本。
如何在网页浏览器上使用 AMD 的 JavaScript 模块呢?请看以下的 HTML 网页范例:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8"/>
<script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.6/require.min.js"></script>
</head>
<body>
<script>
requirejs(["./a.js", "./b.js"], function(A, B) {
A.f();
B.f();
});
</script>
</body>
</html>
利用 require.min.js 提供的 requirejs 函数,可以帮我们引用 AMD 的 JavaScript 模块。
UMD (Universal Module Definition) 模块系统
理想的 UMD 模块应该要可以同时支持 CommonJS、AMD 以及 root( 即网页浏览器的 window 或 Node.js 的 global),所以若将 a.ts 和 b.ts 文件编译成 UMD 的 JavaScript 模块,它们应该要可以像以下这样来被使用:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8"/>
<script src="a.js"></script>
<script src="b.js"></script>
</head>
<body>
<script>
A.f();
B.f();
</script>
</body>
</html>
不过现阶段的 TypeScript 尚未实作这部份的功能,这个 issue 也还在讨论当中,咱们就先等等吧!
替任意 JavaScript 模块加上 TypeScript 的 .d.ts 文件
TypeScript 的 import 与 from 关键字无法直接引用 JavaScript 模块,它必须要有 .d.ts 文件才行。
例如以下这个 JavaScript 模块:
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function f() {
console.log('A');
}
exports.f = f;
我们若想要将 a.js 引用至 TypeScript 程序中,就必须要先撰写正确的 a.d.ts 文件。内容如下:
export declare function f(): void;
TypeScript 官方有提供 .d.ts 文件的自动产生工具,有兴趣的读者们可以参考看看。
替 TypeScript 编译出来的 JavaScript 模块加上 .d.ts 文件
如果需要让 TypeScript 在编译程序的时候顺便产生出 .d.ts 文件,可以修改 tsconfig.json 设置文件中 compilerOptions 字段的 declaration 字段的值为 true。如此一来,被编译到的 .ts 文件都会产生出 .d.ts 文件。
用 ES6 的 import 关键字来引用 Node.js 的模块
至此我们已经学会了 ES6 的 import 关键字的用法了!来看看上一章提供的例子:
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();
在先前的章节有提到,import fs = require("node:fs"); 这样的 import 关键字用法用于 TypeScript 的编译目标是设为 ES6 或是以上的版本时会有问题,这是因为当我们把 TypeScript 的编译目标设为 ES6 或是以上的版本时,module 字段的默认值会变成 ES6。由于 ES6 的 import 关键字并不能被这样使用,所以就会导致程序编译失败。若要解决这个问题,只需要明确设置 module 字段的值为 CommonJS 等别种模块系统就好了。
不过我们既然已经学会 ES6 的模块系统了,就应该要尽量去用它。以上程序可以用 ES6 的 import 关键字修改成这样:
import * as fs from "node:fs";
import * as path from "node:path";
import * as util from "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 的模块制作和引用的方式。下一个章节要来介绍 TypeScript 提供的命名空间(namespace)功能。
下一章:命名空间(namespace)。
