Formateo de texto en Linux

Introducción

El formato de texto es una habilidad fundamental para los usuarios de Linux y los administradores de sistemas. La capacidad de presentar datos en formatos estructurados y legibles es esencial para crear informes, organizar la salida y facilitar la comprensión de la información.

En este laboratorio (lab), aprenderás cómo utilizar el comando printf, una poderosa herramienta de formato de texto en Linux. Explorarás diversas técnicas de formato, incluyendo alineación de campos, especificación de ancho, formato de números y el uso de secuencias de escape. Estas habilidades te ayudarán a crear salidas bien estructuradas para scripts, procesamiento de datos y tareas de administración de sistemas.

Introducción a los conceptos básicos de printf

El comando printf en Linux se utiliza para formatear e imprimir datos. A diferencia del comando echo, que es más sencillo, printf te permite controlar con precisión cómo se muestra tu texto.

En este paso, aprenderás la sintaxis básica del comando printf y crearás tu primera salida formateada.

Primero, navega hasta el directorio de tu proyecto:

cd ~/project/text_formatting

La sintaxis básica de printf es:

printf "format" arguments

Donde:

"format" es una cadena que contiene texto y especificadores de formato
Los especificadores de formato comienzan con % y definen cómo deben formatearse los argumentos
Los argumentos son los valores que se van a formatear

Vamos a crear un ejemplo sencillo:

printf "Hello, %s!\n" "World"

En este comando:

%s es un especificador de formato para cadenas
"World" es el argumento que reemplaza a %s
\n agrega una nueva línea al final

Deberías ver la siguiente salida:

Hello, World!

Ahora, intenta usar múltiples argumentos:

printf "Name: %s, Role: %s\n" "Alice" "Engineer"

Salida:

Name: Alice, Role: Engineer

Vamos a guardar algún texto formateado en un archivo:

printf "Today's date: %s\n" "$(date +%Y-%m-%d)" > date.txt
cat date.txt

Este comando:

Utiliza $(date +%Y-%m-%d) para obtener la fecha actual en formato YYYY-MM-DD
La formatea con printf
Guarda la salida en un archivo llamado date.txt
Muestra el contenido del archivo

Formateo de cadenas con ancho y alineación

Al mostrar datos en columnas o tablas, controlar el ancho y la alineación del texto se vuelve importante. En este paso, aprenderás cómo especificar el ancho del campo y la alineación para datos de tipo cadena.

El especificador de formato para cadenas con control de ancho sigue este patrón:
%[flags][width]s

Donde:

[width] especifica el ancho mínimo del campo
[flags] controla la alineación y otras opciones (- para alineación a la izquierda)

Vamos a crear un archivo con columnas formateadas:

touch formatted_names.txt
printf "%-15s %-10s %s\n" "First Name" "Last Name" "Department" >> formatted_names.txt
printf "%-15s %-10s %s\n" "John" "Smith" "Engineering" >> formatted_names.txt
printf "%-15s %-10s %s\n" "Mary" "Johnson" "Marketing" >> formatted_names.txt
printf "%-15s %-10s %s\n" "Robert" "Williams" "Finance" >> formatted_names.txt
cat formatted_names.txt

En este ejemplo:

%-15s formatea la primera columna como una cadena alineada a la izquierda con un ancho de 15 caracteres
%-10s formatea la segunda columna como una cadena alineada a la izquierda con un ancho de 10 caracteres
%s formatea la tercera columna como una cadena estándar
\n agrega una nueva línea al final

La salida mostrará una tabla ordenada con columnas alineadas:

First Name      Last Name  Department
John            Smith      Engineering
Mary            Johnson    Marketing
Robert          Williams   Finance

Para ver la diferencia entre la alineación a la izquierda y a la derecha, prueba lo siguiente:

printf "Left aligned:  '%-10s'\n" "text"
printf "Right aligned: '%10s'\n" "text"

Salida:

Left aligned:  'text      '
Right aligned: '      text'

Formateo de números y valores decimales

El comando printf ofrece diversas opciones para formatear números, incluyendo enteros y valores de punto flotante. En este paso, aprenderás cómo controlar la visualización de datos numéricos.

Para los enteros, el especificador de formato básico es %d. Vamos a crear un archivo con números formateados:

touch numerical_data.txt
printf "Decimal: %d, Padded: %05d\n" 42 42 > numerical_data.txt
cat numerical_data.txt

En este ejemplo:

%d muestra el número como un entero decimal simple
%05d muestra el número como un entero decimal de 5 dígitos, rellenado con ceros a la izquierda

Salida:

Decimal: 42, Padded: 00042

Para los números de punto flotante, puedes usar %f y controlar la precisión:

printf "Float: %f, Rounded: %.2f\n" 3.14159 3.14159 >> numerical_data.txt
cat numerical_data.txt

En este ejemplo:

%f muestra el número de punto flotante completo
%.2f muestra el número de punto flotante redondeado a 2 decimales

El archivo completo ahora contiene:

Decimal: 42, Padded: 00042
Float: 3.141590, Rounded: 3.14

También puedes formatear números con diferentes sistemas numéricos:

printf "Decimal: %d, Hexadecimal: %x, Octal: %o\n" 16 16 16 >> numerical_data.txt
cat numerical_data.txt

Salida agregada al archivo:

Decimal: 16, Hexadecimal: 10, Octal: 20

Uso de secuencias de escape

Las secuencias de escape en el comando printf te permiten incluir caracteres especiales y códigos de control en tu texto formateado. En este paso, aprenderás cómo usar diversas secuencias de escape.

Las secuencias de escape comunes incluyen:

\n - Salto de línea
\t - Tabulación
\" - Comilla doble
\\ - Barra invertida
\b - Retroceso

Vamos a crear un archivo con ejemplos de secuencias de escape:

touch escape_sequences.txt
printf "Lines:\nFirst line\nSecond line\n" > escape_sequences.txt
printf "Tabs:\tColumn1\tColumn2\tColumn3\n" >> escape_sequences.txt
printf "Quotes: \"quoted text\"\n" >> escape_sequences.txt
cat escape_sequences.txt

La salida mostrará cómo funcionan estas secuencias de escape:

Lines:
First line
Second line
Tabs:	Column1	Column2	Column3
Quotes: "quoted text"

El especificador de formato %b permite la interpretación de secuencias de escape en los argumentos:

printf "%b" "Newline: \\n becomes a\nnew line\n" >> escape_sequences.txt
cat escape_sequences.txt

El especificador %b también es útil para interpretar secuencias de escape hexadecimales que representan caracteres ASCII o Unicode:

printf "ASCII: %b\n" "\x48\x65\x6c\x6c\x6f" >> escape_sequences.txt
cat escape_sequences.txt

Salida:

ASCII: Hello

Creación de un informe formateado

En este último paso, combinarás las técnicas que has aprendido para crear un informe bien formateado. Esto demostrará cómo se pueden aplicar estas habilidades de formato en escenarios prácticos.

Vamos a crear un script que genere un informe de información del sistema:

touch system_report.sh
chmod +x system_report.sh

Abre el archivo del script con nano:

nano system_report.sh

Agrega el siguiente contenido al script:

#!/bin/bash

## Define the output file
report_file="system_report.txt"

## Clear any existing report
> $report_file

## Add formatted header
printf "=======================================\n" >> $report_file
printf "       %s        \n" "SYSTEM INFORMATION REPORT" >> $report_file
printf "       %s        \n" "Generated on: $(date)" >> $report_file
printf "=======================================\n\n" >> $report_file

## CPU Information
printf "%-15s %s\n" "CPU:" "$(grep "model name" /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/^[ \t]*//')" >> $report_file

## Memory Information
total_mem=$(free -m | grep Mem | awk '{print $2}')
used_mem=$(free -m | grep Mem | awk '{print $3}')
printf "%-15s %d MB (Used: %d MB)\n" "Memory:" $total_mem $used_mem >> $report_file

## Disk Information
disk_info=$(df -h / | tail -1)
disk_size=$(echo $disk_info | awk '{print $2}')
disk_used=$(echo $disk_info | awk '{print $3}')
disk_percent=$(echo $disk_info | awk '{print $5}')
printf "%-15s %s (Used: %s, %s)\n" "Disk Space:" $disk_size $disk_used $disk_percent >> $report_file

## System Uptime
uptime_info=$(uptime -p)
printf "%-15s %s\n" "Uptime:" "$uptime_info" >> $report_file

## Add a table of processes
printf "\n%-6s %-10s %-8s %-6s %s\n" "PID" "USER" "CPU%" "MEM%" "COMMAND" >> $report_file
printf "%-6s %-10s %-8s %-6s %s\n" "--" "----" "----" "----" "-------" >> $report_file

## Get top 5 processes by CPU usage
ps aux --sort=-%cpu | head -6 | tail -5 | while read line; do
  pid=$(echo $line | awk '{print $2}')
  user=$(echo $line | awk '{print $1}')
  cpu=$(echo $line | awk '{print $3}')
  mem=$(echo $line | awk '{print $4}')
  cmd=$(echo $line | awk '{print $11}')
  printf "%-6s %-10s %-8.1f %-6.1f %s\n" "$pid" "$user" "$cpu" "$mem" "$cmd" >> $report_file
done

echo "Report generated: $report_file"

Guarda y sale de nano (presiona Ctrl+O, luego Enter y luego Ctrl+X).

Ejecuta el script para generar el informe:

./system_report.sh

Visualiza el informe generado:

cat system_report.txt

El informe combina diversas técnicas de formato:

Ancho de campo y alineación para una presentación organizada de los datos
Formato numérico para los valores de CPU y memoria
Encabezados con texto centrado
Datos tabulares con columnas alineadas

Este ejemplo demuestra cómo se pueden aplicar las técnicas de formato que has aprendido para crear una salida clara y legible para informes de información del sistema.

Resumen

En este laboratorio, has aprendido cómo usar el comando printf para el formato de texto en Linux. Has practicado:

Sintaxis básica de printf y formato de cadenas
Control del ancho de campo y alineación para una salida tabular limpia
Formateo de diferentes tipos de números, incluyendo enteros y valores de punto flotante
Uso de secuencias de escape para incluir caracteres especiales en tu salida
Combinación de estas técnicas para crear un informe práctico de información del sistema

Estas habilidades de formato de texto son esenciales para crear una salida legible en scripts de shell, generar informes y organizar información en la terminal. El comando printf te da un control preciso sobre cómo se muestra tu texto, lo que lo convierte en una herramienta poderosa para usuarios de Linux y administradores de sistemas.

A medida que continúes tu viaje en Linux, encontrarás que estas técnicas de formato son valiosas para presentar datos de manera clara y profesional en tus scripts y aplicaciones de línea de comandos.