Comando join de Linux: Unión de archivos

Introducción

En este laboratorio, aprenderás cómo utilizar el comando join en Linux para combinar datos de múltiples archivos. Simularemos un escenario en el que estás trabajando en el departamento de recursos humanos de una empresa y necesitas combinar la información de los empleados de diferentes bases de datos. Este ejercicio práctico demostrará la potencia y flexibilidad del comando join para tareas de procesamiento de datos.

Skills Graph

Comprender los archivos de datos

Comencemos examinando el contenido de nuestros archivos de datos de empleados. Tenemos dos archivos: employees.txt y salaries.txt.

Primero, cambia al directorio del proyecto:

cd /home/labex/project

Este comando cambia tu directorio de trabajo actual a /home/labex/project. Todas las operaciones subsiguientes se realizarán en este directorio.

Ahora, veamos el contenido de employees.txt:

cat employees.txt

El comando cat muestra el contenido del archivo. Deberías ver una salida similar a esta:

1001 John Engineering
1002 Sarah Marketing
1003 Mike Sales
1004 Emily HR
1005 David Finance

Cada línea representa un empleado con su ID, nombre y departamento.

A continuación, echemos un vistazo a salaries.txt:

cat salaries.txt

La salida debería ser similar a:

1001 75000
1002 65000
1003 70000
1004 60000
1005 80000

Este archivo contiene los IDs de los empleados y sus salarios correspondientes.

Estos archivos representan bases de datos separadas que combinaremos utilizando el comando join.

Operación básica de unión (join)

Ahora que comprendemos nuestros datos, usemos el comando join para combinar la información de ambos archivos basándonos en el ID del empleado.

Ejecuta el siguiente comando:

join employees.txt salaries.txt

Deberías ver una salida como esta:

1001 John Engineering 75000
1002 Sarah Marketing 65000
1003 Mike Sales 70000
1004 Emily HR 60000
1005 David Finance 80000

Analicemos lo que sucedió:

1. El comando join examinó el primer campo (ID del empleado) en ambos archivos.
2. Cuando encontró IDs coincidentes, combinó las líneas de ambos archivos.
3. La salida muestra el ID del empleado, seguido de todos los campos de employees.txt y luego todos los campos de salaries.txt (excepto el ID, que sería redundante).

Esto nos da una vista completa de la información de cada empleado en una sola línea. El comando join es especialmente útil cuando tienes datos divididos en múltiples archivos pero quieres verlos o analizarlos juntos.

Personalizar la salida de la unión (join)

A veces, es posible que queramos cambiar el orden de los campos en nuestra salida o incluir solo campos específicos. Podemos hacer esto especificando los números de campo después del comando de unión (join).

Prueba este comando:

join -o 1.2,1.3,2.2,1.1 employees.txt salaries.txt

Deberías ver:

John Engineering 75000 1001
Sarah Marketing 65000 1002
Mike Sales 70000 1003
Emily HR 60000 1004
David Finance 80000 1005

Analicemos la opción -o:

• -o significa "formato de salida" (output format)
• 1.2 significa el segundo campo del primer archivo (nombre)
• 1.3 significa el tercer campo del primer archivo (departamento)
• 2.2 significa el segundo campo del segundo archivo (salario)
• 1.1 significa el primer campo del primer archivo (ID del empleado)

Esto nos permite personalizar el orden de la información en nuestra salida. Es especialmente útil cuando necesitas reorganizar los datos para un formato de informe específico o cuando solo necesitas ciertos campos de cada archivo.

Manejo de registros no coincidentes

En escenarios del mundo real, es posible que tengas registros en un archivo que no tengan coincidencias correspondientes en el otro archivo. Simulemos esto agregando un nuevo empleado al que aún no se le ha asignado un salario.

Agrega este empleado a employees.txt:

echo "1006 Alex IT" >> employees.txt

El operador >> agrega la nueva línea al final del archivo sin sobrescribir el contenido existente.

Ahora, si ejecutamos nuestro comando básico de unión (join):

join employees.txt salaries.txt

Notarás que Alex no aparece en la salida porque no hay un registro coincidente en salaries.txt.

Para incluir los registros no coincidentes, podemos usar la opción -a:

join -a 1 employees.txt salaries.txt

Ahora deberías ver a Alex en la salida:

1001 John Engineering 75000
1002 Sarah Marketing 65000
1003 Mike Sales 70000
1004 Emily HR 60000
1005 David Finance 80000
1006 Alex IT

La opción -a 1 le dice a join que incluya las líneas no coincidentes del primer archivo (employees.txt). Esto es útil cuando quieres ver todos los registros de un archivo, incluso si no tienen coincidencias en el otro archivo.

Realizar una unión (join) en un campo diferente

Hasta ahora, hemos estado uniendo nuestros archivos basándonos en el primer campo (ID del empleado). Pero, ¿qué pasa si queremos unirnos basándonos en un campo diferente? Esto puede ser útil cuando tus archivos están organizados de manera diferente o cuando necesitas combinar datos basados en un atributo común que no sea un ID.

Creemos un nuevo archivo llamado departments.txt con códigos de departamento:

cat << EOF > departments.txt
Engineering ENG
Marketing MKT
Sales SLS
HR HRS
Finance FIN
IT ITS
EOF

Este comando crea un nuevo archivo departments.txt con nombres de departamento y sus códigos correspondientes.

Ahora, unamos esto con nuestro archivo employees.txt basándonos en el nombre del departamento:

join -1 3 -2 1 employees.txt departments.txt

Deberías ver:

Engineering 1001 John ENG
Marketing 1002 Sarah MKT
Sales 1003 Mike SLS
HR 1004 Emily HRS
Finance 1005 David FIN
IT 1006 Alex ITS

Analicemos el comando:

• -1 3 le dice a join que use el tercer campo del primer archivo (employees.txt) como campo de unión (join field)
• -2 1 le dice que use el primer campo del segundo archivo (departments.txt) como campo de unión (join field)

Esto nos permite unir archivos basados en cualquier campo común, no solo en el primero. Es especialmente útil cuando tus archivos tienen estructuras diferentes pero comparten alguna información común.

Resumen

En este laboratorio, aprendiste cómo usar el comando join en Linux para combinar datos de múltiples archivos. Exploramos varias características clave de join:

• Unión básica de dos archivos basada en un campo común
• Personalización del orden de salida usando la opción -o
• Inclusión de registros no coincidentes con la opción -a
• Unión en campos distintos de la primera columna usando las opciones -1 y -2

Otras opciones de join no cubiertas en este laboratorio incluyen:

• -t CHAR: Utiliza CHAR como separador de campos de entrada y salida
• -i: Ignora las diferencias de mayúsculas y minúsculas al comparar campos
• -e STRING: Reemplaza los campos de entrada faltantes con STRING
• -j FIELD: Equivalente a '-1 FIELD -2 FIELD'
• -v FILE_NUMBER: Similar a -a FILE_NUMBER, pero suprime las líneas de salida unidas

El comando join es una herramienta poderosa para el procesamiento de datos en Linux, que te permite combinar información de múltiples fuentes de manera eficiente. A medida que sigas trabajando con datos en tu entorno Linux, recuerda que join puede ser un activo valioso para combinar y analizar información de diferentes archivos.

Recursos

• Linux Roadmap - roadmap.sh