Columnización de texto en Linux

Introducción

La columnización de texto es una técnica poderosa en Linux que te permite organizar y mostrar datos en un formato tabular estructurado. Cuando se trabaja con archivos de texto plano que contienen datos delimitados, el contenido puede ser difícil de leer sin un formato adecuado. El comando column en Linux resuelve este problema transformando el texto plano en columnas bien formateadas.

Esta práctica (lab) te guiará para dominar la utilidad column en Linux. Aprenderás cómo mostrar el contenido de archivos en un formato tabulado, lo que hace que los datos sean más fáciles de leer y analizar. Estas habilidades son esenciales para el procesamiento y visualización de datos en el entorno de línea de comandos.

Skills Graph

Comprender los conceptos básicos del comando column

En este paso, aprenderemos cómo utilizar el comando column para formatear texto en columnas alineadas, lo que hace que los datos sean más fáciles de leer e interpretar.

El comando column es una utilidad en Linux que formatea su entrada en múltiples columnas. Esto es especialmente útil cuando se trabaja con datos que tienen una estructura natural pero se almacenan en formato de texto plano.

Crear un archivo de datos de muestra

Comencemos creando un archivo de texto simple que contenga los datos que queremos formatear. Crearemos un archivo llamado powers_list.txt en el directorio ~/project que contenga nombres de superpoderes y los nombres de los héroes correspondientes, separados por dos puntos.

Navegue hasta el directorio del proyecto:

cd ~/project

Ahora cree el archivo de muestra utilizando el comando echo con la opción -e, que permite la interpretación de secuencias de escape de barra invertida (como \n para salto de línea):

echo -e "Telekinesis:Jane\nInvisibility:John\nSuper Strength:Max" > ~/project/powers_list.txt

Examinemos el contenido del archivo que acabamos de crear:

cat ~/project/powers_list.txt

Debería ver una salida como esta:

Telekinesis:Jane
Invisibility:John
Super Strength:Max

Estos datos están formateados con dos puntos (:) como delimitador entre el nombre del superpoder y el nombre del héroe. El formato no es muy legible como está.

Utilizar el comando column para formatear

Ahora, utilicemos el comando column para transformar estos datos en un formato más legible:

column -t -s ':' ~/project/powers_list.txt

En este comando:

• column es la utilidad que estamos utilizando
• La opción -t le dice al comando que cree una salida similar a una tabla
• -s ':' especifica que el delimitador (separador) en nuestro archivo de entrada es un dos puntos
• ~/project/powers_list.txt es la ruta a nuestro archivo de entrada

Después de ejecutar este comando, debería ver la siguiente salida:

Telekinesis     Jane
Invisibility    John
Super Strength  Max

Note cómo los datos ahora están alineados en columnas de manera ordenada, lo que los hace mucho más fáciles de leer. El comando column ha determinado automáticamente el ancho de cada columna en función del contenido y ha alineado todo en consecuencia.

Este uso básico del comando column demuestra su poder para formatear datos de texto para una mejor legibilidad.

Formateo avanzado de columnas con un script de shell

En este paso, crearemos un script de shell que facilite la columnización de archivos de texto con diferentes delimitadores. Este enfoque permite mayor flexibilidad y eficiencia al trabajar con diversos formatos de datos.

Comprender los scripts de shell

Un script de shell es un archivo que contiene comandos que el shell puede ejecutar. Te permite automatizar tareas combinando múltiples comandos y agregando lógica. En este caso, crearemos un script que simplifique el proceso de columnización de archivos.

Crear el script de columnización

Creemos un script llamado columnize.sh en el directorio ~/project. Este script tomará dos argumentos: un nombre de archivo y un carácter delimitador.

Primero, navega al directorio del proyecto si no estás ya allí:

cd ~/project

Ahora, crea el archivo del script:

touch columnize.sh

Luego, abre el archivo con el editor de texto nano:

nano columnize.sh

Agrega el siguiente contenido al archivo:

#!/bin/bash
## A script to columnize text files

## Check if the correct number of arguments are provided
if [ "$#" -ne 2 ]; then
  echo "Usage: $0 <filename> <delimiter>"
  echo "Example: $0 data.txt :"
  exit 1
fi

## Extract arguments
FILENAME=$1
DELIMITER=$2

## Check if the file exists
if [ ! -f "$FILENAME" ]; then
  echo "Error: File '$FILENAME' does not exist"
  exit 1
fi

## Format and output the content
column -t -s "$DELIMITER" "$FILENAME"

Para guardar el archivo en nano, presiona Ctrl+O, luego Enter, y para salir de nano, presiona Ctrl+X.

Analicemos lo que hace este script:

1. La primera línea (#!/bin/bash) le dice al sistema que use el shell bash para ejecutar el script.
2. Verificamos si se proporcionaron exactamente dos argumentos (un nombre de archivo y un delimitador).
3. Asignamos estos argumentos a variables para una referencia más fácil.
4. Verificamos si el archivo especificado existe.
5. Finalmente, usamos el comando column con el nombre de archivo y el delimitador proporcionados.

Hacer el script ejecutable

Antes de poder usar nuestro script, debemos hacerlo ejecutable:

chmod +x ~/project/columnize.sh

Usar el script de columnización

Ahora podemos usar nuestro script para columnizar archivos de texto. Usémoslo con nuestro archivo existente powers_list.txt:

~/project/columnize.sh ~/project/powers_list.txt :

Deberías ver la siguiente salida:

Telekinesis     Jane
Invisibility    John
Super Strength  Max

Creemos otro archivo de muestra con un delimitador diferente para probar la flexibilidad de nuestro script:

echo -e "Apple,Red,Fruit\nCarrot,Orange,Vegetable\nBlueberry,Blue,Fruit" > ~/project/foods.txt

Ahora usa nuestro script con este nuevo archivo y una coma como delimitador:

~/project/columnize.sh ~/project/foods.txt ,

Deberías ver una salida como esta:

Apple      Red     Fruit
Carrot     Orange  Vegetable
Blueberry  Blue    Fruit

Nuestro script ha columnizado con éxito los datos en ambos archivos, usando diferentes delimitadores. Esto demuestra la flexibilidad y el poder de combinar scripting de shell con la utilidad column.

Trabajar con diferentes formatos de archivos

En este paso, exploraremos cómo utilizar el comando column con diversos formatos de archivos y delimitadores. Esto te ayudará a comprender la versatilidad de la utilidad column y cómo se puede aplicar a diferentes tipos de datos.

Trabajar con archivos CSV

Los archivos CSV (Comma-Separated Values, Valores Separados por Comas) son un formato común para almacenar datos tabulares. Creemos un archivo CSV más complejo y usemos el comando column para formatearlo.

Primero, crea un nuevo archivo CSV:

cd ~/project
echo -e "Name,Age,Occupation,City\nAlex,28,Engineer,Boston\nSamantha,35,Teacher,Chicago\nMohamed,42,Doctor,New York\nLin,31,Artist,San Francisco" > employees.csv

Examinemos el contenido de este archivo:

cat employees.csv

Deberías ver:

Name,Age,Occupation,City
Alex,28,Engineer,Boston
Samantha,35,Teacher,Chicago
Mohamed,42,Doctor,New York
Lin,31,Artist,San Francisco

Ahora, usemos el comando column para formatear este archivo CSV:

column -t -s ',' employees.csv

La salida debería verse así:

Name       Age  Occupation  City
Alex       28   Engineer    Boston
Samantha   35   Teacher     Chicago
Mohamed    42   Doctor      New York
Lin        31   Artist      San Francisco

Observa cómo el comando column ha organizado los datos en columnas alineadas, lo que los hace mucho más fáciles de leer.

Trabajar con archivos TSV

TSV (Tab-Separated Values, Valores Separados por Tabulaciones) es otro formato común para datos tabulares. Creemos un archivo TSV y formateémoslo utilizando el comando column.

Crea un archivo TSV:

echo -e "Product\tPrice\tCategory\nLaptop\t999.99\tElectronics\nBook\t12.50\tMedia\nChair\t149.50\tFurniture" > products.tsv

Veamos el contenido:

cat products.tsv

Deberías ver:

Product	Price	Category
Laptop	999.99	Electronics
Book	12.50	Media
Chair	149.50	Furniture

Ahora, formatealo utilizando el comando column. Dado que las tabulaciones son el delimitador predeterminado para el comando column, no necesitamos especificar un delimitador:

column -t products.tsv

La salida debería verse así:

Product  Price   Category
Laptop   999.99  Electronics
Book     12.50   Media
Chair    149.50  Furniture

Usar nuestro script con diferentes archivos

Ahora, usemos nuestro script columnize.sh con estos diferentes archivos:

Para el archivo CSV:

~/project/columnize.sh employees.csv ,

Para el archivo TSV:

~/project/columnize.sh products.tsv $'\t'

Nota: En el segundo comando, estamos usando $'\t' para representar un carácter de tabulación. Esta es una sintaxis especial en bash que nos permite incluir caracteres especiales como tabulaciones.

Ambos comandos deberían producir una salida bien formateada, lo que demuestra la flexibilidad de nuestro script con diferentes formatos de archivos y delimitadores.

Este paso ha mostrado cómo el comando column y nuestro script se pueden utilizar para formatear varios tipos de datos tabulares, haciéndolos más legibles y fáciles de analizar.

Resumen

En este laboratorio, has aprendido cómo utilizar el comando column para organizar y mostrar datos en un formato tabular, lo que los hace más fáciles de leer y analizar. Aquí está un resumen de lo que has logrado:

1. Has aprendido el uso básico del comando column con las opciones -t y -s para formatear archivos de texto delimitados.

2. Has creado un script de shell (columnize.sh) que facilita la aplicación del formato de columnas a cualquier archivo con cualquier delimitador.

3. Has aplicado estas técnicas a diferentes formatos de archivos (CSV y TSV), demostrando la flexibilidad de la utilidad column para varios tipos de datos.

Estas habilidades son valiosas para el procesamiento y análisis de datos en un entorno Linux. La capacidad de formatear y visualizar rápidamente datos de texto es una herramienta poderosa para administradores de sistemas, analistas de datos y cualquier persona que trabaje con archivos de texto en la línea de comandos.

Las técnicas que has aprendido se pueden aplicar a:

• Análisis de archivos de registro
• Gestión de archivos de configuración
• Extracción y transformación de datos
• Visualización rápida de datos estructurados

Al dominar el comando column y aprender cómo automatizar su uso con scripts de shell, has agregado una herramienta importante a tu conjunto de herramientas de la línea de comandos de Linux.