如何基于测试覆盖率报告自动移除JavaScript库中未使用代码？

Great question—this is a common challenge when dealing with large JS libraries, and the key here is fixing the coverage accuracy first before you can safely prune unused code. Let's walk through a step-by-step approach:

Your current coverage tool's flaws (ignoring closing brackets, marking method definition lines as executed even when the method isn't called) are dealbreakers—you can't trust pruning based on bad data. Here's how to fix this:

• Switch to AST-aware coverage tools: Ditch tools that rely on naive line counting. Use c8 (which leverages V8's native coverage, built into Node.js) instead of older Istanbul versions. V8's coverage tracks actual execution of AST nodes (like function bodies, not just their definition lines), so it won't mark a method as "used" just because the parser read its definition line.
• Validate coverage manually: Pick a handful of functions you know are never called by your tests, then check if the coverage report correctly flags them as unused. If issues persist, build a lightweight Babel plugin to inject custom execution markers: add a line like __trackExecution__('my-unique-function-id') at the start of every function body, then collect these IDs during test runs. This gives you 100% accurate data on which functions are actually invoked.
• Fix bracket counting issues: Most modern coverage tools handle JS syntax correctly, but if you're still seeing bracket-related errors, ensure your library uses valid, well-formed JS (no missing brackets, no weird minification artifacts). Running your code through a linter like ESLint first can catch syntax issues that throw off coverage tools.

Once your coverage data is reliable, you need to translate it into a clear map of what's actually used:

• Extract execution data: For c8, you can directly parse the coverage.json output file. It contains detailed entries for every file, including which functions, branches, and lines were executed. Focus on function coverage (not line coverage) to identify unused methods—this will ignore false positives from definition lines.
• Flag module-level side effects: JS libraries often have top-level code that runs immediately (like setting global variables, initializing configs) even if no functions are called. Use an AST parser (like Babel's parser) to scan for top-level expressions that aren't function/class declarations (e.g., window.MyLib = {}, IIFEs). These are likely necessary side effects—mark them as "keep" even if they don't show up in function coverage.
• Track dynamic references: If your library uses dynamic code (e.g., obj[dynamicKey](), eval()), your coverage tool might miss these. Add test cases that explicitly cover all dynamic paths, or manually audit these parts to ensure you don't prune code that's called indirectly.

With your usage map in hand, you can automate the pruning process using AST manipulation:

• Build a custom pruning script: Use Babel's API to traverse your library's AST. For each node (function, class, variable, branch), check if it's in your "used" list. If not, remove it from the AST. For example, a Babel visitor could target FunctionDeclaration nodes and skip generating code for any function not marked as executed.
• Prune dead branches: For IfStatement or SwitchCase nodes, if coverage shows a branch was never executed, remove that branch entirely. If all branches except one are unused, simplify the condition (e.g., turn if (false) { ... } else { ... } into just the else block).
• Iterate and validate: Prune in small batches, then run your full test suite after each pass. It's common to miss indirect dependencies (e.g., a utility function called by a used function but not flagged in coverage), so you'll need to adjust your usage map and re-prune until all tests pass.
• Handle exports: If your library exposes exports, make sure you only keep the exports that are actually used by your app. Use your coverage data to track which exports are imported/invoked, then strip the rest.

• Run full regression tests: Ensure your pruned library passes every test case—this confirms you haven't removed critical code.
• Manual spot-checks: Audit key workflows in your app to make sure nothing breaks (coverage tools can still miss edge cases).
• Minify (optional): Once you're confident the pruned code is correct, run it through Terser to remove comments, whitespace, and any remaining redundant code.

内容的提问来源于stack exchange，提问作者Oleg Mikhailov