Comparador de Textos

Compara dos textos lado a lado y resalta las diferencias línea por línea

Prueba un ejemplo

Texto A

Texto B

Se ejecuta localmente · Es seguro pegar secretos
Se ejecuta localmente · Es seguro pegar secretos

¿Qué es Text Diff?

Un text diff (abreviatura de "difference", diferencia) es el resultado de comparar dos bloques de texto e identificar qué líneas fueron añadidas, eliminadas o dejadas sin cambios. El concepto tiene su origen en la utilidad Unix diff, publicada por primera vez en 1974 como parte de Version 5 Unix. Hoy en día, el text diff es la base de los sistemas de control de versiones como Git, donde cada commit almacena un diff en lugar de una copia completa de cada archivo.

Un algoritmo de diff encuentra la Subsecuencia Común más Larga (LCS) entre dos secuencias de líneas. Las líneas presentes en el LCS se marcan como sin cambios. Las líneas del texto original que no están en el LCS se marcan como eliminadas. Las líneas del texto modificado que no están en el LCS se marcan como añadidas. El resultado es el conjunto mínimo de cambios necesarios para transformar un texto en el otro.

La salida del diff existe en varios formatos. El unified diff (el predeterminado para git diff) prefija las líneas eliminadas con un signo menos y las líneas añadidas con un signo más. El diff lado a lado organiza ambos textos en columnas paralelas. Esta herramienta usa comparación línea por línea con salida codificada por colores: verde para adiciones, rojo para eliminaciones y neutro para líneas sin cambios. Las líneas sin cambios se muestran sin prefijo por defecto, pero pueden ocultarse para centrarse solo en lo que cambió.

¿Por qué usar una herramienta de diff de texto online?

Comparar texto en un terminal requiere instalar utilidades diff y manejar opciones de línea de comandos. Una herramienta diff en el navegador elimina ese obstáculo por completo.

Comparación instantánea
Pega dos bloques de texto y ve las diferencias resaltadas de inmediato. Sin crear archivos, sin comandos que recordar, sin salidas que interpretar.
🔒
Procesamiento con privacidad garantizada
Toda la comparación ocurre en tu navegador usando JavaScript. Tu texto nunca abandona tu dispositivo, lo que importa al comparar archivos de configuración, credenciales o código propietario.
📋
Salida lista para copiar
La salida del diff usa los prefijos estándar + / - compatibles con el formato unified diff. Puedes copiar el resultado directamente en mensajes de commit, comentarios de revisión de código o reportes de errores.
🌐
Sin registro ni instalación
Funciona en cualquier dispositivo con navegador. Sin crear cuenta, sin extensiones, sin aplicación de escritorio. Abre la página y empieza a comparar.

Casos de uso del diff de texto

Desarrollo frontend
Compara la salida de CSS o HTML minificado antes y después de un paso de compilación para detectar cambios no deseados en el marcado o los estilos generados.
Ingeniería backend
Haz diff de respuestas API entre entornos (staging vs producción) para verificar que un despliegue no introdujo cambios de datos inesperados.
DevOps e Infraestructura
Compara manifests de Kubernetes, planes de Terraform o configuraciones de Nginx antes de aplicar cambios a un clúster o servidor en producción.
QA y Testing
Verifica que la salida de las pruebas coincide con las líneas base esperadas comparando el resultado real contra un archivo de snapshot almacenado.
Ingeniería de datos
Compara cabeceras CSV o definiciones de esquemas SQL entre migraciones de base de datos para confirmar que las columnas fueron añadidas o renombradas correctamente.
Aprendizaje y cursos
Compara tu solución con una implementación de referencia línea por línea para encontrar dónde tu lógica se aleja del enfoque esperado.

Comparativa de formatos de salida diff

Las herramientas de diff producen salida en varios formatos. La tabla siguiente resume los más comunes, qué los genera y cuándo es útil cada uno.

FormatoHerramienta / FuenteDescripción
Unified diffdiff -u / git diffPrefixes lines with + / - / space; includes @@ hunk headers
Side-by-sidediff -y / sdiffTwo columns, changed lines aligned horizontally
Context diffdiff -cShows changed lines with surrounding context, marked with ! / + / -
HTML diffPython difflibColor-coded HTML table with inline change highlights
JSON PatchRFC 6902Array of add/remove/replace operations on a JSON document

Cómo funciona el diff de líneas: el algoritmo LCS

La mayoría de las herramientas de diff de líneas, incluida esta, usan el algoritmo de Subsecuencia Común más Larga (LCS). El LCS encuentra el mayor conjunto de líneas que aparecen en ambos textos en el mismo orden relativo, sin necesidad de que sean contiguas. Las líneas que no están en el LCS son las diferencias reales.

El algoritmo LCS estándar usa programación dinámica y se ejecuta en tiempo O(m x n), donde m y n son los recuentos de líneas de los dos textos. Para archivos grandes, variantes optimizadas como el algoritmo de diff de Myers (usado por Git) lo reducen a O(n + d^2), donde d es el número de diferencias, lo que lo hace rápido cuando la mayoría de las líneas son compartidas.

1. Construir la tabla DP
Crea una matriz de (m+1) x (n+1). Para cada par de líneas, almacena la longitud de la subsecuencia común más larga vista hasta ese momento. Las líneas iguales extienden el valor diagonal en 1.
2. Retroceder
Recorre desde la esquina inferior derecha de la matriz hasta (0,0). Los movimientos diagonales en líneas iguales producen entradas "sin cambios". Los movimientos horizontales o verticales producen entradas "añadida" o "eliminada".
3. Renderizar la salida
Asigna a cada entrada una línea de visualización: las líneas sin cambios no reciben prefijo, las líneas añadidas reciben +, las eliminadas reciben -. Aplica codificación de colores para mayor claridad visual.

Ejemplos de código

Implementaciones de comparación de texto línea por línea en JavaScript, Python, Go y la línea de comandos. Cada ejemplo produce salida en formato unified diff.

JavaScript
// Line-by-line diff using the LCS algorithm
function diffLines(a, b) {
  const linesA = a.split('\n')
  const linesB = b.split('\n')

  // Build LCS table
  const m = linesA.length, n = linesB.length
  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0))
  for (let i = 1; i <= m; i++)
    for (let j = 1; j <= n; j++)
      dp[i][j] = linesA[i-1] === linesB[j-1]
        ? dp[i-1][j-1] + 1
        : Math.max(dp[i-1][j], dp[i][j-1])

  // Backtrack to produce diff
  const result = []
  let i = m, j = n
  while (i > 0 || j > 0) {
    if (i > 0 && j > 0 && linesA[i-1] === linesB[j-1]) {
      result.unshift({ type: 'equal', text: linesA[i-1] }); i--; j--
    } else if (j > 0 && (i === 0 || dp[i][j-1] >= dp[i-1][j])) {
      result.unshift({ type: 'add', text: linesB[j-1] }); j--
    } else {
      result.unshift({ type: 'remove', text: linesA[i-1] }); i--
    }
  }
  return result
}

const diff = diffLines("alpha\nbeta\ngamma", "alpha\nbeta changed\ngamma\ndelta")
// → [
//   { type: 'equal',  text: 'alpha' },
//   { type: 'remove', text: 'beta' },
//   { type: 'add',    text: 'beta changed' },
//   { type: 'equal',  text: 'gamma' },
//   { type: 'add',    text: 'delta' }
// ]
Python
import difflib

text_a = """alpha
beta
gamma""".splitlines()

text_b = """alpha
beta changed
gamma
delta""".splitlines()

# Unified diff (same format as git diff)
for line in difflib.unified_diff(text_a, text_b, fromfile='a.txt', tofile='b.txt', lineterm=''):
    print(line)
# --- a.txt
# +++ b.txt
# @@ -1,3 +1,4 @@
#  alpha
# -beta
# +beta changed
#  gamma
# +delta

# HTML side-by-side diff
d = difflib.HtmlDiff()
html = d.make_file(text_a, text_b, fromdesc='Original', todesc='Modified')
Go
package main

import (
	"fmt"
	"strings"
)

// Minimal LCS-based line diff
func diffLines(a, b string) {
	la := strings.Split(a, "\n")
	lb := strings.Split(b, "\n")
	m, n := len(la), len(lb)

	dp := make([][]int, m+1)
	for i := range dp {
		dp[i] = make([]int, n+1)
	}
	for i := 1; i <= m; i++ {
		for j := 1; j <= n; j++ {
			if la[i-1] == lb[j-1] {
				dp[i][j] = dp[i-1][j-1] + 1
			} else if dp[i-1][j] >= dp[i][j-1] {
				dp[i][j] = dp[i-1][j]
			} else {
				dp[i][j] = dp[i][j-1]
			}
		}
	}

	var result []string
	i, j := m, n
	for i > 0 || j > 0 {
		if i > 0 && j > 0 && la[i-1] == lb[j-1] {
			result = append([]string{" " + la[i-1]}, result...)
			i--; j--
		} else if j > 0 && (i == 0 || dp[i][j-1] >= dp[i-1][j]) {
			result = append([]string{"+" + lb[j-1]}, result...)
			j--
		} else {
			result = append([]string{"-" + la[i-1]}, result...)
			i--
		}
	}

	for _, line := range result {
		fmt.Println(line)
	}
}

// Output:
//  alpha
// -beta
// +beta changed
//  gamma
// +delta
CLI (diff / git)
# Compare two files with unified diff (3 lines of context)
diff -u original.txt modified.txt

# Git diff between working tree and last commit
git diff HEAD -- file.txt

# Git diff between two branches
git diff main..feature -- src/

# Side-by-side diff in the terminal
diff -y --width=120 original.txt modified.txt

# Color-coded diff (requires colordiff)
diff -u original.txt modified.txt | colordiff

Preguntas frecuentes

¿Cuál es la diferencia entre un diff de líneas y un diff de caracteres?
Un diff de líneas compara el texto línea por línea: si cambia cualquier carácter de una línea, la línea completa se marca como eliminada y la nueva versión se marca como añadida. Un diff de caracteres (o diff de palabras) opera con mayor granularidad, marcando los caracteres o palabras específicos que cambiaron dentro de una línea. El diff de líneas es el estándar para revisión de código; el diff de caracteres es más útil para edición de prosa.
¿Cómo funciona git diff internamente?
Git usa el algoritmo de diff de Myers por defecto, que encuentra el script de edición más corto (el mínimo número de inserciones y eliminaciones) entre dos archivos. Git almacena el resultado en formato unified diff con cabeceras de bloque @@ que indican los números de línea. Cuando ejecutas git diff, Git compara el árbol de trabajo contra el índice (área de staging), no el último commit, a menos que pases HEAD explícitamente.
¿Puedo hacer diff de archivos binarios con una herramienta de diff de texto?
No. Las herramientas de diff de texto dividen la entrada en caracteres de nueva línea y comparan cadenas. Los archivos binarios contienen secuencias de bytes arbitrarias que producen divisiones de línea sin sentido. Para comparación binaria, usa una herramienta de hex diff o una comparación de checksum a nivel de archivo (sha256sum en ambos archivos).
¿Se envían mis datos a un servidor al usar esta herramienta?
No. Esta herramienta se ejecuta completamente en tu navegador. El cálculo del diff usa una implementación LCS en JavaScript que se ejecuta en el lado del cliente. No se realizan solicitudes de red con el contenido de tu texto. Puedes verificarlo abriendo la pestaña de Red de tu navegador mientras usas la herramienta.
¿Qué es el formato unified diff?
Unified diff es el formato de salida usado por diff -u y git diff. Muestra las líneas modificadas con los prefijos - (eliminadas) y + (añadidas), precedidos por cabeceras @@ que especifican los rangos de números de línea en ambos archivos. Las líneas de contexto (sin cambios) tienen un prefijo de espacio. Unified diff es el formato más común para parches, pull requests y herramientas de revisión de código.
¿Cómo comparo archivos grandes con muchas diferencias?
Para archivos de miles de líneas, una herramienta en el navegador funciona pero puede ralentizarse porque el algoritmo LCS escala cuadráticamente. Para diffs muy grandes, herramientas de línea de comandos como diff o git diff son más rápidas porque usan implementaciones en C optimizadas y pueden transmitir la salida. También puedes filtrar las líneas sin cambios (desactiva "Mostrar líneas sin cambios" en esta herramienta) para centrarte solo en los cambios.
¿Qué es un diff de fusión a tres bandas?
Un diff de fusión a tres bandas compara dos versiones modificadas de un archivo contra su ancestro común (la base). Git lo usa durante git merge y git rebase. Identifica los cambios realizados en cada rama respecto a la base y los combina. Cuando ambas ramas modifican la misma línea, Git reporta un conflicto de fusión. La fusión a tres bandas requiere tres entradas, mientras que un diff estándar solo necesita dos.