Better Compression with UglifyJS

By  on  

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"] →
  • 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. 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!

Recent Features

  • By
    Send Text Messages with PHP

    Kids these days, I tell ya.  All they care about is the technology.  The video games.  The bottled water.  Oh, and the texting, always the texting.  Back in my day, all we had was...OK, I had all of these things too.  But I still don't get...

  • By
    CSS vs. JS Animation: Which is Faster?

    How is it possible that JavaScript-based animation has secretly always been as fast — or faster — than CSS transitions? And, how is it possible that Adobe and Google consistently release media-rich mobile sites that rival the performance of native apps? This article serves as a point-by-point...

Incredible Demos

  • By
    HTML5 Datalist

    One of the most used JavaScript widgets over the past decade has been the text box autocomplete widget.  Every JavaScript framework has their own autocomplete widget and many of them have become quite advanced.  Much like the placeholder attribute's introduction to markup, a frequently used...

  • By
    GitHub-Style Sliding Links

    GitHub seems to change a lot but not really change at all, if that makes any sense; the updates come often but are always fairly small. I spotted one of the most recent updates on the pull request page. Links to long branch...


  1. Petah

    I thought closure compiler was the most effective

    • Jason

      It probably is in Advanced mode.

    • It really is; it’s just slower and inconvenient to run because it’s Java. Uglify’s most awesome feature is that it’s easy to deploy, run, and bundle. And while it compresses poorly, it’s safer than CC’s Advanced mode because it doesn’t optimize as much.

  2. kurtextrem

    You could also use “screw_ie8” (in case you don’t support ie8). Looks like this in grunt:

    uglify: {
    	options: {
    		mangle: {
    			//toplevel: true,
    			screw_ie8: true
    		compress: {
    			screw_ie8: true,
    			sequences: true,
    			//properties: true,
    			dead_code: true,
    			drop_debugger: true,
    			comparisons: true,
    			conditionals: true,
    			evaluate: true,
    			booleans: true,
    			loops: true,
    			unused: true,
    			hoist_funs: true,
    			if_return: true,
    			join_vars: true,
    			cascade: true,
    			//negate_iife: true,
    			drop_console: true
    	main: {
    		src: ['src/main.js'],
    		dest: 'dist/main.min.js'
  3. eugene

    Most of these options are on by default – they are there to disable them

  4. Bunt

    “slower and inconvenient to run because it’s Java”

    Java is faster than node. If it’s inconvenient, it’s because it’s badly written or you are a scriptkiddie

    • Anon

      >Java is faster than node
      Sure thing, buddy. Now go and run Closure Compiler and UglifyJS, one of them feels like opening Photoshop, which one is it? The Java one or the Node one?

      Yeah. Turns out a decades-old language that didn’t improve much and is owned by Oracle isn’t that great.

    • Nona

      They mean faster than node when it comes to the code running. Java is slower to load because of the VM. Node is slower to execute because of the need to go through a JS interpreter. It’s not black and white though, and there are some areas where Node runs faster.

  5. Rods

    You could also avoid minify some functions.
    Maybe if you have some unobtrusive function [onclick="functionName01"].
    Not in the docs.

    mangle: {
        except: ['functionName01', 'functionName02'],
        screw_ie8: true

Wrap your code in <pre class="{language}"></pre> tags, link to a GitHub gist, JSFiddle fiddle, or CodePen pen to embed!