Comparar y combinar archivos

1. Dos archivos a la vez

«Comparar» no es una sola operación. Según lo que se quiera saber, y según qué clase de archivos se tenga delante, corresponde una herramienta distinta. Conviene tener el mapa antes de empezar:

Las tres primeras comparan: informan sobre las diferencias. La última combina: produce un archivo nuevo con datos de los dos. La distinción entre diff y comm es la más fina, y la que más importa elegir bien. Un programa, una carta o un archivo de configuración son textos: si dos líneas cambian de lugar, el archivo es otro. Una nómina de alumnos o una lista de paquetes instalados son conjuntos: lo que interesa es quién está, no en qué renglón.

Las cuatro tienen la misma forma, comando archivo1 archivo2, y ninguna modifica los archivos que recibe.

2. Los archivos de trabajo

Para comparar hacen falta parejas de archivos. Las fabricamos con lo aprendido en los temas anteriores, y las dejamos en /tmp para no alterar el directorio de práctica. La primera pareja es tareas.txt y una versión posterior, a la que se le quitó una tarea, se le corrigió otra y se le agregó una al final:

$ cd ~/practica
$ cp tareas.txt /tmp/copia.txt                                      # una copia exacta
$ sed -e '2d' -e 's/vim/awk/' -e '$a Sacar la basura' tareas.txt > /tmp/tareas2.txt
$ cat /tmp/tareas2.txt
Comprar pan
Pagar la luz
Estudiar awk
Regar las plantas
Sacar la basura

Las otras parejas salen de ventas.csv. Con awk obtenemos dos listas de productos, los vendidos en cada ciudad, y el total por vendedor. A mano escribimos una tabla con el objetivo de ventas de cada vendedor, donde figura uno, Pedro, que todavía no vendió nada:

$ awk -F, '$3 == "Rosario" {print $4}' ventas.csv | sort -u > /tmp/rosario.txt
$ awk -F, '$3 == "Mendoza" {print $4}' ventas.csv | sort -u > /tmp/mendoza.txt
$ awk -F, '{t[$2] += $6} END {for (v in t) print v "," t[v]}' ventas.csv | sort > /tmp/totales.csv
$ cat > /tmp/objetivos.csv << FIN
> Ana,600
> Luis,500
> Marta,350
> Pedro,300
> FIN
$ cat /tmp/totales.csv
Ana,731
Luis,495
Marta,395

Los tres archivos generados pasaron por sort, y el que escribimos a mano está en orden alfabético. No es un detalle de prolijidad: es el requisito de comm y de join, como veremos.

3. cmp: ¿son iguales?

La pregunta más simple admite solo sí o no. La responde cmp, de compare, que recorre los dos archivos byte por byte y se detiene en el primero que no coincide.

$ cmp tareas.txt /tmp/copia.txt              # sin salida: son idénticos
$ cmp tareas.txt /tmp/tareas2.txt
tareas.txt /tmp/tareas2.txt differ: byte 13, line 2

Como tantos comandos de Unix, cmp calla cuando no hay nada que decir: el silencio significa «iguales». Cuando difieren informa dónde empieza la diferencia —aquí, en el byte 13, que es el primero de la línea 2— y no sigue. No dice qué cambió, ni si hay más cambios.

Esa brevedad es su virtud. cmp no interpreta el contenido, de modo que sirve para cualquier archivo: imágenes, comprimidos, ejecutables. Y es rápido, porque abandona en la primera diferencia. Es la manera de comprobar que una copia salió bien.

Todo comando termina con un número, el código de salida, que la shell guarda en la variable $?: cero quiere decir «todo bien», y cualquier otro valor, que algo no resultó. En cmp y en diff el significado es el mismo:

$ cmp -s tareas.txt /tmp/copia.txt; echo $?
0
$ cmp -s tareas.txt /tmp/tareas2.txt; echo $?
1
$ cmp -s tareas.txt /tmp/copia.txt && echo "La copia está bien"
La copia está bien

La tercera forma es la que se usa en los scripts: el operador && ejecuta el segundo comando solo si el primero terminó con cero, es decir, solo si los archivos son iguales.

4. diff: qué cambió

Saber que dos archivos difieren rara vez alcanza. Lo que se necesita es ver las diferencias, y esa es la tarea de diff, una de las herramientas más influyentes de Unix.

diff compara dos archivos de texto línea por línea y muestra el conjunto mínimo de cambios que habría que hacerle al primero para convertirlo en el segundo.

$ diff tareas.txt /tmp/copia.txt             # sin salida: son iguales
$ diff tareas.txt /tmp/tareas2.txt
2d1
< Llamar a Luis
4c3
< Estudiar vim
---
> Estudiar awk
5a5
> Sacar la basura

La definición tiene dos ideas que conviene separar. La primera es que diff no muestra los archivos: muestra solo lo que cambió. Las líneas que no se tocaron, como «Comprar pan» y «Regar las plantas», no figuran en la salida. En un archivo de mil líneas con una sola modificada, la salida tendría cuatro renglones.

La segunda es que la comparación tiene dirección. El primer argumento es el punto de partida, «lo viejo»; el segundo, el de llegada, «lo nuevo». La salida es una receta para ir de uno a otro, y por eso el orden de los argumentos importa: invertidos, cada cosa que se quitó aparece como agregada.

Encontrar ese conjunto mínimo no es trivial. diff no compara la línea 1 con la 1 y la 2 con la 2: si lo hiciera, al faltar la segunda línea todas las siguientes parecerían distintas. Busca la secuencia más larga de líneas que los dos archivos comparten en el mismo orden, la toma como esqueleto, y describe lo demás como cambios. Por eso entendió que «Pagar la luz» era la misma línea, aunque pasó del renglón 3 al 2.

5. Leer la salida: a, d y c

La salida anterior está en el llamado formato normal. Parece críptica y se lee con dos reglas. La primera: las líneas que empiezan con < son del primer archivo, y las que empiezan con >, del segundo. La segunda: cada cambio va precedido de una orden, formada por números de línea y una letra.

4c3
│││
││└─ la línea correspondiente en el segundo archivo
│└─ la operación: c, cambiar
└─ la línea del primer archivo

El número de la izquierda se refiere siempre al primer archivo, y el de la derecha, al segundo. Con eso, la salida se traduce renglón por renglón:

2d1                  la línea 2 del primero se borró; habría quedado después de la 1 del segundo
< Llamar a Luis        esta es la línea que ya no está

4c3                  la línea 4 del primero cambió, y es ahora la 3 del segundo
< Estudiar vim         decía esto
---
> Estudiar awk         dice esto

5a5                  después de la línea 5 del primero se agregó la 5 del segundo
> Sacar la basura      esta es la línea nueva

Cuando el cambio abarca varias líneas, los números son rangos separados por una coma: 8,12c8,10 quiere decir que las líneas 8 a 12 del primero fueron reemplazadas por las 8 a 10 del segundo.

Las letras resultarán familiares. Son las órdenes a, d y c de sed, del tema 29, y no por casualidad: este formato nació como un guion para el editor ed, el antepasado común. Una regla para no confundir los signos: < apunta hacia la izquierda, hacia el primer argumento; >, hacia la derecha, hacia el segundo.

6. El formato unificado

El formato normal tiene un defecto: muestra los cambios sin lo que los rodea. Dice «la línea 4 cambió», pero no se ve qué hay en la 3 ni en la 5, y en un archivo grande eso obliga a ir a mirarlo. La opción -u produce un formato más legible, que es hoy el habitual.

$ diff -u tareas.txt /tmp/tareas2.txt
--- tareas.txt	2026-10-12 11:05:41.318402117 -0300
+++ /tmp/tareas2.txt	2026-10-20 09:14:02.551873340 -0300
@@ -1,5 +1,5 @@
 Comprar pan
-Llamar a Luis
 Pagar la luz
-Estudiar vim
+Estudiar awk
 Regar las plantas
+Sacar la basura

Aquí los dos archivos aparecen fundidos en uno, de ahí el nombre, y el primer carácter de cada línea dice a cuál pertenece:

Una línea modificada se muestra como una que se quita y otra que se agrega, juntas: es lo que ocurre con «Estudiar vim» y «Estudiar awk». La marca del bloque se lee así: -1,5, «en el archivo viejo, desde la línea 1, cinco líneas»; +1,5, «en el nuevo, desde la línea 1, cinco líneas».

Alrededor de cada cambio se muestran tres líneas de contexto; -U 1 pide una sola, -U 0 ninguna. En un archivo largo, los cambios alejados entre sí forman bloques separados, cada uno con su marca @@, y lo que hay entre ellos se omite.

7. Lado a lado, y qué ignorar

Hay una tercera presentación, la más intuitiva para archivos cortos: los dos archivos en columnas paralelas. Se pide con -y, y -W fija el ancho total:

$ diff -y -W 50 tareas.txt /tmp/tareas2.txt
Comprar pan             Comprar pan
Llamar a Luis         <
Pagar la luz            Pagar la luz
Estudiar vim          | Estudiar awk
Regar las plantas       Regar las plantas
                      > Sacar la basura

En la columna central, < marca una línea que solo está a la izquierda, > una que solo está a la derecha, y | una que cambió. Con --suppress-common-lines se ocultan las que no tienen marca. Las líneas largas se cortan para caber: por eso este formato sirve para mirar, y no para guardar.

El otro grupo de opciones decide qué cuenta como diferencia. Para diff, una línea con un espacio de más es otra línea. A veces esa exigencia estorba: se quiere saber si cambió el contenido, no la presentación.

$ sed 's/Comprar/COMPRAR/; s/Regar las/Regar   las/' tareas.txt > /tmp/t3.txt
$ diff tareas.txt /tmp/t3.txt
1c1
< Comprar pan
---
> COMPRAR pan
5c5
< Regar las plantas
---
> Regar   las plantas
$ diff -i tareas.txt /tmp/t3.txt             # sin contar las mayúsculas
5c5
< Regar las plantas
---
> Regar   las plantas
$ diff -i -b tareas.txt /tmp/t3.txt          # ni los espacios repetidos: iguales
$ diff -q tareas.txt /tmp/t3.txt
Files tareas.txt and /tmp/t3.txt differ

-q, de quiet, reduce todo a una línea. Es lo que haría cmp, con una diferencia: diff -q acepta las opciones de esta sección. «¿Son iguales, sin contar los espacios?» solo puede responderlo diff -qw.

8. Comparar directorios

Si los dos argumentos son directorios, diff compara los archivos que tienen el mismo nombre en uno y en otro, e informa cuáles existen en uno solo. Con -r desciende además por los subdirectorios. Armamos dos directorios pequeños, como si fueran dos versiones de un proyecto:

$ mkdir /tmp/v1 /tmp/v2
$ cp tareas.txt ventas.csv /tmp/v1
$ cp ventas.csv /tmp/objetivos.csv /tmp/v2
$ cp /tmp/tareas2.txt /tmp/v2/tareas.txt     # mismo nombre, otro contenido
$ diff -rq /tmp/v1 /tmp/v2
Only in /tmp/v2: objetivos.csv
Files /tmp/v1/tareas.txt and /tmp/v2/tareas.txt differ

La combinación -rq da el resumen: una línea por cada archivo que sobra, que falta o que cambió. ventas.csv, idéntico en los dos, no se menciona. Es la primera pregunta ante dos copias de un proyecto, o ante un respaldo y su original: ¿en qué archivos hay diferencias? Sin la -q, a continuación de cada pareja distinta aparece su comparación completa:

$ diff -r /tmp/v1 /tmp/v2
Only in /tmp/v2: objetivos.csv
diff -r /tmp/v1/tareas.txt /tmp/v2/tareas.txt
2d1
< Llamar a Luis
4c3
< Estudiar vim
---
> Estudiar awk
5a5
> Sacar la basura

Es la comprobación que hicimos en el tema 15 después de extraer un archivo tar: diff -r entre el original y lo extraído, sin salida, certificaba que el respaldo estaba completo. Se combina con -u para el detalle en formato unificado, y con --exclude='*.log' para dejar fuera lo que no interesa comparar.

9. patch: aplicar las diferencias

La salida de diff es, dijimos, una receta para transformar un archivo en otro. Es una receta que se puede ejecutar. El programa que lo hace es patch, y el archivo con las diferencias se llama, por eso, parche.

$ diff -u tareas.txt /tmp/tareas2.txt > /tmp/cambios.patch    # guardar las diferencias
$ cp tareas.txt /tmp/t.txt                                    # una copia del original
$ patch /tmp/t.txt < /tmp/cambios.patch                       # aplicarle los cambios
patching file /tmp/t.txt
$ cmp /tmp/t.txt /tmp/tareas2.txt                             # sin salida: quedó igual al nuevo
$ patch -R /tmp/t.txt < /tmp/cambios.patch                    # deshacer
patching file /tmp/t.txt
$ cmp /tmp/t.txt tareas.txt                                   # sin salida: volvió al original

La copia del archivo viejo, más el parche, dio exactamente el archivo nuevo. Y con -R, de reverse, el mismo parche se aplicó al revés. A diferencia de las herramientas del tema, patch sí modifica el archivo que recibe.

La idea tiene más alcance del que parece. Quien corrige tres líneas en un programa de cien mil no necesita enviar el programa: envía el parche, unos pocos renglones que cualquiera puede leer antes de aceptar. Las líneas de contexto del formato unificado le permiten a patch encontrar el lugar correcto aunque el archivo de destino haya cambiado un poco. Así se desarrolló el software libre durante décadas, con parches enviados por correo, y sobre esa misma idea —guardar los cambios, no las copias— están construidos los sistemas de control de versiones como Git.

10. comm: comparar dos listas

Cambiamos de clase de archivo. Las dos listas de productos de la sección 2 no son textos donde importe el renglón: son conjuntos. La pregunta ya no es «qué línea cambió», sino «qué elementos tienen en común, y cuáles son de una sola».

comm compara dos archivos ordenados línea por línea, y reparte las líneas en tres columnas: las que están solo en el primero, las que están solo en el segundo, y las comunes a los dos.

$ paste /tmp/rosario.txt /tmp/mendoza.txt    # las dos listas, lado a lado
cable	monitor
monitor	mouse
teclado	
$ comm /tmp/rosario.txt /tmp/mendoza.txt
cable
		monitor
	mouse
teclado

La salida es una sola lista, con todos los productos en orden, y lo que informa es la sangría de cada uno. Sin sangría, primera columna: solo se vende en Rosario. Con una tabulación, segunda columna: solo en Mendoza. Con dos, tercera columna: en las dos ciudades.

Casi nunca se quieren las tres columnas juntas. Las opciones -1, -2 y -3 hacen algo que al principio se lee al revés: suprimen la columna indicada. Para ver una, se quitan las otras dos:

$ comm -12 /tmp/rosario.txt /tmp/mendoza.txt     # se vende en las dos ciudades
monitor
$ comm -23 /tmp/rosario.txt /tmp/mendoza.txt     # en Rosario, y no en Mendoza
cable
teclado
$ comm -13 /tmp/rosario.txt /tmp/mendoza.txt     # en Mendoza, y no en Rosario
mouse

Con una sola columna a la vista no queda sangría, y la salida es una lista limpia, apta para seguir en una tubería. Es la respuesta directa a la tercera pregunta con que abrimos el tema: con los inscriptos en un archivo y los que pagaron en otro, comm -23 inscriptos.txt pagaron.txt entrega los que deben.

11. join: cruzar dos tablas

La última herramienta no compara: combina. Tenemos dos tablas que hablan de las mismas personas. Una dice cuánto vendió cada vendedor; la otra, cuánto debía vender. Para saber quién cumplió hay que poner los dos datos en un mismo renglón.

join une las líneas de dos archivos que tienen el mismo valor en un campo, llamado clave. Por cada pareja escribe una línea con la clave, los demás campos del primer archivo y los demás campos del segundo.

$ join -t, /tmp/totales.csv /tmp/objetivos.csv
Ana,731,600
Luis,495,500
Marta,395,350

totales.csv        objetivos.csv        resultado

Ana,731       +    Ana,600         →    Ana,731,600
Luis,495      +    Luis,500        →    Luis,495,500
Marta,395     +    Marta,350       →    Marta,395,350
                   Pedro,300            (sin pareja: no aparece)

La opción -t indica el separador de campos, como en sort; sin ella, join separa por espacios. Si no se dice otra cosa, la clave es el primer campo de cada archivo. Pedro está en un solo archivo, no tiene con quién unirse, y queda fuera.

No hay que confundir esto con paste, del tema 26, que también junta dos archivos. paste une la línea 1 con la línea 1 y la 2 con la 2, por su posición, sin mirar qué dicen. join une por contenido: busca en el otro archivo la línea que tiene la misma clave. Si a uno de los archivos le faltara una fila, paste desalinearía todo lo que sigue; join no.

El resultado es un archivo de campos como cualquier otro, y se lo puede seguir procesando. Con el awk del tema anterior, la respuesta a la pregunta:

$ join -t, /tmp/totales.csv /tmp/objetivos.csv | awk -F, '{print $1, $2 - $3}'
Ana 131
Luis -5
Marta 45

Ana y Marta superaron su objetivo; a Luis le faltaron cinco pesos. Quien haya trabajado con bases de datos habrá reconocido la operación: es el JOIN de SQL, y también el BUSCARV de las planillas de cálculo, hecho con archivos de texto.

12. join: columnas, y filas sin pareja

Dos cosas quedaron fijas en el ejemplo anterior y se pueden ajustar: cuál es el campo clave de cada archivo, y qué pasa con las líneas que no encuentran pareja.

$ join -t, -v 2 /tmp/totales.csv /tmp/objetivos.csv      # tienen objetivo y no tienen ventas
Pedro,300
$ join -t, -a 2 /tmp/totales.csv /tmp/objetivos.csv      # todos los del segundo archivo
Ana,731,600
Luis,495,500
Marta,395,350
Pedro,300

Con -a 2 Pedro aparece, pero su línea tiene dos campos donde las demás tienen tres, y el 300 quedó en la columna de las ventas. Para que la tabla salga pareja hay que decir qué campos se quieren, con -o, y con qué rellenar los que falten, con -e:

$ join -t, -a 2 -e 0 -o 0,1.2,2.2 /tmp/totales.csv /tmp/objetivos.csv
Ana,731,600
Luis,495,500
Marta,395,350
Pedro,0,300

En la lista de -o, cada campo se nombra con el número del archivo, un punto y el número del campo: 1.2 es el segundo campo del primer archivo. El 0 representa la clave, venga del archivo que venga.

Las opciones -1 y -2 permiten cruzar archivos donde la clave no es el primer campo. En ventas.csv el vendedor es el segundo, y el archivo está ordenado por fecha. Hay que ordenarlo antes por ese campo; lo hacemos al paso, con la sustitución de procesos del tema 25:

$ join -t, -1 2 -2 1 <(sort -t, -k2,2 ventas.csv) /tmp/objetivos.csv | head -n 4
Ana,2026-10-02,Salta,mouse,5,75,600
Ana,2026-10-03,Mendoza,monitor,2,640,600
Ana,2026-10-05,Rosario,cable,4,16,600
Luis,2026-10-01,Rosario,teclado,2,90,500
$ join -t, -1 2 -2 1 -o 1.1,0,1.6,2.2 <(sort -t, -k2,2 ventas.csv) /tmp/objetivos.csv | head -n 3
2026-10-02,Ana,75,600
2026-10-03,Ana,640,600
2026-10-05,Ana,16,600

Dos cosas para observar. La clave se escribe primero, aunque en el archivo original fuera el segundo campo; con -o se la vuelve a poner donde se quiera. Y la línea de objetivos de Ana se unió con sus tres ventas: cuando una clave se repite en un archivo, se forman todas las parejas posibles.

13. Comparar salidas de comandos

En este tema todo fueron archivos, y sin embargo lo que más se quiere comparar a menudo no está en ningún archivo: son las salidas de dos comandos. Una tubería no alcanza, porque estas herramientas esperan dos nombres de archivo. El recurso es el que acabamos de usar, y que en el tema 25 presentamos justamente con diff:

La sustitución de procesos, <(comando), ejecuta el comando y pone en su lugar un nombre de archivo del que se puede leer su salida.

$ diff <(ls /tmp/v1) <(ls /tmp/v2)           # qué nombres hay en un directorio y no en el otro
0a1
> objetivos.csv
$ comm -13 <(cut -d, -f2 ventas.csv | sort -u) <(cut -d, -f1 /tmp/objetivos.csv)
Pedro

El segundo comando responde «¿qué vendedores tienen objetivo y ninguna venta?» sin haber creado ningún archivo intermedio: cada lista se arma, se ordena y se entrega en el momento. Es la forma en que comm y join se usan casi siempre, porque resuelve de paso la exigencia del orden: el sort va adentro.

La primera fila es una manera de practicar el procedimiento prudente del tema 29: ver exactamente qué líneas cambiaría una orden de sed antes de aplicarla con -i. Y cuando diff no tiene más que un archivo y una tubería, acepta un guion en lugar de un nombre para leer de su entrada estándar: sort a | diff - b.

14. Recetas y errores comunes

La referencia del tema:

Los archivos de /tmp pueden quedar; el directorio de práctica no se modificó. Con este tema termina el bloque dedicado al texto: buscar con grep, describir formas con expresiones regulares, editar con sed, calcular con awk, y ahora comparar y cruzar. Hasta aquí la terminal fue una manera de trabajar con archivos. En el tema 32 empezamos a mirar lo que está vivo en el sistema: los programas en ejecución, es decir, los procesos.

15. Resumen

• Para comparar hay que saber qué se tiene: diff es para textos, donde importa la posición de cada línea; comm, para listas, donde no importa.
• cmp dice si dos archivos son idénticos, byte por byte, y sirve para cualquier tipo de archivo. Si son iguales no escribe nada.
• cmp y diff terminan con código 0 si los archivos son iguales, 1 si difieren y 2 si hubo un error.
• diff viejo nuevo muestra los cambios mínimos para pasar del primero al segundo. El orden de los argumentos importa.
• En el formato normal, < marca líneas del primer archivo y > del segundo; las órdenes a, d y c indican agregado, borrado y cambio.
• diff -u produce el formato unificado: - para lo quitado, + para lo agregado, y líneas de contexto. Es el que usan Git y los parches.
• diff -y muestra los archivos lado a lado; -i, -b, -w y -B ignoran mayúsculas, espacios y líneas vacías; -q solo avisa.
• diff -r compara dos directorios; con -q, lista qué archivos difieren o faltan.
• patch aplica a un archivo las diferencias guardadas por diff, y con -R las deshace.
• comm separa las líneas de dos archivos ordenados en tres columnas; -12 deja las comunes, -23 y -13 las exclusivas de cada uno.
• join une las líneas de dos archivos que tienen la misma clave. Con -t se da el separador; con -1 y -2, el campo clave; con -a y -v, las filas sin pareja.
• comm y join exigen archivos ordenados con sort; join, por el campo clave.
• Con <(comando) se comparan salidas de comandos sin crear archivos intermedios.

16. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Ejecuta diff /tmp/tareas2.txt tareas.txt, con los argumentos invertidos. Antes, escribe en un papel la salida que esperas.
2. Copia tareas.txt a /tmp, modifícalo con nano —borra una línea, cambia otra, agrega dos— y compáralo con el original en los tres formatos: normal, -u y -y.
3. Obtén con sed una versión de ventas.csv donde Salta sea SALTA. Compárala con el original con diff, con diff -i y con diff -q. ¿Cuántas líneas cambiaron?
4. Compara ventas.csv con sort ventas.csv usando la sustitución de procesos. Luego ordénalo por importe y compara de nuevo. ¿Por qué la segunda salida es tanto más larga?
5. Con una copia de informe.txt en /tmp, cambia tcp por TCP con sed -i.bak, genera un parche con diff -u entre el respaldo y el resultado, y aplícalo con patch a otra copia del original. Verifica con cmp.
6. Copia ~/practica a /tmp/practica2, borra allí un archivo, modifica otro y crea uno nuevo. Encuentra los tres cambios con diff -rq.
7. Con comm y la sustitución de procesos, averigua qué productos vendió Luis que no vendió Ana, cuáles vendieron los dos, y qué ciudades visitó Marta que no visitó Luis.
8. Averigua con comm qué comandos están en /usr/bin y no en /usr/sbin, y cuántos nombres comparten.
9. Crea /tmp/precios.csv con el precio de lista de cada producto (cable,5, monitor,350…). Crúzalo con ventas.csv por el producto, y con awk muestra las ventas hechas por debajo del precio de lista.
10. Prueba join /tmp/totales.csv /tmp/objetivos.csv, sin -t, y comm tareas.txt /tmp/tareas2.txt. Explica los dos resultados.