Using Microsoft Ajax Minifier Tool to Minify JavaScript Files

by Bipin Joshi

A growing use of JavaScript and libraries based on JavaScript (such as ASP.NET AJAX and jQuery) causes a decrease in website performance. Microsoft Ajax Minifier, a tool to compress JavaScript and CSS files, can greatly reduce the size of such files, resulting in improved performance of web applications.


The increased use of JavaScript and libraries based on JavaScript (such as ASP.NET AJAX and jQuery) results in a considerable amount of JavaScript being downloaded on the client side. The need for large amounts of JavaScript to be downloaded may result in your website getting a performance penalty for obvious reasons. In such cases it is recommended to reduce the size of JavaScript files by using minification techniques. To that end Microsoft Ajax Minifier, a tool to compress JavaScript and CSS files, can greatly reduce the size of such files thus improving the performance of your web application. In this article you will learn the basics of using Microsoft Ajax Minifier tool and certain programming recommendations to get most out of the minification process.

Understanding Minification

Developers are often advised to write clear and readable code. The variable names you use and the comments you place in your code greatly affect the readability of your code. No doubt, as a good programming practice you should adhere to this principle. However, these standards are of little use to compilers, parsers and code execution engines. Consider the following JavaScript function for example,

//The following function converts a given temperature value
//from Fahrenheit to Celsius
function ConvertToCelsius(value) {
    var newValue;
    newValue = (value * 1.8) + 32;
    return newValue;

The ConvertToCelsius function shown above converts a given temperature value from Fahrenheit to Celsius. The function name, variable names used within the function, comments, etc., makes the code readable and easily understandable. Now consider the following piece of code:

function f(b){var a;a=b*1.8+32;return a}

The function f, shown above, does exactly the same thing as the ConvertToCelsius() function but if you compare the number of bytes in both versions, obviously the second version is highly compact. This means the later version will be more quickly downloaded to the client machine than the former one.

Microsoft Ajax Minifier tool works on the same principle. It cleverly compacts your JavaScript code by applying several minification techniques such as removing comments, renaming variables and functions and removing white spaces (and there are many others).

Using Microsoft Ajax Minifier Command Line Tool

Microsoft Ajax Minifier is a command line tool named AjaxMin.exe. The AjaxMin.exe supports several command line switches out of which the following can be used for basic minification.

ajaxmin.exe <source_file> -o <destination_file> -clobber:<true/false>

In the above syntax, source_file is the path and name of the source JavaScript file that you wish to minify. The -o switch specifies the destination_file, B i.e. the path and name of the output file after minification. By default the destination_file will not be overwritten if already present. The -clobber switch allows you to control this behavior. If you set the -clobber switch to true, the destination_file will be overwritten.

A complete list of available command line options can be seen by /? switch.

Minifying a Sample JavaScript File

Now that you know what minification is, let's create a sample JavaScript file and then apply minification to it. Open Visual Studio and create a new ASP.NET Website. Then add a new JScript file to the website and key-in the following code:

//The following function converts a given temperature value
//from Fahrenheit to Celsius and vice a versa
//Example: Test(1,20,"C")
function Test(month,temp,unit) {
    var months = new Array("Jan","Feb","Mar");
    var newValue;
    var ConvertToCelsius = function(value) {
        return (value * 1.8) + 32;
    var ConvertToFahrenheit = function(value) {
        return (value - 32) / 1.8;
    if (unit == "C") {
        newValue = ConvertToCelsius(temp);
    else {
        newValue = ConvertToFahrenheit(temp);
    alert("The temperature in the month of " + months[month] + " was " + newValue);

Now, open the Microsoft Ajax Minifier Command Prompt from Windows Start menu (see below).

Microsoft Ajax Minifier Command Prompt
Figure 1: Microsoft Ajax Minifier Command Prompt

Issue the following command at the command prompt. Make sure to change the path and file name of the source and the destination files (JScript.js and JScript.min.js in the following figure).

Issue the following command at the command prompt
Figure 2: Issue the following command at the command prompt

When you press enter, the Microsoft Ajax Minifier tool compresses the source file and displays the statistics related to the minification process. For example, the following figure shows that a source file of 656 bytes is reduced to 205 during the process.

The Microsoft Ajax Minifier tool compresses the source file
Figure 3: The Microsoft Ajax Minifier tool compresses the source file

You can now refer the JScript.min.js file in the <script> tags throughout your web wite.

Now that you know how to use the minifier tool with its basic switches, let's see some of the main optimization techniques that it uses on your JavaScript code.

How the Microsoft Ajax Minifier Tool Works

Here are some minification techniques that the Microsoft Ajax Minifier tool applies to your code:

  • Unnecessary white spaces, line breaks are removed.
  • function Test()
        alert("Hello World");


    function Test(){alert("Hello World")}
  • Comments you put in the code are removed.
  • Unnecessary semicolons are removed.
  • function Test() {
        alert("Hello World!");


    function Test(){alert("Hello World!")}
  • Curly braces from code blocks consisting of only one statement are removed.
  • function Test(i) {
            return i+10;
            return i-10;


    function Test(a){return a>100?a+10:a-10}
  • Local variables and functions are renamed to smaller names.
  • function Test() {
        var currentValue = 100;
        var myFunction = function() {
            currentValue = currentValue + 10;


    function Test(){var a=100,b=function(){a=a+10;alert(a)};b()}
  • String delimiters are checked and appropriate substitution is made so that escape characters are minimal.
  • var msg = "Please enter Email e.g. "john@somedomain.com"?"; 


    var msg='Please enter Email e.g. "john@somedomain.com"?'
  • Multiple separate variable declarations are combined into one statement.
  • var var1 = "Hello";
    var var2 = "World";
    var var3 = "from";
    var var4 = "JavaScript";


    var var1="Hello",var2="World",var3="from",var4="JavaScript";
  • If a constructor is parameter-less empty parentheses are removed. For example,
  • var dt = new Date();


    var dt=new Date;
  • Arrays constructors are converted to array literals.
  • var months = new Array("Jan", "Feb", "Mar");


    var months=["Jan","Feb","Mar"]

Detailed discussion of how Microsoft Ajax Minifier deals with the code can found on the official ASP.NET website.

Coding for Better Minification

Though the Microsoft Ajax Minifier tool does a great amount of work for you to generate a compact output, following some coding practices can further increase the chance of better minification. Some of such coding practices are discussed below.

Avoid Using Eval() Function and With Statement

The eval() function executes a piece of code supplied as a string. For example, consider the eval() function call below:

eval("var myVar=100;alert(myVar);");

There is no way for the minifier tool to convert this string literal into a compact form. As a result the call will not be compacted. Similarly, using with statement also hampers the minification process.

var myVar = 100;
with(window) {

Since the minifier tool won't know whether myVar refers to the variable or to a member of window object the entire block will not be minified.

Try to Avoid Global Variables and Functions

Global variables and functions are never minified because there is a chance that they are used from some other part of the website. Consider the set of global variables and function below:

function MainFunction() {

function HelperFunction1() {
    alert("inside helper function 1");

function HelperFunction2() {
    alert("inside helper function 2");

Here, the functions HelperFunction1() and HelperFunction2() are used only by MainFunction() and are not used anywhere else. However, since they are in global scope, the minifier tool will not compact them. You can overcome this problem by modifying the code like this:

function MainFunction() {
    var HelperFunction1=function(){
        alert("inside helper function 1");

    var HelperFunction2=function() {
        alert("inside helper function 2");

Now, the minifier tool will compact both of the helper functions to smaller names and calls to them will also be substituted accordingly.

Use Shortcuts for Window and Document Objects

It is very common to use window and document JavaScript objects in the code. If you refer them as "window" and "document" at each and every place then you will be wasting bytes every time. Instead you can use them as shown below:

var w = window;
var d = document;
function MainFunction() {
    w.setInterval(myCode, 1000);

You can even wrap frequently used methods of document object (such as getElementById) in a separate function like this:

function Get(id)
    return d.getElementById(id);

Then use the Get() function at all the places where you would have used getElementById() method.

function DoTest() {

Minifying CSS Files

The Microsoft Ajax Minifier tool can also compact Cascading Style Sheet (CSS) files. The process is very similar to what we discussed for JavaScript files but with much less complication. You can refer to the official documentation of the tool for its usage syntax and available switches for the CSS files.

Running Microsoft Ajax Minifier Tool from Visual Studio

Microsoft Ajax Minifier is a command line tool. Rather than opening the command prompt every time and then invoking the commands manually, wouldn't it be nice if you integrated it with Visual Studio IDE itself? Luckily you can do so with simple steps.

Open Visual Studio and select "External Tools" from its Tools menu.

Visual Studio: External Tools
Figure 4: Visual Studio: External Tools

This will open a dialog as shown below:

Visual Studio External Tools Dialog Box
Figure 5: Visual Studio External Tools Dialog Box

Specify the tool title as "Microsoft Ajax Minifier." Set Command to point to ajaxmin.exe. Add arguments as shown below:

$(ItemFileName)$(ItemExt)  -out $(ItemFileName).min$(ItemExt) -clobber

The $(ItemFileName) represents the file name of the currently opened file in the Visual Studio IDE. The $(ItemExt) represents its extension. You can also pick these arguments from the arguments menu. Set initial directory to $(ItemDir) i.e. the same folder as the opened file. Finally. check the "Use Output Window" checkbox so that output messages will be displayed there and click on the OK button. The Microsoft Ajax Minifier tool will now be displayed on the Tools menu.

The Microsoft Ajax Minifier Tool
Figure 6: The Microsoft Ajax Minifier Tool

Open any JavaScript file and run the tool on it. A sample message emitted by the tool as seen in the Output Windows is shown below:

Microsoft Ajax Minifier Tool Output Window
Figure 7: Microsoft Ajax Minifier Tool Output Window

In order to see the minified file you will need to refresh the website in the Solution Explorer.


Microsoft Ajax Minifier is a tool to produce minified versions of JavaScript and CSS files. In this article we saw the basic usage of Microsoft Ajax Minifier tool for minifying JavaScript files. We also discussed certain programming practices for achieving better minification. The minified JavaScript files will take much less time to download on the client side thus improving the overall performance of your website.

About the Author:

Bipin Joshi is a blogger and writes about apparently unrelated topics - Yoga & technology! A former Software Consultant by profession, Bipin is programming since 1995 and is working with .NET framework ever since its inception. He has authored or co-authored half a dozen books and numerous articles on .NET technologies. He has also penned a few books on Yoga. He was a well known technology author, trainer and an active member of Microsoft developer community before he decided to take a backseat from the mainstream IT circle and dedicate himself completely to spiritual path. Having embraced Yoga way of life he now codes for fun and writes on his blogs. He can also be reached there.

This article was originally published on Wednesday May 4th 2011
Mobile Site | Full Site