Cómo usar pipes en la terminal: conectar comandos paso a paso

Introducción

En la línea de comandos de Unix‑like (Linux, macOS, WSL, etc.) uno de los conceptos más poderosos es el pipe o tubería, representado por el carácter |. Permite tomar la salida estándar (stdout) de un proceso y usarla como entrada estándar (stdin) del siguiente, sin necesidad de archivos intermedios. En este tutorial veremos cómo funciona, qué ocurre en cada etapa y mostraremos ejemplos concretos con la salida esperada, todo en voseo rioplatense.

¿Qué hace exactamente un pipe?

Cuando escribís:

comando1 | comando2

el shell:

1. Ejecuta comando1 y captura su stdout.
2. Ese flujo de bytes se convierte en el stdin de comando2.
3. El stderr de ambos comandos sigue yendo a la terminal (a menos que lo redirijas explícitamente).
4. El código de salida del pipe es el de comando2; si comando1 falla pero comando2 sigue recibiendo datos, el pipe no se corta automáticamente.

Esto permite construir pipelines (encadenamientos) de proceso tras proceso, cada uno realizando una transformación sencilla.

Sintaxis básica y buenas prácticas

• El pipe no necesita espacios, pero es recomendable ponerlos para legibilidad: cmd1 | cmd2.
• Podés encadenar tantos como queráis: cmd1 | cmd2 | cmd3 | cmd4.
• Si querés capturar también el stderr, usá 2>&1 antes del pipe: cmd1 2>&1 | cmd2.
• Para guardar el resultado final en un archivo, redirigí después del último pipe: ... | cmdN > salida.txt.

Ejemplo clásico: ls -l | grep .txt

Veamos qué pasa en cada paso.

Paso 1: ls -l

Supongamos que en el directorio actual tenés los siguientes archivos:

archivo.txt
otro.doc
notas.txt
script.py
lectura.txt

Ejecutando ls -l obtenés:

$ ls -l
-rw-r--r-- 1 usuario grupo   0 Sep 24 10:00 archivo.txt
-rw-r--r-- 1 usuario grupo   0 Sep 24 10:00 otro.doc
-rw-r--r-- 1 usuario grupo   0 Sep 24 10:00 notas.txt
-rw-r--r-- 1 usuario grupo   0 Sep 24 10:00 script.py
-rw-r--r-- 1 usuario grupo   0 Sep 24 10:00 lectura.txt

Esta es la salida que el pipe va a tomar como entrada.

Paso 2: grep .txt

grep recibe línea por línea y filtra aquellas que contengan la cadena .txt. La salida esperada es:

$ ls -l | grep .txt
-rw-r--r-- 1 usuario grupo   0 Sep 24 10:00 archivo.txt
-rw-r--r-- 1 usuario grupo   0 Sep 24 10:00 notas.txt
-rw-r--r-- 1 usuario grupo   0 Sep 24 10:00 lectura.txt

Nota: el punto en .txt se interpreta como "cualquier carácter" seguido de txt. Si querés buscar literalmente el punto, deberías escapar o usar -F: grep -F .txt. Pero para el ejemplo básico sirve.

Otros ejemplos útiles

1. Contar líneas de archivos .log

find . -name "*.log" -type f | xargs cat | wc -l

• find lista los archivos.
• xargs cat los concatena y envía su contenido a wc -l.
• wc -l cuenta las líneas y muestra un número.

Salida esperada (ejemplo):

12457

2. Ordenar y eliminar duplicados de una lista de palabras

cat palabras.txt | tr ' ' '\n' | sort | uniq -c | sort -nr

• cat lee el archivo.
• tr reemplaza espacios por salto de línea, dejando una palabra por línea.
• sort ordena alfabéticamente.
• uniq -c cuenta cuántas veces aparece cada palabra.
• El último sort -nr ordena de mayor a menor frecuencia.

Salida esperada (fragmento):

   42 hola
   35 mundo
   12 prueba
    5 ejemplo

3. Mostrar los 5 procesos que más consumen memoria

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

• ps aux lista todos los procesos con su uso de memoria.
• --sort=-%mem ordena de forma descendente por porcentaje de memoria.
• head -n 6 muestra la cabecera más los cinco primeros procesos.

Salida esperada (las primeras líneas):

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root       1234  0.2  15.4 1234567 89012 ?      Ssl  08:10   0:12 /usr/bin/mi-servicio
...

Encadenando múltiples pipes

Un pipeline puede ser tan largo como necesites. Cada stage transforma el dato y lo pasa al siguiente. Por ejemplo, para obtener solo los nombres de usuario de los procesos que consumen más de 10 % de CPU:

ps aux --sort=-%cpu | awk '$3 > 10 {print $1}' | sort | uniq

Desglose:

1. ps aux --sort=-%cpu → lista procesos ordenados por CPU.
2. awk '$3 > 10 {print $1}' → la tercera columna es %CPU; si supera 10, imprime la primera columna (usuario).
3. sort ordena la lista de usuarios.
4. uniq elimina repeticiones.

Redirigir la salida final a un archivo

Si querés guardar ese listado de usuarios en usuarios_top.txt:

ps aux --sort=-%cpu | awk '$3 > 10 {print $1}' | sort | uniq > usuarios_top.txt

Luego podés verificarlo con cat usuarios_top.txt.

Tips y trucos

• Silenciar errores: si no querés que el stderr moleste, redirigílo a /dev/null: cmd1 2>/dev/null | cmd2.
• Uso de tee: cuando querés ver la salida y además guardarla, insertá tee archivo en medio del pipe: cmd1 | tee intermedio.txt | cmd2.
• Evitar buffers: algunos comandos (como sort) esperan recibir toda la entrada antes de producir salida; si necesitás respuesta inmediata, usá versiones --line-buffered o herramientas como stdbuf -oL.
• Pipes y sudo: si el primer comando necesita privilegios, colocá sudo antes de él: sudo cmd1 | cmd2. El segundo comando se ejecuta con el usuario original, a menos que también le pongas sudo.

Conclusión

El operador pipe | es una herramienta fundamental para combinar pequeños comandos especializados y lograr tareas complejas sin escribir scripts extensos. Al entender qué produce cada etapa y qué consume la siguiente, podés construir pipelines claros, eficientes y fáciles de depurar. Practicá con los ejemplos mostrados, variá los filtros y los comandos, y pronto estarás pensando en términos de "flujo de datos" plutôt que de secuencias aisladas.

¡A fluyan esos datos!