Awesome 社區模塊

UglifyJS 3

UglifyJS is a JavaScript parser, minifier, compressor and beautifier toolkit.

Note:

  • uglify-js@3has a simplifieduglify-js@2
  • Documentation for UglifyJS2.x
  • uglify-js only supports JavaScript (ECMAScript 5).
  • To minify ECMAScript 2015 or above, transpile using tools like

Install

First make sure you have installed the latest version of

From NPM for use as a command line app:

1
npm install uglify-js -g

From NPM for programmatic use:

1
npm install uglify-js

Command line usage

1
uglifyjs [input files] [options]

UglifyJS can take multiple input files. It's recommended that you pass the input files first, then pass the options. UglifyJS will parse input files in sequence and apply any compression options. The files are parsed in the same global scope, that is, a reference from a file to some variable/function declared in another file will be matched properly.

If no input file is specified, UglifyJS will read from STDIN.

If you wish to pass your options before the input files, separate the two with a double dash to prevent input files being used as option arguments:

1
uglifyjs --compress --mangle -- input.js

Command line options

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 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
-h, --help Print usage information. `--help options` for details on available options. -V, --version Print version number. -p, --parse <options> Specify parser options: `acorn` Use Acorn for parsing. `bare_returns` Allow return outside of functions. Useful when minifying CommonJS modules and Userscripts that may be anonymous function wrapped (IIFE) by the .user.js engine `caller`. `expression` Parse a single expression, rather than a program (for parsing JSON). `spidermonkey` Assume input files are SpiderMonkey AST format (as JSON). -c, --compress [options] Enable compressor/specify compressor options: `pure_funcs` List of functions that can be safely removed when their return values are not used. -m, --mangle [options] Mangle names/specify mangler options: `reserved` List of names that should not be mangled. --mangle-props [options] Mangle properties/specify mangler options: `builtins` Mangle property names that overlaps with standard JavaScript globals. `debug` Add debug prefix and suffix. `domprops` Mangle property names that overlaps with DOM properties. `keep_quoted` Only mangle unquoted properties. `regex` Only mangle matched property names. `reserved` List of names that should not be mangled. -b, --beautify [options] Beautify output/specify output options: `beautify` Enabled with `--beautify` by default. `preamble` Preamble to prepend to the output. You can use this to insert a comment, for example for licensing information. This will not be parsed, but the source map will adjust for its presence. `quote_style` Quote style: 0 - auto 1 - single 2 - double 3 - original `wrap_iife` Wrap IIFEs in parenthesis. Note: you may want to disable `negate_iife` under compressor options. -o, --output <file> Output file path (default STDOUT). Specify `ast` or `spidermonkey` to write UglifyJS or SpiderMonkey AST as JSON to STDOUT respectively. --comments [filter] Preserve copyright comments in the output. By default this works like Google Closure, keeping JSDoc-style comments that contain "@license" or "@preserve". You can optionally pass one of the following arguments to this flag: - "all" to keep all comments - a valid JS RegExp like `/foo/` or `/^!/` to keep only matching comments. Note that currently not *all* comments can be kept when compression is on, because of dead code removal or cascading statements into sequences. --config-file <file> Read `minify()` options from JSON file. -d, --define <expr>[=value] Global definitions. --ie8 Support non-standard Internet Explorer 8. Equivalent to setting `ie8: true` in `minify()` for `compress`, `mangle` and `output` options. By default UglifyJS will not try to be IE-proof. --keep-fnames Do not mangle/drop function names. Useful for code relying on Function.prototype.name. --name-cache <file> File to hold mangled name mappings. --self Build UglifyJS as a library (implies --wrap UglifyJS) --source-map [options] Enable source map/specify source map options: `base` Path to compute relative paths from input files. `content` Input source map, useful if you're compressing JS that was generated from some other original code. Specify "inline" if the source map is included within the sources. `filename` Name and/or location of the output source. `includeSources` Pass this flag if you want to include the content of source files in the source map as sourcesContent property. `root` Path to the original source to be included in the source map. `url` If specified, path to the source map to append in `//# sourceMappingURL`. --timings Display operations run time on STDERR. --toplevel Compress and/or mangle variables in top level scope. --verbose Print diagnostic messages. --warn Print warning messages. --wrap <name> Embed everything in a big function, making the “exports” and “global” variables available. You need to pass an argument to this option to specify the name that your module will take when included in, say, a browser.

Specify--output-o

CLI source map options

UglifyJS can generate a source map file, which is highly useful for debugging your compressed JavaScript. To get a source map, pass--source-map --output output.jsoutput.js.map

Additional options:

  • --source-map "filename='<NAME>'" to specify the name of the source map.

  • --source-map "root='<URL>'" to pass the URL where the original files can be found.

  • --source-map "url='<URL>'"to specify the URL where the source map can be found. Otherwise UglifyJS assumes HTTPX-SourceMap//# sourceMappingURL=

For example:

1 2 3
uglifyjs js/file1.js js/file2.js \ -o foo.min.js -c -m \ --source-map "root='http://foo.com/src',url='foo.min.js.map'"

The above will compress and manglefile1.jsfile2.jsfoo.min.jsfoo.min.js.maphttp://foo.com/src/js/file1.jshttp://foo.com/src/js/file2.jshttp://foo.com/srcjs/file1.jsjs/file2.js

Composed source map

When you're compressing JS code that was output by a compiler such as CoffeeScript, mapping to the JS code won't be too helpful. Instead, you'd like to map back to the original code (ie CoffeeScript). UglifyJS has an option to take an input source map. Assuming you have a mapping from CoffeeScript → compiled JS, UglifyJS can generate a map from CoffeeScript → compressed JS by mapping every token in the compiled JS to its original location.

To use this feature pass--source-map "content='/path/to/input/source.map'"--source-map "content=inline"

CLI compress options

You need to pass--compress-c

Options are in the formfoo=barfootruefoo=true

Example:

1
uglifyjs file.js -c toplevel,sequences=false

CLI mangle options

To enable the mangler you need to pass--mangle-m

  • toplevel(defaultfalse

  • eval(defaultfalseevalwith

When mangling is enabled but you want to prevent certain names from being mangled, you can declare those names with--mangle reserved

1
uglifyjs ... -m reserved=['$','require','exports']

to prevent therequireexports$

CLI mangling property names (--mangle-props

Note:--mangle-props

1 2 3 4 5 6 7 8 9 10 11
// example.js var x = { baz_: 0, foo_: 1, calc: function() { return this.foo_ + this.baz_; } }; x.bar_ = 2; x["baz_"] = 3; console.log(x.calc());

Mangle all properties (except for JavaScriptbuiltins

1
$ uglifyjs example.js -c -m --mangle-props
1
var x={o:0,_:1,l:function(){return this._+this.o}};x.t=2,x.o=3,console.log(x.l());

Mangle all properties except forreserved

1
$ uglifyjs example.js -c -m --mangle-props reserved=[foo_,bar_]
1
var x={o:0,foo_:1,_:function(){return this.foo_+this.o}};x.bar_=2,x.o=3,console.log(x._());

Mangle all properties matching aregex

1
$ uglifyjs example.js -c -m --mangle-props regex=/_$/
1
var x={o:0,_:1,calc:function(){return this._+this.o}};x.l=2,x.o=3,console.log(x.calc());

Combining mangle properties options:

1
$ uglifyjs example.js -c -m --mangle-props regex=/_$/,reserved=[bar_]
1
var x={o:0,_:1,calc:function(){return this._+this.o}};x.bar_=2,x.o=3,console.log(x.calc());

In order for this to be of any use, we avoid mangling standard JS names by default (--mangle-props builtins

A default exclusion file is provided intools/domprops.json--mangle-props domprops

A regular expression can be used to define which property names should be mangled. For example,--mangle-props regex=/^_/

When you compress multiple files using this option, in order for them to work together in the end we need to ensure somehow that one property gets mangled to the same name in all of them. For this, pass--name-cache filename.json

1 2 3
$ rm -f /tmp/cache.json # start fresh $ uglifyjs file1.js file2.js --mangle-props --name-cache /tmp/cache.json -o part1.js $ uglifyjs file3.js file4.js --mangle-props --name-cache /tmp/cache.json -o part2.js

Now,part1.jspart2.js

Using the name cache is not necessary if you compress all your files in a single call to UglifyJS.

Mangling unquoted names (--mangle-props keep_quoted

Using quoted property name (o["foo"]fooo.foo

1 2 3 4 5 6 7
// stuff.js var o = { "foo": 1, bar: 3 }; o.foo += o.bar; console.log(o.foo);
1
$ uglifyjs stuff.js --mangle-props keep_quoted -c -m
1
var o={foo:1,o:3};o.foo+=o.o,console.log(o.foo);

Debugging property name mangling

You can also pass--mangle-props debugo.fooo._$foo$_

1
$ uglifyjs stuff.js --mangle-props debug -c -m
1
var o={_$foo$_:1,_$bar$_:3};o._$foo$_+=o._$bar$_,console.log(o._$foo$_);

You can also pass a custom suffix using--mangle-props debug=XYZo.fooo._$foo$XYZ_

API Reference

Assuming installation via NPM, you can load UglifyJS in your application like this:

1
var UglifyJS = require("uglify-js");

There is a single high level function,minify(code, options)minify()compressmangle

1 2 3 4
var code = "function add(first, second) { return first + second; }"; var result = UglifyJS.minify(code); console.log(result.error); // runtime error, or `undefined` if no error console.log(result.code); // minified output: function add(n,d){return n+d}

You canminify

1 2 3 4 5 6 7
var code = { "file1.js": "function add(first, second) { return first + second; }", "file2.js": "console.log(add(1 + 2, 3 + 4));" }; var result = UglifyJS.minify(code); console.log(result.code); // function add(d,n){return d+n}console.log(add(3,7));

Thetoplevel

1 2 3 4 5 6 7 8
var code = { "file1.js": "function add(first, second) { return first + second; }", "file2.js": "console.log(add(1 + 2, 3 + 4));" }; var options = { toplevel: true }; var result = UglifyJS.minify(code, options); console.log(result.code); // console.log(3+7);

ThenameCache

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
var options = { mangle: { toplevel: true, }, nameCache: {} }; var result1 = UglifyJS.minify({ "file1.js": "function add(first, second) { return first + second; }" }, options); var result2 = UglifyJS.minify({ "file2.js": "console.log(add(1 + 2, 3 + 4));" }, options); console.log(result1.code); // function n(n,r){return n+r} console.log(result2.code); // console.log(n(3,7));

You may persist the name cache to the file system in the following way:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
var cacheFileName = "/tmp/cache.json"; var options = { mangle: { properties: true, }, nameCache: JSON.parse(fs.readFileSync(cacheFileName, "utf8")) }; fs.writeFileSync("part1.js", UglifyJS.minify({ "file1.js": fs.readFileSync("file1.js", "utf8"), "file2.js": fs.readFileSync("file2.js", "utf8") }, options).code, "utf8"); fs.writeFileSync("part2.js", UglifyJS.minify({ "file3.js": fs.readFileSync("file3.js", "utf8"), "file4.js": fs.readFileSync("file4.js", "utf8") }, options).code, "utf8"); fs.writeFileSync(cacheFileName, JSON.stringify(options.nameCache), "utf8");

An example of a combination ofminify()

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
var code = { "file1.js": "function add(first, second) { return first + second; }", "file2.js": "console.log(add(1 + 2, 3 + 4));" }; var options = { toplevel: true, compress: { global_defs: { "@console.log": "alert" }, passes: 2 }, output: { beautify: false, preamble: "/* uglified */" } }; var result = UglifyJS.minify(code, options); console.log(result.code); // /* uglified */ // alert(10);"

To produce warnings:

1 2 3 4 5 6
var code = "function f(){ var u; return 2 + 3; }"; var options = { warnings: true }; var result = UglifyJS.minify(code, options); console.log(result.error); // runtime error, `undefined` in this case console.log(result.warnings); // [ 'Dropping unused variable u [0:1,18]' ] console.log(result.code); // function f(){return 5}

An error example:

1 2 3
var result = UglifyJS.minify({"foo.js" : "if (0) else console.log(1);"}); console.log(JSON.stringify(result.error)); // {"message":"Unexpected token: keyword (else)","filename":"foo.js","line":1,"col":7,"pos":7}

Note: unlike, the

1 2
var result = UglifyJS.minify(code, options); if (result.error) throw result.error;

Minify options

  • warnings(defaultfalsetrueresult.warnings"verbose"

  • parse(default{}

  • compress(default{}false

  • mangle(defaulttruefalse

    • mangle.properties(defaultfalse
  • output(defaultnull

  • sourceMap(defaultfalse

  • toplevel(defaultfalsetrue

  • nameCache(defaultnull{}nameCacheminify()minify()

  • ie8(defaultfalsetrue

  • keep_fnames(default:falsetrueFunction.prototype.name

Minify options structure

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
{ parse: { // parse options }, compress: { // compress options }, mangle: { // mangle options properties: { // mangle property options } }, output: { // output options }, sourceMap: { // source map options }, nameCache: null, // or specify a name cache object toplevel: false, ie8: false, warnings: false, }

Source map options

To generate a source map:

1 2 3 4 5 6 7 8
var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, { sourceMap: { filename: "out.js", url: "out.js.map" } }); console.log(result.code); // minified output console.log(result.map); // source map

Note that the source map is not saved in a file, it's just returned inresult.mapsourceMap.url//# sourceMappingURL=out.js.mapresult.codefilenamefile

You can set optionsourceMap.url"inline"

You can also specify sourceRoot property to be included in source map:

1 2 3 4 5 6
var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, { sourceMap: { root: "http://example.com/src", url: "out.js.map" } });

If you're compressing compiled JavaScript and have a source map for it, you can usesourceMap.content

1 2 3 4 5 6 7
var result = UglifyJS.minify({"compiled.js": "compiled code"}, { sourceMap: { content: "content from compiled.js.map", url: "minified.js.map" } }); // same as before, it returns `code` and `map`

If you're using theX-SourceMapsourceMap.url

Parse options

  • bare_returns(defaultfalsereturn

  • html5_comments(defaulttrue

  • shebang(defaulttrue#!command

Compress options

  • arguments(default:truearguments[index]

  • booleans(default:true!!a ? b : c → a ? b : c

  • collapse_vars(default:true

  • comparisons(default:true!(a <= b) → a > ba = !b && !c && !d && !e → a=!(b||c||d||e)

  • conditionals(default:trueif

  • dead_code(default:true

  • drop_console(default:falsetrueconsole.*console.infopure_funcs

  • drop_debugger(default:truedebugger;

  • evaluate(default:true

  • expression(default:falsetruereturn

  • global_defs(default:{}

  • hoist_funs(default:false

  • hoist_props(default:truevar o={p:1, q:2}; f(o.p, o.q);f(1, 2);hoist_propsmanglecompresspasses2compresstoplevel

  • hoist_vars(default:falsevarfalse

  • if_return(default:true

  • inline(default:truereturn

    • false -- same as 0
    • 0 -- disabled inlining
    • 1 -- inline simple functions
    • 2 -- inline functions with arguments
    • 3 -- inline functions with arguments and variables
    • true -- same as 3
  • join_vars(default:truevar

  • keep_fargs(default:trueFunction.length

  • keep_fnames(default:falsetrueFunction.prototype.namekeep_fnames

  • keep_infinity(default:falsetrueInfinity1/0

  • loops(default:truedowhilefor

  • negate_iife(default:true

  • passes(default:1

  • properties(default:truefoo["bar"] → foo.bar

  • pure_funcs(default:nullvar q = Math.floor(a/b)qMath.floor(a/b)pure_funcs: [ 'Math.floor' ]pure_funcsmangle.reserved

  • pure_getters(default:"strict"truefoo.barfoo["bar"]"strict"foo.barfoonullundefined

  • reduce_funcs(default:truereduce_vars

  • reduce_vars(default:true

  • sequences(default:truetruesequences200false0sequences2sequences1true20020

  • side_effects(default:truefalse/*@__PURE__*//*#__PURE__*//*@__PURE__*/foo();

  • switches(default:trueswitch

  • toplevel(default:false"funcs""vars"falsetrue

  • top_retain(default:nullunusedtoplevel

  • typeofs(default:truetypeof foo == "undefined"foo === void 0false

  • unsafe(default:false

  • unsafe_comps(default:falsea <= bNaN

  • unsafe_Function(default:falseFunction(args, code)argscode

  • unsafe_math(default:false2 * x * 36 * x

  • unsafe_proto(default:falseArray.prototype.slice.call(a)[].slice.call(a)

  • unsafe_regexp(default:falseRegExp

  • unsafe_undefined(default:falsevoid 0undefined

  • unused(default:true"keep_assign"

  • warnings(default:false

Mangle options

  • eval(defaultfalsetrueevalwith

  • keep_fnames(defaultfalsetrueFunction.prototype.namekeep_fnames

  • reserved(default[]["foo", "bar"]

  • toplevel(defaultfalsetrue

Examples:

1 2 3 4 5
// test.js var globalVar; function funcName(firstLongName, anotherLongName) { var myVariable = firstLongName + anotherLongName; }
1 2 3 4 5 6 7 8 9 10
var code = fs.readFileSync("test.js", "utf8"); UglifyJS.minify(code).code; // 'function funcName(a,n){}var globalVar;' UglifyJS.minify(code, { mangle: { reserved: ['firstLongName'] } }).code; // 'function funcName(firstLongName,a){}var globalVar;' UglifyJS.minify(code, { mangle: { toplevel: true } }).code; // 'function n(n,a){}var a;'

Mangle properties options

  • builtins(default:falsetrue

  • debug(default:false""

  • keep_quoted(default:false

  • regex(default:null

  • reserved(default:[]reserved

Output options

The code generator tries to output shortest code possible by default. In case you want beautified output, pass--beautify-b

  • ascii_only(defaultfalse

  • beautify(defaulttrue-b-b-b beautify=false

  • braces(defaultfalseiffordowhilewith

  • comments(defaultfalsetrue"all""some"/^!/

  • indent_level(default4

  • indent_start(default0

  • inline_script(defaulttrue</script>

  • keep_quoted_props(defaultfalse

  • max_line_len(defaultfalse

  • preamble(defaultnull

  • preserve_line(defaultfalsetruebeautifyfalse

  • quote_keys(defaultfalsetrue

  • quote_style(default0

    • 0-- prefers double quotes, switches to single quotes when there are more double quotes in the string itself.0
    • 1 -- always use single quotes
    • 2 -- always use double quotes
    • 3 -- always use the original quotes
  • semicolons(defaulttruefalse

  • shebang(defaulttrue#!

  • webkit(defaultfalsetrue

  • width(default80

  • wrap_iife(defaultfalsetrue

Miscellaneous

You can pass--comments--comments all--comments /^!//*! Copyright Notice */

Note, however, that there might be situations where comments are lost. For example:

1 2 3 4 5 6 7
function f() { /** @preserve Foo Bar */ function g() { // this function is never called } return something(); }

Even though it has "@preserve", the comment will be lost because the inner functiong

The safest comments where to place copyright information (or other info that needs to be kept in the output) are comments attached to toplevel nodes.

Theunsafe compress

It enables some transformations that

  • new Array(1, 2, 3)orArray(1, 2, 3)[ 1, 2, 3 ]
  • new Object(){}
  • String(exp)orexp.toString()"" + exp
  • new Object/RegExp/Function/Error/Array (...) → we discard the new

Conditional compilation

You can use the--define-d--define DEBUG=false

1 2 3
if (DEBUG) { console.log("debug stuff"); }

You can specify nested constants in the form of--define env.DEBUG=false

UglifyJS will warn about the condition being always false and about dropping unreachable code; for now there is no option to turn off only this specific warning, you can passwarnings=false

Another way of doing that is to declare your globals as constants in a separate file and include it into the build. For example you can have abuild/defines.js

1 2 3
var DEBUG = false; var PRODUCTION = true; // etc.

and build your code like this:

1
uglifyjs build/defines.js js/foo.js js/bar.js... -c

UglifyJS will notice the constants and, since they cannot be altered, it will evaluate references to them to the value itself and drop unreachable code as usual. The build will contain theconstconstvarreduce_vars

Conditional compilation API

You can also use conditional compilation via the programmatic API. With the difference that the property name isglobal_defs

1 2 3 4 5 6 7 8
var result = UglifyJS.minify(fs.readFileSync("input.js", "utf8"), { compress: { dead_code: true, global_defs: { DEBUG: false } } });

To replace an identifier with an arbitrary non-constant expression it is necessary to prefix theglobal_defs"@"

1 2 3 4 5 6 7 8
UglifyJS.minify("alert('hello');", { compress: { global_defs: { "@alert": "console.log" } } }).code; // returns: 'console.log("hello");'

Otherwise it would be replaced as string literal:

1 2 3 4 5 6 7 8
UglifyJS.minify("alert('hello');", { compress: { global_defs: { "alert": "console.log" } } }).code; // returns: '"console.log"("hello");'

Using native Uglify AST with minify()

1 2 3 4 5 6 7 8 9 10 11 12 13
// example: parse only, produce native Uglify AST var result = UglifyJS.minify(code, { parse: {}, compress: false, mangle: false, output: { ast: true, code: false // optional - faster if false } }); // result.ast contains native Uglify AST
1 2 3 4 5 6 7 8 9 10 11 12 13 14
// example: accept native Uglify AST input and then compress and mangle // to produce both code and native AST. var result = UglifyJS.minify(ast, { compress: {}, mangle: {}, output: { ast: true, code: true // optional - faster if false } }); // result.ast contains native Uglify AST // result.code contains the minified code in string form.

Working with Uglify AST

Transversal and transformation of the native AST can be performed throughTreeWalkerTreeTransformer

ESTree / SpiderMonkey AST

UglifyJS has its own abstract syntax tree format; for

For example

1
acorn file.js | uglifyjs -p spidermonkey -m -c

The-p spidermonkey

Use Acorn for parsing

More for fun, I added the-p acornrequire("acorn")

Acorn is really fast (eg 250ms instead of 380ms on some 650K code), but converting the SpiderMonkey tree that Acorn produces takes another 150ms so in total it's a bit more than just using UglifyJS's own parser.

Uglify Fast Minify Mode

It's not well known, but whitespace removal and symbol mangling accounts for 95% of the size reduction in minified code for most JavaScript - not elaborate code transforms. One can simply disablecompressmanglebutternut

d3.js minify size gzip size minify time (seconds)
original 451,131 108,733 -
uglify-js@3.0.24 316,600 85,245 0.70
uglify-js@3.0.24 220,216 72,730 1.13
butternut@0.4.6 217,568 72,738 1.41
uglify-js@3.0.24 212,511 71,560 3.36
babili@0.1.4 210,713 72,140 12.64

To enable fast minify mode from the CLI use:

1
uglifyjs file.js -m

To enable fast minify mode with the API use:

1
UglifyJS.minify(code, { compress: false, mangle: true });

Source maps and debugging

Variouscompresscompressmangle

Compiler assumptions

To allow for better optimizations, the compiler makes various assumptions:

  • .toString() and .valueOf()
  • undefined,NaNInfinity
  • arguments.callee,arguments.callerFunction.prototype.caller
  • The code doesn't expect the contents ofFunction.prototype.toString()Error.prototype.stack
  • Getting and setting properties on a plain object does not cause other side effects (using.watch()Proxy
  • Object properties can be added, removed and modified (not prevented withObject.defineProperty()Object.defineProperties()Object.freeze()Object.preventExtensions()Object.seal()