Minificador de JavaScript

Comprima y optimice scripts JavaScript directamente en su navegador. Elimina espacios redundantes, suprime llamadas de depuración y comentarios, preserva licencias obligatorias y acorta variables locales sin alterar la semántica de ejecución.

Opciones de compresión
Código fuente
Líneas26
Tamaño original658 B
Código minificado
/*! MyLib v1.2.3 | Licencia MIT | (c) 2026 Example Corp */
function calcularTotal(elementos,tasaImpuesto){let total=0;for(const item of elementos){total+=item.precio*item.cantidad;}const conImpuesto=total*(1+tasaImpuesto);console.log("Total liquidado:",conImpuesto);return conImpuesto;}const carrito=[{precio:19.99,cantidad:2},{precio:5.5,cantidad:4},];calcularTotal(carrito,0.08);
Minificado en 1 ms
Resultado2 líneas · 381 B

Se eliminaron 4 comentarios.

Se conservaron 1 bloque de licencia de código abierto (/*! ... */).

Todo el proceso de minificación y análisis se ejecuta 100% en local en su navegador. Su código nunca se envía a servidores externos.

Guía de Operación

Paso 1

Cargar Script de Origen

Pegue o escriba código JavaScript en el editor, o arrastre directamente un archivo .js, .mjs, .cjs o .txt al área de entrada.

Paso 2

Configurar Reglas de Minificación

Active la eliminación de comentarios, preservación de licencias, compresión de espacios, ofuscación de variables locales o supresión de llamadas a console.*.

Paso 3

Inspeccionar y Exportar Código Comprimido

Revise el resultado minificado en el panel de salida, verifique las métricas de reducción y copie el resultado o descargue minified.min.js.

Ejemplos de Transformación

1. Función y Bucle Multilínea → Script Compacto para Producción

Entrada · Código Fuente Estructurado

function calcularTotal(elementos, tasaImpuesto) {
  // Sumar todos los precios de los artículos
  let total = 0;

  for (const item of elementos) {
    total += item.precio * item.cantidad;
  }

  /* Aplicar tasa impositiva al subtotal */
  const conImpuesto = total * (1 + tasaImpuesto);

  return conImpuesto;
}

Salida · Minificado (Espacios y Saltos Suprimidos)

function calcularTotal(elementos,tasaImpuesto){let total=0;for(const item of elementos){total+=item.precio*item.cantidad;}const conImpuesto=total*(1+tasaImpuesto);return conImpuesto;}

2. Preservación de Licencia de Código Abierto y Supresión de Comentarios Internos

Entrada · Cabecera Legal + Comentarios de Rutina

/*! MyLib v1.2.3 | Licencia MIT | (c) 2026 Example Corp */
function saludar(nombre) {
  // Saludo simple
  return "Hola, " + nombre + "!";
}

Salida · Licencia Retenida, Comentarios Internos Purgados

/*! MyLib v1.2.3 | Licencia MIT | (c) 2026 Example Corp */
function saludar(nombre){return"Hola, "+nombre+"!";}

3. Ofuscación de Variables Locales (Parámetros y Ámbito de Función)

Entrada · Identificadores Locales Descriptivos

function calcularTotal(elementos, tasaImpuesto) {
  let total = 0;
  for (const item of elementos) {
    total += item.precio * item.cantidad;
  }
  return total * (1 + tasaImpuesto);
}

Salida · Parámetros y Variables Locales Breves (a, b, c, d)

function calcularTotal(a,b){let c=0;for(const d of a){c+=d.precio*d.cantidad;}return c*(1+b);}

4. Eliminación de Sentencias de Depuración (Producción Limpia)

Entrada · console.time, log, info, timeEnd

function obtenerUsuario(idUsuario) {
  console.time('consulta');
  console.log('Obteniendo usuario:', idUsuario);
  const resultado = bd.consultar(idUsuario);
  console.info('Consulta completada');
  console.timeEnd('consulta');
  return resultado;
}

Salida · Llamadas a Console Depuradas (Cero Sobrecarga en Runtime)

function obtenerUsuario(idUsuario){const resultado=bd.consultar(idUsuario);return resultado;}

Reglas de Procesamiento y Referencia de Configuración

OpciónPor DefectoMecanismo de Ejecución y Límites de Seguridad
Eliminar comentariosActivadoElimina comentarios de una línea (//) y de bloque (/* ... */). Las cadenas de texto literales, plantillas de texto y expresiones regulares quedan blindadas frente a truncamientos erróneos.
Conservar /*! licencias */ActivadoAísla los bloques de comentarios precedidos por un signo de exclamación (/*!) y los reincorpora en la cabecera superior del código generado para cumplir las obligaciones legales de licencias MIT, Apache y BSD.
Comprimir espaciosActivadoColapsa espacios, tabulaciones y saltos de línea superfluos al separador gramatical mínimo indispensable. Inserta automáticamente puntos y comas donde la Inserción Automática de Punto y Coma (ASI) fallaría.
Ofuscar nombres (Mangle)DesactivadoAnaliza declaraciones de función, parámetros de flecha y ámbitos de bloque (let, const, var), renombrando identificadores locales a símbolos cortos (a, b, c…). Preserva intactos nombres globales y propiedades de objetos.
Eliminar console.*DesactivadoDetecta llamadas a console.log, warn, error, info, table y time. En posición de sentencia se eliminan por completo; en posición de expresión se sustituyen con seguridad por void 0.

Análisis Léxico y Desambiguación de Límites de Tokens

JavaScript no puede comprimirse de forma fiable mediante expresiones regulares globales simples. Sustituciones ingenuas como eliminar // corrompen URLs válidas ("https://api.dominio.com") y contenidos de cadenas, mientras que suprimir espacios dentro de plantillas literales altera el formato deseado. La minificación requiere un analizador léxico con máquina de estados que clasifique el código en categorías de tokens estrictas:

Estado 1

Protección de Literales

Las cadenas entre comillas simples, dobles y comillas invertidas se analizan rastreando secuencias de escape (\\). Su contenido queda completamente aislado de la supresión de espacios.

Estado 2

Desambiguación de Barras

Determina si una barra diagonal representa un operador de división (a / b), un prefijo de comentario (//, /*) o un literal de expresión regular (/patrón/flags) en función del token significativo precedente.

Estado 3

Interpolación Anidada

Rastrea la profundidad de llaves dentro de interpolaciones en plantillas literales (`val: ${anidado}`), evitando que objetos o subexpresiones cierren prematuramente el token de la plantilla.

Estado 4

Preservación de Operadores

Distingue signos de puntuación multicarácter (===, >>>, ?., ??=) e inserta los espacios requeridos entre operadores unarios adyacentes (+ +a frente a ++a).

Restricciones de Inserción Automática de Punto y Coma (ASI) según ECMA-262

De acuerdo con ECMA-262, la inserción de punto y coma se activa cuando un token infringe las reglas gramaticales a través de un terminador de línea. Al comprimir espacios y saltos de línea durante la minificación, las condiciones que antes disparaban el mecanismo ASI desaparecen a menos que se inyecten puntos y comas explícitos:

Peligro en Producciones Restringidas

JavaScript prohíbe de forma estricta un salto de línea entre palabras clave como return, throw, yield, await, break y continue y la expresión subsiguiente. Si se elimina el salto sin insertar punto y coma, una función que retorna un objeto literal alteraría catastróficamente su valor retornado.

// Código Original sin Minificar:
return\n{ exito: true }; → retorna undefined bajo ASI
// Salida Segura del Minificador:
return;{exito:true}; → Punto y coma preservado; semántica idéntica

Trampas de Caracteres Iniciales ((, [, /, +, -)

Cuando una sentencia comienza con un paréntesis o corchete de apertura en una nueva línea, omitir el punto y coma anterior provoca que el motor lo interprete como una invocación de función o un acceso por propiedad computada sobre la sentencia anterior, desencadenando excepciones en tiempo de ejecución.

// Código Original sin Minificar:
const a = b\n(elementos).forEach(...)
// Compresión Ingenua (Roto):
const a=b(elementos).forEach(...) → ¡Invoca b como función!
// Minificación Segura:
const a=b;(elementos).forEach(...) → Punto y coma inyectado

Análisis de Ámbito y Límites de Ofuscación de Identificadores (Mangle)

La ofuscación de identificadores renombra variables a símbolos de uno o dos caracteres (a, b, c... aa, ab...), aportando una reducción adicional del 15% al 25% en el peso del token. Sin embargo, los límites léxicos imponen reglas estrictas sobre qué símbolos pueden transformarse con seguridad:

Categoría de IdentificadorSeguridad en MangleJustificación Técnica y Restricciones en Runtime
Parámetros de Función y Variables LocalesSeguro (Ofuscado)Variables declaradas con let, const o var cuya referencia léxica permanece estrictamente dentro del ámbito local. Nunca se exponen al invocador externo.
Propiedades de Objetos (obj.prop, { prop: val })Inseguro (Preservado)Renombrar propiedades rompe accesos dinámicos (obj[clave]), esquemas JSON serializados de APIs externas y accesos al DOM del navegador. Deben permanecer intactas.
Variables Globales y APIs WebInseguro (Preservado)Identificadores como window, document, fetch, localStorage y objetos globales nativos (Math, Promise) no pueden reasignarse sin corromper el entorno host.
Declaraciones Exportadas de Nivel SuperiorInseguro (Preservado)Las exportaciones con nombre (export function calcular()) constituyen la API pública del módulo ES. Ofuscar identificadores de nivel superior rompería los consumidores que los importan.

Presupuesto de Ejecución: Transferencia de Red vs. Coste de Análisis y Compilación en V8

Optimizar JavaScript no se limita a la velocidad de descarga en red. Los motores de navegación modernos (Chromium V8, WebKit JavaScriptCore y Gecko SpiderMonkey) consumen considerables ciclos de CPU en el hilo principal durante la ingesta de scripts:

Fase de Scanner y Tokenizer

Antes de ejecutar el código, el escáner del navegador lee caracteres de forma secuencial. Eliminar el 50% de espacios y comentarios suprime millones de iteraciones de lectura en el hilo principal durante la carga inicial.

Generación de Bytecode en Ignition

El intérprete Ignition de V8 compila bytecode directamente desde los nodos del AST. Un código compacto reduce la profundidad de nodos y la asignación de memoria, disminuyendo el Total Blocking Time (TBT) y el Interaction to Next Paint (INP).

Sinergia de Entropía con Brotli y Gzip

Comprimir nombres de variables a tokens cortos reduce la diversidad de símbolos en los árboles de Huffman. Un JavaScript minificado alcanza un tamaño transferido adicional entre un 20% y un 30% menor tras la compresión Brotli en comparación con código sin minificar.

Matriz de Herramientas: Minificador Web vs. Empaquetadores CLI

Comprender cuándo utilizar una herramienta interactiva en el navegador frente a una cadena de compilación completa optimiza el flujo de trabajo:

Dimensión FuncionalMinificador de JavaScript OnlineHerramientas CLI (Terser / esbuild / SWC)
Configuración y EntornoCero configuración; ejecución instantánea en navegadorRequiere entorno Node.js/Rust, package.json y configuración en pipelines CI
Casos de Uso IdealesScripts inline en HTML, bookmarklets, fragmentos de prueba, librerías individualesMonorepositorios, empaquetado multifichero, tree-shaking y builds de producción masivos
Generación de Source MapsSalida autónoma de archivo individualGeneración completa de archivos .map para depuración en producción
Tree-Shaking de Sistema CompletoPasada léxica de archivo únicoEliminación de código muerto entre módulos y poda del grafo de dependencias

Frequently Asked Questions

¿Cuál es la diferencia entre minificación, uglification (mangling) y ofuscación en JavaScript?

La minificación suprime espacios en blanco, sangrías, saltos de línea y comentarios para reducir el peso en bytes brutos. La técnica de afeamiento o mangling da un paso adicional renombrando variables y parámetros locales por identificadores cortos (a, b, c), preservando exactamente la semántica del AST y la lógica de ejecución. Ninguna de estas dos técnicas constituye ofuscación real: no cifran cadenas ni alteran el flujo de control. La ofuscación deliberada introduce código muerto, codificación de cadenas y aplanamiento de flujo de control para entorpecer la ingeniería inversa a expensas del rendimiento en tiempo de ejecución, mientras que la minificación se enfoca exclusivamente en la eficiencia de transferencia y ejecución.

¿La minificación de JavaScript puede alterar la ejecución o romper el comportamiento del código?

Un código JavaScript válido no experimentará fallos al procesarse mediante un minificador con reconocimiento léxico y sintáctico. La compresión segura aísla cadenas literales, expresiones regulares e interpolaciones en plantillas de texto, e inserta automáticamente puntos y comas donde lo exige la especificación de Inserción Automática de Punto y Coma (ASI). Los únicos riesgos ocurren si el código fuente ya contenía errores de sintaxis previos, o si la lógica depende de la reflexión sobre nombres de identificadores (como Function.prototype.name o Error.stack) y se habilita el modo de ofuscación de nombres (Mangle).

¿Por qué sigue siendo necesaria la minificación de JS si el servidor web ya aplica compresión Gzip o Brotli?

La minificación y la compresión HTTP operan en capas diferentes y con propósitos complementarios. Gzip y Brotli comprimen flujos de bytes en tránsito por la red usando diccionarios LZ77/Huffman; los nombres largos y espacios repetitivos diluyen la eficiencia del diccionario, por lo que minificar reduce el tamaño transferido post-Brotli entre un 20% y un 30% adicional. Más importante aún: la compresión en tránsito solo optimiza la descarga. Una vez en el navegador, el motor principal (como V8) debe descomprimir el archivo completo en memoria física y escanear cada carácter para compilarlo a bytecode. La minificación reduce directamente la carga del analizador léxico y sintáctico, mejorando de forma directa las métricas Total Blocking Time (TBT) e Interaction to Next Paint (INP).

¿Cómo evita el minificador que se rompa la Inserción Automática de Punto y Coma (ASI)?

La especificación ECMA-262 permite omitir puntos y comas cuando las sentencias finalizan en un salto de línea físico. Eliminar indiscriminadamente los saltos de línea causaría que sentencias adyacentes colisionaran generando excepciones de sintaxis. El minificador rastrea los límites de tokens, las producciones restringidas (return, throw, yield, await, break, continue) y los caracteres iniciales de alto riesgo en la línea siguiente ((, [, /, +, -, y comillas invertidas). Cuando colapsar espacios entre dos tokens alteraría la interpretación gramatical, se inserta automáticamente un punto y coma explícito.

¿Por qué el modo Mangle solo renombra variables locales en lugar de propiedades de objetos?

JavaScript es un lenguaje dinámico. Las propiedades de objetos (como user.id, config.timeout o { clave: valor }) se acceden con frecuencia mediante notación de corchetes dinámica (obj[prop]), se serializan desde cargas útiles JSON de APIs externas o interactúan con APIs del DOM del navegador. Renombrar propiedades sin un análisis estático de todo el sistema rompería las interfaces públicas y la ejecución en tiempo de ejecución. El modo Mangle solo acorta identificadores y parámetros cuyo ámbito léxico está estrictamente restringido al cuerpo de funciones o bloques locales.

¿Por qué al eliminar llamadas a console se genera void 0 en ciertas posiciones en lugar de borrar la línea?

Cuando console.log() aparece como una sentencia independiente, el minificador elimina la sentencia y su delimitador por completo. Sin embargo, cuando una llamada a console.* reside dentro de una expresión (como en operadores ternarios isValid ? console.log(data) : null o cortocircuitos lógicos debug && console.warn(msg)), suprimir los tokens dejaría un árbol sintáctico incompleto. El minificador sustituye la llamada por void 0 (la expresión estándar en JavaScript que evalúa a undefined), garantizando la validez gramatical y eliminando el código de depuración.

¿Por qué deben preservarse los comentarios /*! licencia */ en distribuciones de producción?

Las licencias de código abierto —incluyendo MIT, BSD y Apache 2.0— exigen legalmente que los avisos de derechos de autor y términos de concesión permanezcan adjuntos a todas las redistribuciones, incluidos los recursos desplegados en clientes web. La convención /*! es el estándar universalmente adoptado que indica a minificadores y empaquetadores que conserven el encabezado legal mientras purgan todos los comentarios internos de desarrollo.

¿Se puede revertir o descompilar un código JavaScript minificado a su estado original?

Los formateadores y embellecedores de código pueden reestructurar la sangría visual y los saltos de línea para hacer el script legible y depurable. Sin embargo, los comentarios eliminados y los identificadores locales ofuscados (por ejemplo, una variable renombrada de clienteDireccionFacturacion a a) no se pueden recuperar algorítmicamente porque los símbolos originales se descartan en la compilación. Para restaurar los nombres de archivos, líneas y variables originales en las herramientas de desarrollo, es indispensable contar con los archivos Source Map (.map) generados durante la compilación inicial.