Better Compression with UglifyJS

UglifyJS is widely known as the most performant and effective JavaScript minifier available.  UglifyJS' default minification with --compress is nice but it doesn't do the full job.  There are a number of additional directives for the compress option, including:

• sequences -- join consecutive simple statements using the comma operator
• properties -- rewrite property access using the dot notation, for example foo["bar"] → foo.bar
• dead_code -- remove unreachable code
• drop_debugger -- remove debugger; statements
• unsafe (default: false) -- apply "unsafe" transformations (discussion below)
• conditionals -- apply optimizations for if-s and conditional expressions
• comparisons -- apply certain optimizations to binary nodes, for example: !(a <= b) → a > b (only when unsafe), attempts to negate binary nodes, e.g. a = !b && !c && !d && !e → a=!(b||c||d||e) etc.
• evaluate -- attempt to evaluate constant expressions
• booleans -- various optimizations for boolean context, for example !!a ? b : c → a ? b : c
• loops -- optimizations for do, while and for loops when we can statically determine the condition
• unused -- drop unreferenced functions and variables
• hoist_funs -- hoist function declarations
• hoist_vars (default: false) -- hoist var declarations (this is false by default because it seems to increase the size of the output in general)
• if_return -- optimizations for if/return and if/continue
• join_vars -- join consecutive var statements
• cascade -- small optimization for sequences, transform x, x into x and x = something(), x into x = something()
• warnings -- display warnings when dropping unreachable code or unused declarations etc.
• negate_iife -- negate "Immediately-Called Function Expressions" where the return value is discarded, to avoid the parens that the code generator would insert.
• pure_getters -- the default is false. If you pass true for this, UglifyJS will assume that object property access (e.g. foo.bar or foo["bar"]) doesn't have any side effects.
• pure_funcs -- default null. You can pass an array of names and UglifyJS will assume that those functions do not produce side effects. DANGER: will not check if the name is redefined in scope. An example case here, for instance var q = Math.floor(a/b). If variable q is not used elsewhere, UglifyJS will drop it, but will still keep the Math.floor(a/b), not knowing what it does. You can pass pure_funcs: [ 'Math.floor' ] to let it know that this function won't produce any side effect, in which case the whole statement would get discarded. The current implementation adds some overhead (compression will be slower).
• drop_console -- default false. Pass true to discard calls to console.* functions.

So instead of simply doing a basic compress, squeeze the hell out of your JavaScript files by altering booleans, removing unneeded var uses, axing unreachable code, and much more.  Here's an example of such a case using the NodeJS API:

var UglifyJS = require('uglify-js');
var fs = require('fs');

var result = UglifyJS.minify('site.js', {
	mangle: true,
	compress: {
		sequences: true,
		dead_code: true,
		conditionals: true,
		booleans: true,
		unused: true,
		if_return: true,
		join_vars: true,
		drop_console: true
	}
});

fs.writeFileSync('site.min.js', result.code);

You can pass those compression values via command line as well.  This post isn't meant to be groundbreaking but more to raise awareness that simply using --compress doesn't optimize minification anywhere near potential.  If you're going to minify and compress your JavaScript, go all out!