Minified/compiled JavaScript vs. uncompressed JavaScript in terms of performance

Question

My understanding of JavaScript “compilation” is that it condenses and minifies your code to ultimately save bytes.

Does either condensing or minification make JavaScript run any faster?

Take the following examples for consideration:

var abcdefghijklmnopqrstuvwxyz = 1;
// vs.
var a=1;

var b = function() {
    // Here is a comment
    // And another
                                                                                                                        // White space
    return true;
};

// vs.

var b=function(){return true}

I ran these examples through jsPerf with little or no difference.

Can compilation of JavaScript make it any faster or slower, in addition to saving bytes?

Solution 1

Yes, compilation in the sense of the transforms applied by something like the Google Closure Compiler can make your script run faster. Consider this very simple example:

var x = ["hello", "james"].join(" ");

That compiles to:

var x="hello james";

Which is both less code and quicker to run. Obviously that's a silly example. I would hope you would write the compiled version yourself. However, it does demonstrate that Closure is capable of giving performance improvements as well as just file size improvements.

From the Closure docs (emphasis added):

The Closure Compiler is a tool for making JavaScript download and run faster. It is a true compiler for JavaScript. Instead of compiling from a source language to machine code, it compiles from JavaScript to better JavaScript.

Edit

For an example of the Closure compiler actually increasing the size of a JavaScript file in an attempt to offer performance improvements, see my answer to this question.

Solution 2

Minified vs un-minified shouldn't make any difference in terms of execution speed. The only difference could be that minified version would be faster to parse, but even that when you have a very large file (you won't find any differences with the test you ran, it's just to small).

edit: the first statement I've made is valid if you are doing just the basic "minification". If you are using Closure compiler like James showed, then there could be some differences if the Clousure tools would optimize your code ...

Comments

[Blowsie]

I guess uncompiled javascript also has potential to use more memory vs compiled javascript?

[James Allardice]

@Blowsie - That's probably less likely, since the things you store in memory are unlikely to change as a result of the compilation (and things stored unnecessarily will be garbage collected anyway). But it is probably possible, yes.

[Octavian Damiean]

So in fact it is not a compiler but a tool which refactors for performance.

[James Allardice]

@OctavianDamiean - Pretty much, yes. Although Google do call it "a true compiler for JavaScript" (although according to Wikipedia, this violates the definition of "compiler").

[Florian Margaine]

@Blowsie Actually, the compiled javascript might take less memory. Google Closure Compiler often inlines functions, which means there is less stack used, thus less memory used.