如何让Google Closure Compiler正确优化Node.js命令行JS工具？

I've run into this exact issue before when using Closure Compiler with Node.js CLI tools. The problem here is that Closure Compiler doesn't natively recognize Node.js's global objects like process and console by default—so in ADVANCED compilation mode, it treats them as undefined globals, renames their properties (since it thinks they're arbitrary object keys), and strips calls it deems "unused" (like console.log).

Here's how to fix this properly, with two reliable approaches:

Approach 1: Use Closure's Built-in Node.js Environment Preset #

Closure Compiler has a dedicated NODE environment flag that automatically loads official Node.js externs and adjusts its behavior for the Node.js runtime. This is the simplest solution:

1. Update your closure.conf:
   Replace --env CUSTOM with --env NODE. Your config should look like this:

   --compilation_level=ADVANCED
   --env NODE
   --language_in=ECMASCRIPT5_STRICT
   --language_out=ECMASCRIPT5_STRICT
   --warning_level=VERBOSE
   --error_format=STANDARD
   --strict_mode_input
   --dependency_mode=NONE
   --rewrite_polyfills=false
   --module_resolution=NODE
   --jscomp_off=checkVars
   --package_json_entry_names es2015
   --process_common_js_modules
   

2. Re-run your compilation command:
   The same command you used before will now work correctly:

   java -jar path/to/closure/compiler.jar --flagfile ./closure.conf --js main.js --js_output_file bundle.js
   

This flag tells Closure Compiler that it's targeting a Node.js environment, so it will:

• Recognize process, console, and other Node.js globals as external resources (no property renaming)
• Preserve calls to console.log and other Node.js API methods
• Handle CommonJS modules correctly alongside Node.js globals

Approach 2: Define Custom Externs (For Fine-Grained Control) #

If you need more control over which Node.js APIs are recognized, you can create a custom externs file to explicitly declare the globals and their methods/properties. This mimics the "header file" behavior you mentioned (like C/C++ headers or Java imports):

1. Create a node-externs.js file:

   /**
    * Externs for Node.js core globals
    * @externs
    */
   
   /** @type {Object} */
   var process;
   
   /** @type {function(string): void} */
   process.chdir;
   
   /** @type {Array<string>} */
   process.argv;
   
   /** @type {Object} */
   var console;
   
   /** @type {function(...*): void} */
   console.log;
   

   This tells Closure Compiler that process and console are global objects with the specified methods/properties, so it won't rename or remove references to them.

2. Update your compilation command:
   Add the --externs flag to reference your externs file:

   java -jar path/to/closure/compiler.jar --flagfile ./closure.conf --js main.js --externs node-externs.js --js_output_file bundle.js
   

Expected Result #

After making either change, your compiled bundle.js should preserve all the original behavior without incorrect renaming or stripping:

'use strict';console.log("test");process.chdir("/");console.log("arg: "+JSON.stringify(process.argv));

The key takeaway is that Closure Compiler needs explicit hints about external globals that aren't part of its standard library. Using the --env NODE preset is the easiest way to get full Node.js support, while custom externs let you tailor the rules to your specific use case.

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