Tree Shaking实现方法指南

时间：2023-03-09来源：系统城装机大师作者：佚名

当使用JavaScript框架或库时，代码中可能会存在许多未使用的函数和变量，这些未使用的代码会使应用程序的文件大小变大，从而影响应用程序的性能。Tree shaking可以解决这个问题，它可以通过检测和删除未使用的代码来减小文件大小并提高应用程序性能。

接下来我们将通过两种方式实现Tree shaking

方式一：JavaScript模拟

1、首先，你需要使用ES6模块来导出和导入代码。ES6模块可以静态分析，从而使Tree shaking技术成为可能。例如，在一个名为“math.js”的文件中，你可以使用以下代码来导出函数：

1
2
3
4
5
6
7
8
9 export function add(a, b) {
return a + b;
}
export function subtract(a, b) {
return a - b;
}
export function multiply(a, b) {
return a * b;
}

2、在应用程序入口处标记使用的代码: 在应用程序的入口处，你需要标记使用的代码。这可以通过创建一个名为"usedExports"的集合来实现，其中包含你在入口文件中使用的导出。

1 2	`import { add } from` `'./math.js';` `const usedExports =` `new` `Set([add]);`

在这个示例中，我们创建了一个名为"usedExports"的集合，并将我们在应用程序入口文件中使用的add函数添加到集合中。

3、遍历并检测未使用的代码: 在应用程序的所有模块中遍历导出并检查它们是否被使用。你可以使用JavaScript的反射API来实现这一点。以下是代码示例：

1
2
3
4
5
6
7
8 function isUsedExport(exportName) {
return usedExports.has(eval(exportName));
}
for (const exportName of Object.keys(exports)) {
if (!isUsedExport(exportName)) {
delete exports[exportName];
}
}

在这个示例中，我们定义了一个isUsedExport函数来检查是否使用了给定的导出名称。然后，我们遍历应用程序中的所有导出，并将每个导出的名称作为参数传递给isUsedExport函数。如果导出没有被使用，则从exports对象中删除该导出。

4、最后，我们需要在控制台中调用一些函数以确保它们仍然可以正常工作。由于我们只在"usedExports"集合中添加了add函数，因此subtract()和multiply()函数已经被删除了。

方式二：利用AST实现

假设我们有以下的 source 代码：

1
2
3
4
5 import { sum } from './utils';
export function add(a, b) {
return sum(a, b);
}
export const PI = 3.14;

我们首先需要使用 @babel/parser 将源代码解析成 AST：

1
2
3
4
5
6 const parser = require("@babel/parser");
const fs = require("fs");
const sourceCode = fs.readFileSync("source.js", "utf8");
const ast = parser.parse(sourceCode, {
sourceType: "module",
});

接着，我们需要遍历 AST 并找到所有被使用的导出变量和函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49 // 创建一个 Set 来保存被使用的导出
const usedExports = new Set();
// 标记被使用的导出
function markUsedExports(node) {
if (node.type === "Identifier") {
usedExports.add(node.name);
} else if (node.type === "ExportSpecifier") {
usedExports.add(node.exported.name);
}
}
// 遍历 AST 树并标记被使用的导出
function traverse(node) {
if (node.type === "CallExpression") {
markUsedExports(node.callee);
node.arguments.forEach(markUsedExports);
} else if (node.type === "MemberExpression") {
markUsedExports(node.property);
markUsedExports(node.object);
} else if (node.type === "Identifier") {
usedExports.add(node.name);
} else if (node.type === "ExportNamedDeclaration") {
if (node.declaration) {
if (node.declaration.type === "FunctionDeclaration") {
usedExports.add(node.declaration.id.name);
} else if (node.declaration.type === "VariableDeclaration") {
node.declaration.declarations.forEach((decl) => {
usedExports.add(decl.id.name);
});
}
} else {
node.specifiers.forEach((specifier) => {
usedExports.add(specifier.exported.name);
});
}
} else if (node.type === "ImportDeclaration") {
node.specifiers.forEach((specifier) => {
usedExports.add(specifier.local.name);
});
} else {
for (const key of Object.keys(node)) {
// 遍历对象的属性，如果属性的值也是对象，则递归调用 traverse 函数
if (key !== "loc" && node[key] && typeof node[key] === "object") {
traverse(node[key]);
}
}
}
}
// 遍历整个 AST 树
traverse(ast);

在这里，我们创建了一个 Set 来保存被使用的导出，然后遍历 AST 树并标记被使用的导出。具体来说，我们会：

标记被调用的函数；
标记被访问的对象属性；
标记被直接引用的变量和函数；
标记被导出的变量和函数；
标记被导入的变量和函数。

我们通过遍历 AST 树并调用 markUsedExports 函数来标记被使用的导出，最终将这些导出保存在 usedExports Set 中。

接下来，我们需要遍历 AST 并删除未被使用的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71 // 移除未使用的代码
function removeUnusedCode(node) {
// 处理函数声明
if (node.type === "FunctionDeclaration") {
if (!usedExports.has(node.id.name)) { // 如果该函数未被使用
node.body.body = []; // 将该函数体清空
}
}
// 处理变量声明
else if (node.type === "VariableDeclaration") {
node.declarations = node.declarations.filter((decl) => {
return usedExports.has(decl.id.name); // 过滤出被使用的声明
});
if (node.declarations.length === 0) { // 如果没有被使用的声明
node.type = "EmptyStatement"; // 将该声明置为 EmptyStatement
}
}
// 处理导出声明
else if (node.type === "ExportNamedDeclaration") {
if (node.declaration) {
// 处理函数导出声明
if (node.declaration.type === "FunctionDeclaration") {
if (!usedExports.has(node.declaration.id.name)) { // 如果该函数未被使用
node.declaration.body.body = []; // 将该函数体清空
}
}
// 处理变量导出声明
else if (node.declaration.type === "VariableDeclaration") {
node.declaration.declarations = node.declarations.filter((decl) =>
return usedExports.has(decl.id.name); // 过滤出被使用的声明
});
if (node.declaration.declarations.length === 0) { // 如果没有被使用的声明
node.type = "EmptyStatement"; // 将该声明置为 EmptyStatement
}
} else {
// 处理导出的具体内容
node.specifiers = node.specifiers.filter((specifier) => {
return usedExports.has(specifier.exported.name); // 过滤出被使用的内容
});
if (node.specifiers.length === 0) { // 如果没有被使用的内容
node.type = "EmptyStatement"; // 将该声明置为 EmptyStatement
}
}
}
// 处理导入声明
else if (node.type === "ImportDeclaration") {
node.specifiers = node.specifiers.filter((specifier) => {
return usedExports.has(specifier.local.name); // 过滤出被使用的声明
});
if (node.specifiers.length === 0) { // 如果没有被使用的声明
node.type = "EmptyStatement"; // 将该声明置为 EmptyStatement
}
}
// 处理表达式语句
else if (node.type === "ExpressionStatement") {
if (node.expression.type === "AssignmentExpression") {
if (!usedExports.has(node.expression.left.name)) { // 如果该表达式未被使用
node.type = "EmptyStatement"; // 将该语句置为 EmptyStatement
}
}
}
// 处理其他情况
else {
for (const key of Object.keys(node)) {
if (key !== "loc" && node[key] && typeof node[key] === "object") {
removeUnusedCode(node[key]); // 递归处理子节点
}
}
}
}
removeUnusedCode(ast); // 执行移除未使用代码的

在这里，我们遍历 AST 并删除所有未被使用的代码。具体地，我们会：

删除未被使用的函数和变量的函数体和声明语句；
删除未被使用的导出和导入声明；
删除未被使用的赋值语句。

最后，我们将修改后的 AST 重新转换回 JavaScript 代码：

1
2
3
4
5 const { transformFromAstSync } = require("@babel/core");
const { code } = transformFromAstSync(ast, null, {
presets: ["@babel/preset-env"],
});
console.log(code);