JavaScript Minifier

Minify JavaScript code to reduce file size and improve load times.

Original Size

1.40 KB

Minified Size

865 B

Savings

39.7%

JavaScript Input

// Application entry point
// Last updated: March 2026

/**
 * Utility function to debounce rapid calls.
 * Useful for search inputs, resize handlers, etc.
 */
function debounce(func, delay) {
  let timeoutId = null;

return function (...args) {
    const context = this;

if (timeoutId !== null) {
      clearTimeout(timeoutId);
    }

timeoutId = setTimeout(function () {
      func.apply(context, args);
      timeoutId = null;
    }, delay);
  };
}

// Format a number as currency
function formatCurrency(amount, currency = "USD") {
  return new Intl.NumberFormat("en-US", {
    style: "currency",
    currency: currency,
  }).format(amount);
}

/*
  Main application class
  Handles initialization and event binding
*/
class App {
  constructor(config) {
    this.name = config.name || "MyApp";
    this.version = config.version || "1.0.0";
    this.isReady = false;
  }

// Initialize the application
  init() {
    console.log("Initializing " + this.name + " v" + this.version);
    this.bindEvents();
    this.isReady = true;
    return this;
  }

bindEvents() {
    const handleResize = debounce(function () {
      console.log("Window resized");
    }, 250);

window.addEventListener("resize", handleResize);
    window.addEventListener("load", function () {
      console.log("Page loaded");
    });
  }
}

// Create and start the app
const app = new App({ name: "Chroma", version: "2.0.0" });
app.init();

Minified Output

function debounce(func,delay){let timeoutId=null;return function(...args){const context=this;if(timeoutId!==null){clearTimeout(timeoutId);}timeoutId=setTimeout(function(){func.apply(context,args);timeoutId=null;},delay);};}function formatCurrency(amount,currency="USD"){return new Intl.NumberFormat("en-US",{style:"currency",currency:currency,}).format(amount);}class App{constructor(config){this.name=config.name||"MyApp";this.version=config.version||"1.0.0";this.isReady=false;}init(){console.log("Initializing "+this.name+" v"+this.version);this.bindEvents();this.isReady=true;return this;}bindEvents(){const handleResize=debounce(function(){console.log("Window resized");},250);window.addEventListener("resize",handleResize);window.addEventListener("load",function(){console.log("Page loaded");});}}const app=new App({name:"Chroma",version:"2.0.0"});app.init();

Related Tools

CSS MinifyNEW

Minify CSS code to reduce file size. Remove comments, whitespace, and optimize.

JSON Formatter

Format, beautify, minify, and validate JSON data online with instant error detection.

HTML FormatNEW

Format and beautify messy HTML code with proper indentation and structure.

Frequently Asked Questions

What does JavaScript minification do?

JS minification removes unnecessary characters like whitespace, newlines, and comments without changing functionality. This reduces file size and speeds up page loading.

Is minified JavaScript still readable?

Minified JavaScript is intentionally hard to read — that is the tradeoff for smaller file size. Always keep your original source files for development.

Will minifying JavaScript break my code?

Proper minification preserves all functionality. The tool removes only whitespace, comments, and unnecessary syntax. Your code will execute identically after minification.

What is the difference between minification and obfuscation?

Minification focuses on reducing file size by removing unnecessary characters. Obfuscation goes further by renaming variables and restructuring code to make it deliberately hard to reverse-engineer. Minification is for performance; obfuscation is for intellectual property protection.

Should I use source maps with minified JavaScript?

Yes. Source maps link minified code back to the original source, making it possible to debug production issues in browser developer tools. Most build tools generate source maps automatically alongside minified output.

How much smaller will my JavaScript file be?

Results vary depending on coding style, but most JavaScript files shrink by 30-60% after minification. Files with extensive comments, long variable names, and generous whitespace see the greatest reductions.

Is my JavaScript code kept private?

Yes. All minification runs entirely in your browser. Your code is never sent to a server, ensuring complete privacy and security for proprietary scripts.

Can I minify TypeScript with this tool?

This tool minifies plain JavaScript. If you are working with TypeScript, compile it to JavaScript first using the TypeScript compiler (tsc) or your build tool, then paste the output here for minification.

How to Use the JavaScript Minifier

Paste your JavaScript code into the input area and receive compressed output instantly. Our free online JavaScript Minifier strips whitespace, comments, and redundant syntax to produce the smallest possible file while maintaining identical functionality. Copy the result with one click and drop it straight into your production build. No sign-up, no installation, and no data ever leaves your browser.

The tool accepts everything from small utility functions to large application bundles. Whether your code is written in ES5, ES6+, or compiled from TypeScript, the minifier handles it seamlessly and shows you the exact byte savings.

What Is JavaScript Minification?

JavaScript minification is the process of removing every character that is not required for the code to execute correctly. This includes spaces, tabs, newlines, block and inline comments, and unnecessary semicolons or brackets. The result is a single line (or highly condensed block) of code that browsers parse and execute just as quickly, if not faster, than the original.

Because JavaScript is a render-blocking resource by default, its file size has a direct impact on how quickly a page becomes interactive. Lighthouse and Google PageSpeed Insights specifically flag unminified JavaScript as a performance bottleneck. Minifying scripts reduces Time to Interactive (TTI) and Total Blocking Time (TBT), both of which are critical Core Web Vitals metrics that influence search engine rankings.

JavaScript Minifier Use Cases

Front-end developers minify JavaScript before every production deployment to ensure optimal load times. WordPress site owners paste plugin or theme scripts into the minifier when they need quick optimizations without modifying build pipelines. Email template developers reduce inline script size to meet strict email client limitations. Open-source library authors ship minified distribution files so consumers get the smallest possible bundle out of the box.

The tool is equally valuable for quick experiments and prototyping. If you are embedding a script in a third-party platform that has file-size restrictions, such as Google Tag Manager custom HTML tags or advertising creatives, minifying the code helps you stay within limits. It is also useful for comparing the minified size of different implementation approaches before committing to one.

Why Use Our JavaScript Minifier?

Many minification tools require a local Node.js environment, a package manager, and configuration files. Our online JavaScript Minifier eliminates all of that friction. It works from any browser on any device, processes code entirely on the client side for complete privacy, and delivers results in milliseconds. The interface shows a clear before-and-after size comparison, making it easy to quantify and report performance improvements. Whether you are a seasoned developer optimizing a production application or a beginner learning about web performance, this tool provides a fast, reliable, and private way to compress your JavaScript.