Unión de archivos en Linux

Introducción

Esta práctica (lab) te introduce al comando join en Linux, una herramienta poderosa que te permite combinar datos de dos archivos basados en un campo común. Similar a la unión de tablas en una base de datos, este comando es especialmente útil para tareas de procesamiento y análisis de datos en entornos Linux.

A lo largo de esta práctica, aprenderás cómo usar el comando join con diferentes opciones para fusionar datos de archivos separados, manejar diferentes separadores de campo y comprender los principios básicos de las operaciones de unión de archivos en Linux. Estas habilidades resultarán valiosas cuando trabajes con datos estructurados en archivos de texto, una tarea común en la administración de sistemas y el análisis de datos.

Skills Graph

Comprendiendo el comando básico de unión (join)

En este paso, aprenderás la sintaxis básica y el uso del comando join. El comando join en Linux combina líneas de dos archivos basadas en un campo común, similar a la unión de tablas en una base de datos.

Vamos a crear dos archivos de muestra con los que trabajar. Crearemos archivos que contengan datos meteorológicos, específicamente fechas de eventos de tormenta y sus correspondientes direcciones del viento.

Primero, crea un archivo llamado storms.txt con identificadores (IDs) de tormenta y fechas:

echo -e "1:2023-04-01\n2:2023-04-15\n3:2023-05-02" > ~/project/storms.txt

Ahora, crea otro archivo llamado winds.txt con identificadores (IDs) de tormenta y direcciones del viento:

echo -e "1:NW\n2:SE\n3:NE" > ~/project/winds.txt

Examinemos el contenido de estos archivos para entender su estructura:

cat ~/project/storms.txt

Deberías ver la siguiente salida:

1:2023-04-01
2:2023-04-15
3:2023-05-02

Ahora, veamos el archivo de vientos:

cat ~/project/winds.txt

Deberías ver la siguiente salida:

1:NW
2:SE
3:NE

Observa que ambos archivos tienen un primer campo común (el identificador de tormenta) que se puede utilizar para unirlos. Ahora, usemos el comando join para combinar estos archivos basados en este campo común:

join -t: ~/project/storms.txt ~/project/winds.txt

La opción -t: le dice al comando join que el separador de campo en ambos archivos es un dos puntos (:). Por defecto, join busca el campo común en la primera columna de cada archivo.

Deberías ver la siguiente salida:

1:2023-04-01:NW
2:2023-04-15:SE
3:2023-05-02:NE

Esta salida muestra los datos unidos de ambos archivos. Cada línea contiene:

• El identificador de tormenta (el campo común)
• La fecha (del primer archivo)
• La dirección del viento (del segundo archivo)

El comando join emparejó las líneas con el mismo identificador de tormenta y las combinó en líneas únicas en la salida.

Uniendo archivos con diferentes separadores de campo

En escenarios del mundo real, a menudo te encuentras con archivos que utilizan diferentes caracteres como separadores de campo. Este paso te muestra cómo unir tales archivos utilizando el comando join con procesamiento de texto adicional.

Vamos a crear dos archivos con diferentes separadores de campo:

Primero, crea un archivo llamado storms_dash.txt con identificadores (IDs) de tormenta y fechas, utilizando un guión (-) como separador:

echo -e "1-2023-04-10\n2-2023-04-20\n3-2023-05-05" > ~/project/storms_dash.txt

A continuación, crea otro archivo llamado winds_comma.txt con identificadores (IDs) de tormenta y direcciones del viento, utilizando una coma (,) como separador:

echo -e "1,NW\n2,SE\n3,NE" > ~/project/winds_comma.txt

Examinemos el contenido de estos archivos:

cat ~/project/storms_dash.txt

Deberías ver:

1-2023-04-10
2-2023-04-20
3-2023-05-05

Ahora, veamos el archivo winds_comma.txt:

cat ~/project/winds_comma.txt

Deberías ver:

1,NW
2,SE
3,NE

El desafío aquí es que el comando join espera que ambos archivos utilicen el mismo separador de campo. Para resolver este problema, necesitamos preprocesar uno de los archivos para que coincida con el separador del otro. Podemos utilizar el comando tr para traducir caracteres:

join -t- ~/project/storms_dash.txt <(tr ',' '-' < ~/project/winds_comma.txt)

Este comando realiza las siguientes operaciones:

1. tr ',' '-' < ~/project/winds_comma.txt - Convierte todas las comas en guiones en el contenido de winds_comma.txt
2. <(...) - Sustitución de procesos (process substitution), que trata la salida del comando encerrado como un archivo
3. join -t- ~/project/storms_dash.txt - Une el archivo storms_dash.txt con los datos transformados, utilizando el guión (-) como separador de campo

Deberías ver la siguiente salida:

1-2023-04-10-NW
2-2023-04-20-SE
3-2023-05-05-NE

Esta salida muestra los datos unidos de ambos archivos, con el guión (-) como separador de campo en todo momento. La sustitución de procesos es una característica poderosa en bash que te permite tratar la salida de un comando como un archivo, sin necesidad de crear archivos temporales.

Opciones avanzadas de unión (join)

En tareas reales de procesamiento de datos, a menudo se necesitan operaciones de unión más avanzadas, como manejar datos no emparejados o seleccionar campos específicos. Este paso te introduce a estas opciones avanzadas del comando join.

Vamos a crear dos archivos más complejos para nuestros ejemplos:

echo -e "1:2023-04-01:Thunderstorm\n2:2023-04-15:Hurricane\n3:2023-05-02:Tornado\n4:2023-05-10:Blizzard" > ~/project/storms_types.txt
echo -e "1:High\n2:Medium\n5:Low" > ~/project/severity.txt

Examinemos el contenido de estos archivos:

cat ~/project/storms_types.txt

Deberías ver:

1:2023-04-01:Thunderstorm
2:2023-04-15:Hurricane
3:2023-05-02:Tornado
4:2023-05-10:Blizzard

cat ~/project/severity.txt

Deberías ver:

1:High
2:Medium
5:Low

Observa que estos archivos no tienen una coincidencia perfecta de IDs:

• severity.txt tiene una entrada para el ID de tormenta 5, que no existe en storms_types.txt
• storms_types.txt tiene entradas para los IDs de tormenta 3 y 4, que no existen en severity.txt

Por defecto, join solo muestra las líneas donde el campo de unión coincide en ambos archivos:

join -t: ~/project/storms_types.txt ~/project/severity.txt

Deberías ver:

1:2023-04-01:Thunderstorm:High
2:2023-04-15:Hurricane:Medium

Solo los IDs de tormenta 1 y 2 aparecen en la salida porque son los únicos que existen en ambos archivos.

Manejando líneas no emparejadas

Para incluir líneas no emparejadas en la salida, puedes usar la opción -a:

join -t: -a 1 -a 2 ~/project/storms_types.txt ~/project/severity.txt

La opción -a 1 le dice a join que incluya las líneas no emparejadas del primer archivo, y -a 2 hace lo mismo para el segundo archivo.

Deberías ver:

1:2023-04-01:Thunderstorm:High
2:2023-04-15:Hurricane:Medium
3:2023-05-02:Tornado:
4:2023-05-10:Blizzard:
5::Low

Observa cómo las líneas no emparejadas tienen campos vacíos donde estaría la información del otro archivo.

Seleccionando campos específicos

También puedes seleccionar campos específicos de cada archivo para incluir en la salida usando la opción -o:

join -t: -o 1.1,1.3,2.2 ~/project/storms_types.txt ~/project/severity.txt

La opción -o 1.1,1.3,2.2 especifica qué campos se deben mostrar:

• 1.1: Primer campo del primer archivo (ID de tormenta)
• 1.3: Tercer campo del primer archivo (tipo de tormenta)
• 2.2: Segundo campo del segundo archivo (severidad)

Deberías ver:

1:Thunderstorm:High
2:Hurricane:Medium

Esta salida incluye solo el ID de tormenta, el tipo de tormenta y el nivel de severidad, omitiendo la información de la fecha. Esto es especialmente útil cuando se trabaja con archivos que tienen muchos campos pero solo se necesitan algunos específicos en la salida.

Resumen

En este laboratorio, has aprendido cómo utilizar el comando join en Linux para combinar datos de diferentes archivos basados en un campo común. Esta es una habilidad esencial para el procesamiento y análisis de datos en entornos Linux.

Has practicado el uso del comando join con varias opciones:

• La sintaxis básica para unir archivos con el mismo separador de campo
• Manejar archivos con diferentes separadores de campo utilizando la sustitución de procesos (process substitution) y el comando tr
• Utilizar la opción -a para incluir líneas no emparejadas en la salida
• Utilizar la opción -o para seleccionar campos específicos de cada archivo para la salida

El comando join es especialmente útil cuando se trabaja con datos de texto estructurados, archivos de registro o en cualquier situación en la que se necesite combinar información de diferentes fuentes basada en un identificador común. Esta habilidad complementa otros comandos de procesamiento de texto en Linux como grep, sed y awk, brindándote un potente conjunto de herramientas para la manipulación de datos en la línea de comandos.