¿Qué es el procesamiento de flujos de texto en Linux?

1.1. La filosofía de los flujos de texto

En Linux, casi todo se representa como texto. Los archivos de configuración, los registros del sistema, la salida de comandos y las entradas de los usuarios viajan en forma de flujos de texto (text streams).

Dominar el procesamiento de esos flujos es una habilidad fundamental para administrar sistemas, automatizar tareas y, por supuesto, para superar el examen LFCS.

Un flujo de texto no es más que una secuencia de caracteres que puede leerse de una fuente (entrada) o escribirse en un destino (salida). El sistema operativo organiza estas comunicaciones mediante tres canales estándar:

• Entrada estándar (stdin) → descriptor de archivo 0. Normalmente es el teclado.
• Salida estándar (stdout) → descriptor de archivo 1. Normalmente es la pantalla.
• Error estándar (stderr) → descriptor de archivo 2. También la pantalla, pero separado para mensajes de error.

Esta separación permite filtrar, redirigir y combinar información con una facilidad asombrosa.

1.2. Redirecciones: cambiar el origen y el destino

La redirección desvía los flujos hacia archivos u otros comandos. Es la base sobre la que se construyen las tuberías (pipes).

1.2.1. Redirección de salida

• comando > archivo
  Redirige stdout a un archivo, sobrescribiendo su contenido. Si el archivo no existe, se crea.

ls -l > listado.txt

• comando >> archivo (redirige stdout y agrega al final del archivo)

echo "Nueva línea" >> bitacora.log

• comando 2> errores.log (redirige únicamente stderr a un archivo)

ls /ruta/inexistente 2> error.txt

• comando &> todo.log: (redirige tanto stdout como stderr al mismo archivo -notación abreviada-. Equivalente a > todo.log 2>&1)

ls /root /tmp &> resultado.txt

1.2.2. Redirección de entrada

• comando < archivo (el comando lee desde el archivo en lugar del teclado)

wc -l < lista.txt

Útil para pasar contenido a comandos que no aceptan archivos directamente.

1.2.3. Combinaciones avanzadas

• comando 2>&1 (redirige stderr al mismo lugar que stdout. Muy usado en scripts)

ls /root /tmp > salida.txt 2>&1

• comando << DELIMITADOR: Here document: permite incrustar un bloque de texto multilínea directamente en la línea de comandos o en un script. El delimitador marca el final.

cat << FIN > mensaje.txt
Hola, esto es un
texto de varias líneas.
FIN

• comando <<< "cadena": Here string: pasa una cadena literal como entrada estándar.

tr 'a-z' 'A-Z' <<< "hola mundo"

1.3. Tuberías (pipes): el verdadero poder

El símbolo | conecta la salida estándar de un comando con la entrada estándar del siguiente. Así se construyen pipelines que procesan los datos por etapas.

comando1 | comando2 | comando3

Por ejemplo, para ver los 5 procesos que más memoria consumen:

ps aux --sort=-%mem | head -n 6

A continuación estudiaremos los filtros más importantes que, combinados con tuberías, transforman flujos de texto en información útil.

1.4. Comandos esenciales para procesar texto

1.4.1. cat: Concatenar y mostrar archivos

Aunque su nombre viene de concatenar, su uso más básico es mostrar el contenido de uno o varios archivos.

cat archivo1.txt archivo2.txt

Con tuberías puede servir para iniciar un flujo:

cat /etc/passwd | grep /bin/bash

1.4.2. tac y rev

• tac: igual que cat pero invierte el orden de las líneas.
• rev: invierte el orden de los caracteres en cada línea.

echo -e "uno\ndos\ntres" | tac   # muestra tres, dos, uno
echo "Linux" | rev               # muestra xuniL

1.4.3. head y tail: principio y final

head muestra las primeras líneas (por defecto 10). tail, las últimas.

head -n 5 /etc/passwd
tail -f /var/log/syslog       # sigue el crecimiento del archivo en tiempo real
tail -n 3 /etc/group

tail -f es imprescindible para depurar servicios.

1.4.4. less y more: paginadores

Muestran contenido página a página. less es más moderno y permite desplazamiento hacia adelante y hacia atrás, búsqueda (/patrón) y otras facilidades.

less /var/log/syslog
dmesg | less

1.4.5. wc: contar líneas, palabras y bytes

wc -l archivo.txt   # solo líneas
wc -w archivo.txt   # solo palabras
wc -c archivo.txt   # bytes

Ejemplo en tubería:

grep error /var/log/syslog | wc -l

1.4.6. sort: ordenar líneas

Ordena alfabéticamente (o numéricamente) las líneas de un archivo o flujo.

sort -n   # orden numérico
sort -r   # reverso
sort -k2  # ordena por la segunda columna
sort -t: -k3 -n /etc/passwd   # campo separador ':', ordena por UID numéricamente

Combinado con uniq, es perfecto para encontrar valores únicos.

1.4.7. uniq: eliminar o contar líneas repetidas

Solo funciona correctamente si el flujo está ordenado o las repeticiones son consecutivas.

sort datos.txt | uniq           # elimina duplicados
sort datos.txt | uniq -c        # cuenta ocurrencias
sort datos.txt | uniq -d        # muestra solo duplicados

Ejemplo: direcciones IP que más aparecen en un log:

awk '{print $1}' access.log | sort | uniq -c | sort -nr | head

1.4.8. tr: traducir, sustituir o eliminar caracteres

tr lee stdin y escribe stdout transformando caracteres según los conjuntos especificados.

echo "hola" | tr 'a-z' 'A-Z'       # convierte a mayúsculas
echo "hola mundo" | tr -d 'o'      # elimina todas las 'o'
echo "uno  dos   tres" | tr -s ' ' # reduce espacios repetidos a uno solo

También es útil para cambiar saltos de línea:

cat lista.txt | tr '\n' ',' | sed 's/,$/\n/'

1.4.9. cut: extraer columnas o campos

Extrae secciones de cada línea basándose en delimitador o en posiciones fijas.

cut -d: -f1 /etc/passwd    # primer campo separado por ':'
cut -d, -f2,3 datos.csv    # campos 2 y 3
cut -c1-5 archivo.txt      # primeros 5 caracteres de cada línea

1.4.10. paste: unir líneas de archivos

Combina las líneas de varios archivos en una sola línea, separadas por un delimitador (por defecto tabulador).

paste archivo1.txt archivo2.txt
paste -d: archivo1.txt archivo2.txt   # usando ':' como delimitador

1.4.11. expand y unexpand: tabulaciones y espacios

expand convierte tabuladores en espacios; unexpand hace lo contrario.

expand -t 4 archivo_con_tabs.txt  # 1 tab = 4 espacios
unexpand -a --first-only archivo_con_espacios.txt

1.4.12. nl: numerar líneas

nl archivo.txt
ls -l | nl

1.4.13. fmt y pr: formatear texto para impresión

fmt da formato de párrafo (líneas de ancho determinado). pr pagina el texto añadiendo cabeceras.

fmt -w 60 texto_largo.txt
pr -h "Título" archivo.txt | lpr

1.5. Expresiones regulares: el lenguaje de los patrones

Las expresiones regulares (regex) son secuencias de caracteres que definen un patrón de búsqueda. Son la base de herramientas como grep, sed y awk. Existen varios sabores; en Linux usaremos principalmente expresiones regulares básicas (BRE) y extendidas (ERE).

1.5.1. Metacaracteres básicos

Ejemplos:

• ^A → líneas que empiezan con A
• error$ → líneas que terminan con “error”
• c.p → “cap”, “cip”, “c3p”, etc.
• a[bc]d → “abd” o “acd”
• [0-9]* → cero o más dígitos

1.5.2. Repeticiones y opcionalidad en ERE

Al usar expresiones extendidas (por ejemplo con grep -E o sed -r), añadimos:

Ejemplo ERE:

grep -E 'error|fail' log.txt
grep -E 'ab{2,4}c' palabras.txt   # abbc, abbbc, abbbbc

1.5.3. Clases predefinidas POSIX

Dentro de [...] se pueden usar:

• [:alnum:] → letras y dígitos
• [:alpha:] → letras
• [:digit:] → dígitos
• [:lower:] → minúsculas
• [:upper:] → mayúsculas
• [:space:] → espacios, tabulaciones, saltos de línea
• [:punct:] → signos de puntuación

grep '[[:digit:]]{3}-[[:digit:]]{4}' contactos.txt   # formato NNN-NNNN

1.6. grep: búsqueda de patrones

grep (global regular expression print) filtra líneas que coinciden con un patrón. Es la navaja suiza del análisis de texto.

Sintaxis básica:

grep [opciones] patrón [archivo...]

1.6.1. Opciones fundamentales

• -i : ignorar mayúsculas/minúsculas
• -v : invertir, mostrar líneas que NO coinciden
• -c : contar líneas coincidentes
• -n : mostrar número de línea
• -l : mostrar solo nombres de archivos que contienen el patrón
• -r o -R : búsqueda recursiva en directorios
• -E : usar expresiones regulares extendidas (ERE)
• -F : tratar el patrón como cadena fija (no regex)
• -o : mostrar solo la parte que coincide (muy útil para extraer datos)

Ejemplos:

grep 'root' /etc/passwd
grep -v '^#' /etc/ssh/sshd_config   # elimina comentarios
grep -rn 'Listen' /etc/
grep -i 'error' /var/log/syslog | grep -v 'debug'
grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' log.txt   # extrae IPs

grep puede leer de stdin, por lo que se integra perfectamente en tuberías.

1.7. sed: editor de flujo

sed (stream editor) realiza transformaciones complejas sobre un flujo de texto sin necesidad de abrir un editor interactivo. Es ideal para sustituciones, borrados, inserciones y cambios automáticos.

1.7.1. Sintaxis básica

sed [opciones] 'comando' archivo
sed -e 'comando1' -e 'comando2' archivo

1.7.2. Sustitución con s

La orden más común:

sed 's/patrón/reemplazo/' archivo

• g al final reemplaza todas las ocurrencias en la línea.
• i ignora mayúsculas (similar a I).
• Se pueden usar distintos delimitadores, como # o |, si el patrón contiene /.

sed 's/error/ERROR/' log.txt
sed 's|/ruta/vieja|/ruta/nueva|g' config.txt
sed 's/[0-9]\+/NUMERO/g' datos.txt

1.7.3. Direcciones (líneas afectadas)

Podemos limitar el cambio a líneas específicas:

sed '5s/hola/adiós/'        # línea 5
sed '1,3s/hola/adiós/'      # líneas 1 a 3
sed '/patrón/s/hola/adiós/' # líneas que contienen "patrón"
sed '1~2s/^/#/'             # desde la línea 1, cada 2 líneas (impares) añade '#'

1.7.4. Más comandos útiles

• d : eliminar líneas
• p : imprimir (útil con -n)
• a\ : añadir después
• i\ : insertar antes
• c\ : cambiar línea completa

sed '/^$/d' archivo           # elimina líneas en blanco
sed -n '5,10p' archivo        # imprime solo líneas 5-10
sed '3a\Nueva línea' archivo  # añade después de la línea 3

1.7.5. sed en tuberías

grep 'ERROR' app.log | sed 's/ERROR/*** CRITICAL ***/g' | less

1.8. awk: mucho más que un filtro

awk es un lenguaje de programación completo orientado a procesar líneas de texto estructurado en campos. En el contexto de LFCS, nos centraremos en su uso como potente filtro.

1.8.1. Estructura básica

awk 'programa' archivo

El programa se compone de patrones y acciones: patrón { acción }.

Si se omite el patrón, la acción se aplica a todas las líneas. Si se omite la acción, se imprime la línea que cumple el patrón.

1.8.2. Variables internas

• $0 : línea completa
• $1, $2, ... : campos (por defecto separados por espacio/tab)
• NF : número de campos
• NR : número de registro (línea actual)
• FS : field separator (por defecto whitespace)
• OFS : output field separator
• RS, ORS : record separators

1.8.3. Selección y cálculo

Mostrar el nombre de usuario y su UID desde /etc/passwd:

awk -F: '{ print $1, $3 }' /etc/passwd

Calcular la suma de tamaños de archivos:

ls -l | awk '{sum+=$5} END {print sum}'

Filtrar líneas cuyo segundo campo sea mayor que 100:

awk '$2 > 100' datos.txt

1.8.4. Combinado con grep y sort

Ejemplo: de un log, extraer las IPs que hicieron más de 10 peticiones:

awk '{print $1}' access.log | sort | uniq -c | awk '$1 > 10'

O incluso con formato personalizado:

df -h | awk 'NR>1 {printf "%-20s %5s %5s\n", $1, $2, $5}'

1.9. Técnicas avanzadas de procesamiento

1.9.1. Sustitución de comandos

Permite usar la salida de un comando como argumento de otro.

• Sintaxis antigua: `comando`
• Sintaxis moderna: $(comando) (preferida y anidable)

echo "Hoy es $(date)"
ls -l $(which passwd)

Se puede combinar con pipes dentro de la sustitución:

cat $(find /var/log -name "*.log" | head -3)

1.9.2. xargs: convertir stdin en argumentos

Cuando un comando no acepta entrada estándar (ej. rm, cp), xargs lee líneas de stdin y las convierte en argumentos.

find /tmp -type f -name "*.tmp" | xargs rm

Con -I puedes controlar la ubicación del argumento:

cat lista.txt | xargs -I {} cp {} /backup/{}.bak

Siempre es recomendable usar -print0 en find y -0 en xargs para manejar nombres con espacios:

find /ruta -name "*.log" -print0 | xargs -0 grep "ERROR"

1.9.3. tee: derivar el flujo

tee lee de stdin y escribe a la vez en stdout y en uno o más archivos. Ideal para depurar o guardar registros intermedios sin romper la tubería.

comando | tee archivo.txt | otro_comando

Ejemplo:

ls -l | tee listado.txt | wc -l

También puede añadir (-a) en lugar de sobrescribir.

1.10. Ejercicios prácticos

Para afianzar los conocimientos, te propongo los siguientes retos. Resuélvelos en tu terminal.

1. Muestra las últimas 20 líneas de /var/log/syslog que contengan la palabra “fail” (sin distinción de mayúsculas).
2. Cuenta cuántos shells diferentes hay en /etc/passwd (pista: campo 7, ordena y cuenta uniq).
3. Genera una lista de todos los usuarios con UID superior a 999 a partir de /etc/passwd, mostrando solo nombre y UID separados por un guión.
4. Extrae todas las direcciones IPv4 de la salida de ip a y ordénalas de manera única.
5. Crea un pipeline que tome el archivo /etc/services, elimine líneas vacías y de comentarios, y muestre solo los nombres de servicios ordenados alfabéticamente.
6. Sustituye todas las ocurrencias de /var/www por /srv/http en un archivo de configuración, pero solo en las líneas que empiecen por DocumentRoot.
7. Crea un script que busque todos los archivos .conf bajo /etc, busque dentro de ellos la palabra Listen y guarde las líneas coincidentes en puertos.txt (manteniendo el nombre de archivo origen) y además las muestre por pantalla.
8. Dado un archivo CSV con campos separados por comas, muestra el segundo campo en mayúsculas y el tercero en minúsculas.

1.11. Conclusión y posibles consejos para el examen

• Comprende bien las redirecciones, especialmente 2>&1 y &>.
• Practica las tuberías hasta que te resulten naturales: son la esencia del procesamiento de texto.
• Memoriza las opciones más útiles de grep, sed y awk. En el examen es posible que solo necesites la funcionalidad básica, pero debes saber leer expresiones regulares.
• Aprende a combinar find con xargs o con la opción -exec para operaciones en lote.
• Un flujo de trabajo típico: generar_datos | filtrar | transformar | resumir.
• La habilidad para procesar flujos de texto te ahorrará horas de trabajo y es evaluada directa o indirectamente en muchos dominios de LFCS.

En el siguiente capítulo nos sumergiremos en el editor de texto más poderoso de la línea de comandos: Vi/Vim, una herramienta que combinada con lo aprendido aquí, te convertirá en un administrador imparable.

¡Sigue practicando con estos comandos y no temas romper nada! La terminal es tu campo de pruebas.