Alberto Méndez

10 comandos de Linux que mejorarán tu flujo de desarrollo

ago. 17, 2025

Este artículo forma parte de una serie:

Linux

La diferencia entre un desarrollador promedio y uno experto no está en el IDE ni en el lenguaje que usa, sino en cómo domina su entorno.

Si has seguido la serie de Linux hasta aquí, ya conoces los comandos básicos y entiendes cómo funcionan los permisos. Ahora es momento de dar el salto: estos 10 comandos transformarán tu productividad y te convertirán en ese desarrollador que resuelve problemas complejos con unas pocas líneas en la terminal.

No se trata de memorizar sintaxis, sino de cambiar tu forma de pensar. Cada comando que veremos resuelve problemas reales del día a día: encontrar archivos perdidos, procesar logs, automatizar tareas repetitivas o depurar aplicaciones. Son las herramientas que separan a quien “sobrevive” en Linux de quien realmente lo domina.

1. find — El detective de archivos

¿Qué hace?

Localiza archivos y directorios basándose en criterios específicos. Mucho más potente que cualquier buscador gráfico.

Casos de uso esenciales


     # Encuentra todos los archivos JavaScript modificados en las últimas 24 horas
     find . -name "*.js" -mtime -1

     # Busca archivos de configuración que contengan 'docker' en el nombre
     find /etc -name "*docker*" 2>/dev/null

     # Encuentra archivos grandes (>100MB) que ocupan espacio
     find . -size +100M -type f

     # Localiza archivos con permisos específicos (potenciales problemas de seguridad)
     find . -perm 777 -type f

     # Encuentra y elimina archivos node_modules para liberar espacio
     find . -name "node_modules" -type d -exec rm -rf {} +

Parámetros importantes de find

  • . — Directorio actual (punto de inicio)
  • -name "patrón" — Busca por nombre de archivo
  • -mtime -1 — Modificado en el último día (-1 = menos de 1 día)
  • -size +100M — Archivos mayores a 100MB (+ = mayor que)
  • -type f/d — Tipo: f=archivo, d=directorio
  • -perm 777 — Archivos con permisos específicos
  • -exec comando {} + — Ejecuta comando sobre resultados encontrados
  • 2>/dev/null — Redirige errores para evitar ruido

Por qué es crucial

En proyectos grandes, buscar archivos manualmente es complicado sin herramientas de búsqueda avanzadas. find te permite localizar exactamente lo que necesitas usando criterios complejos.

2. grep — El filtrador de contenido

¿Qué hace?

Busca patrones de texto dentro de archivos. Es como Ctrl+F pero infinitamente más poderoso.

Casos de uso esenciales


     # Encuentra todas las funciones que contienen 'async' en archivos TypeScript
     grep -r "async" --include="*.ts" .

     # Busca errores en logs excluyendo warnings
     grep -E "ERROR|FATAL" /var/log/app.log | grep -v "WARNING"

     # Encuentra variables de entorno usadas en tu proyecto
     grep -r "process\.env\." --include="*.js" src/

     # Localiza todos los TODOs en el código
     grep -rn "TODO\|FIXME\|HACK" src/

     # Busca IPs en archivos de configuración
     grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}" config/

Parámetros clave de grep

  • -r — Búsqueda recursiva en subdirectorios
  • -E — Expresiones regulares extendidas (permite |, +, ?)
  • -v — Invierte la búsqueda (excluye líneas que coinciden)
  • -n — Muestra números de línea
  • -l — Solo muestra nombres de archivos que contienen coincidencias
  • -i — Ignora mayúsculas/minúsculas
  • --include="patrón" — Solo busca en archivos que coinciden con el patrón
  • \| — OR lógico en patrones (escapado para bash)

Combinación poderosa con find


     # Encuentra archivos Python que importan una librería específica
     find . -name "*.py" -exec grep -l "import pandas" {} \;

     # Busca configuraciones de base de datos en el proyecto
     find . -name "*.yml" -o -name "*.yaml" | xargs grep -i "database"

3. awk — El procesador de datos por excelencia

¿Qué hace?

Procesa y manipula texto estructurado. Ideal para extraer información específica de logs, CSVs o salidas de comandos.

Casos de uso esenciales


     # Extrae solo las IPs de un log de Apache
     awk '{print $1}' /var/log/apache2/access.log | sort | uniq -c

     # Calcula el espacio total usado por tipo de archivo
     ls -la | awk '{total += $5} END {print "Total:", total/1024/1024, "MB"}'

     # Procesa un CSV y extrae columnas específicas
     awk -F',' '{print $1, $3}' datos.csv

     # Encuentra procesos que consumen más memoria
     ps aux | awk '$4 > 5.0 {print $2, $4, $11}'

     # Analiza logs por códigos de estado HTTP
     awk '{print $9}' access.log | sort | uniq -c | sort -nr

Sintaxis esencial de awk

  • $1, $2, $3... — Columnas/campos (separados por espacios por defecto)
  • -F',' — Define separador de campos (aquí: coma para CSV)
  • {print $1} — Acción: imprime primera columna
  • $4 > 5.0 — Condición: filtra líneas donde columna 4 > 5.0
  • END {comando} — Ejecuta comando al final de procesamiento
  • total += $5 — Suma valores de la columna 5
  • substr($1,1,13) — Extrae substring: desde posición 1, 13 caracteres

Ejemplo real: Analizar logs de aplicación


     # Cuenta errores por hora en logs con timestamp
     awk '/ERROR/ {print substr($1,1,13)}' app.log | uniq -c

4. sed — El editor de texto ninja

¿Qué hace?

Modifica texto sobre la marcha sin abrir archivos. Perfecto para refactoring masivo o limpieza de datos.

Casos de uso esenciales


     # Reemplaza URLs de API en todos los archivos de configuración
     sed -i 's/api\.dev\.com/api\.prod\.com/g' config/*.json

     # Extrae solo las líneas entre dos patrones
     sed -n '/START/,/END/p' log.txt

     # Elimina líneas vacías y comentarios
     sed '/^#/d; /^$/d' config.conf

     # Añade un prefijo a cada línea
     sed 's/^/LOG: /' error.txt

     # Convierte formato de fecha
     echo "2025-08-17" | sed 's/-/\//g'

Comandos básicos de sed

  • -i — Edita archivos en lugar (in-place), modifica el archivo original
  • s/patrón/reemplazo/g — Sustituye: s=substitute, g=global (todas las ocurrencias)
  • -n — Modo silencioso, solo imprime lo que se le dice explícitamente
  • /START/,/END/p — Imprime líneas desde patrón START hasta END
  • /^#/d — Elimina líneas que empiezan con # (d=delete)
  • /^$/d — Elimina líneas vacías (^$ = inicio y fin de línea sin contenido)
  • s/^/prefijo/ — Añade texto al inicio de cada línea (^ = inicio de línea)

Ejemplo práctico: Refactoring masivo


     # Cambia imports antiguos por nuevos en todo el proyecto
     find src/ -name "*.js" -exec sed -i 's/old-library/new-library/g' {} \;

5. xargs — El multiplicador de comandos

¿Qué hace?

Convierte salida de un comando en argumentos para otro. Es el pegamento que conecta comandos de forma elegante.

Casos de uso esenciales


     # Encuentra y elimina archivos de backup
     find . -name "*.bak" | xargs rm

     # Busca texto en múltiples archivos encontrados
     find . -name "*.log" | xargs grep "ERROR"

     # Descarga múltiples URLs desde un archivo
     cat urls.txt | xargs -I {} curl -O {}

     # Cambia permisos a múltiples archivos
     ls *.sh | xargs chmod +x

     # Procesa archivos en paralelo (4 trabajos simultáneos)
     find . -name "*.jpg" | xargs -P 4 -I {} convert {} {}.webp

Opciones útiles de xargs

  • -I {} — Define marcador de posición para cada elemento de entrada
  • -P 4 — Ejecuta hasta 4 procesos en paralelo
  • -n 1 — Procesa un argumento por comando (útil para lotes)
  • -d '\n' — Define delimitador personalizado (por defecto: espacios y saltos)
  • -r — No ejecuta comando si no hay entrada (evita errores)

6. curl — El comunicador universal

¿Qué hace?

Realiza peticiones HTTP desde la terminal. Esencial para probar APIs, descargar archivos o automatizar interacciones web.

Archivo curl-format.txt para medir rendimiento

Crea el siguiente archivo curl-format.txt para formatear la respuesta del comando que se muestra abajo:


     tiempo_total:      %{time_total}s
     tiempo_dns:        %{time_namelookup}s
     tiempo_conexión:   %{time_connect}s
     código_estado:     %{http_code}

Casos de uso esenciales


     # Prueba una API con datos JSON
     curl -X POST -H "Content-Type: application/json" \
          -d '{"user":"test","pass":"123"}' \
          https://api.ejemplo.com/login

     # Descarga archivos con barra de progreso
     curl -L -o archivo.zip https://github.com/user/repo/archive/main.zip

     # Prueba tiempo de respuesta de una API
     curl -w "@curl-format.txt" -o /dev/null -s https://api.ejemplo.com/health

     # Sigue redirects y guarda cookies
     curl -L -c cookies.txt -b cookies.txt https://sitio.com/login

     # Verifica certificados SSL
     curl -I https://tu-sitio.com

Parámetros esenciales de curl

  • -X POST/GET/PUT/DELETE — Especifica método HTTP
  • -H "Header: valor" — Añade cabeceras personalizadas
  • -d "datos" — Envía datos en el cuerpo de la petición
  • -L — Sigue redirects automáticamente
  • -o archivo — Guarda respuesta en archivo
  • -O — Guarda con nombre original del servidor
  • -s — Modo silencioso (sin progreso)
  • -w "formato" — Define formato de salida personalizado
  • -c archivo — Guarda cookies en archivo
  • -b archivo — Usa cookies desde archivo
  • -I — Solo cabeceras (método HEAD)

7. jq — El procesador JSON definitivo

¿Qué hace?

Manipula y extrae datos de JSON de forma elegante. Indispensable en la era de las APIs REST.

Instalación


     sudo apt install jq  # Ubuntu/Debian
     brew install jq      # macOS

Casos de uso esenciales


     # Extrae un campo específico de una respuesta API
     curl -s https://api.github.com/users/octocat | jq '.name'

     # Filtra arrays por condiciones
     jq '.[] | select(.age > 18)' usuarios.json

     # Transforma estructura de datos
     jq '.users[] | {nombre: .name, email: .email}' data.json

     # Cuenta elementos en un array
     jq '.items | length' response.json

     # Busca en estructuras anidadas
     jq '.data.users[] | select(.status == "active") | .email' api_response.json

Ejemplo real: Monitorear deployment


     # Verifica el estado de servicios en Kubernetes
     kubectl get pods -o json | jq '.items[] | select(.status.phase != "Running") | .metadata.name'

8. ss — El monitor de conexiones

¿Qué hace?

Muestra conexiones de red activas. Reemplaza al obsoleto netstat con mejor rendimiento.

Casos de uso esenciales


     # Verifica qué proceso está usando un puerto específico
     ss -tulpn | grep :3000

     # Lista todas las conexiones TCP activas
     ss -t -a

     # Muestra conexiones por estado
     ss -t state established

     # Encuentra conexiones a una IP específica
     ss -t dst 192.168.1.100

     # Monitorea puertos en escucha
     ss -tlnp | grep LISTEN

Opciones principales de ss

  • -t — Solo conexiones TCP
  • -u — Solo conexiones UDP
  • -l — Solo puertos en escucha (listening)
  • -a — Muestra todas las conexiones (activas + escucha)
  • -n — Muestra números de puerto en lugar de nombres de servicio
  • -p — Muestra procesos que usan cada conexión
  • state established — Filtra por estado de conexión
  • dst IP — Filtra por IP de destino
  • src IP — Filtra por IP de origen

9. rsync — El sincronizador inteligente

¿Qué hace?

Sincroniza archivos y directorios de forma eficiente. Solo transfiere cambios, no archivos completos.

Casos de uso esenciales


     # Sincroniza proyecto local con servidor remoto
     rsync -avz --exclude node_modules/ ./ user@server:/var/www/app/

     # Backup incremental con progreso
     rsync -av --progress backup/ destino/

     # Sincronización bidireccional (con cuidado)
     rsync -av --delete source/ destination/

     # Copia solo archivos modificados recientemente
     rsync -av --update source/ destination/

     # Dry-run para ver qué se va a sincronizar
     rsync -avn source/ destination/

Flags importantes de rsync

  • -a — Modo archivo (preserva permisos, tiempos, enlaces)
  • -v — Verbose (muestra archivos procesados)
  • -z — Comprime durante transferencia (útil para conexiones lentas)
  • -n — Dry-run (simula sin ejecutar cambios reales)
  • --progress — Muestra barra de progreso
  • --delete — Elimina archivos en destino que no existen en origen
  • --update — Solo actualiza archivos más nuevos
  • --exclude patrón — Excluye archivos/directorios que coinciden
  • Nota: La barra final (/) importa en rutas (afecta si copia directorio o contenido)

10. tmux — El multiplicador de terminal

¿Qué hace?

Crea sesiones de terminal persistentes. Puedes desconectarte y reconectarte sin perder tu trabajo.

Instalación y configuración básica


     sudo apt install tmux  # Ubuntu/Debian

     # Configuración básica en ~/.tmux.conf
     set -g prefix C-a
     bind-key C-a send-prefix
     unbind C-b
     set -g mouse on

Casos de uso esenciales


     # Crear sesión nombrada (equivalente corto: tmux new -s desarrollo)
     tmux new-session -s desarrollo

     # Listar sesiones activas (alias: tmux ls)
     tmux list-sessions

     # Desconectarte (detach) sin cerrar nada: Prefix + d
     #  (Prefix = Ctrl+a porque lo redefinimos; si no cambiaste config es Ctrl+b)

     # Reconectarse a una sesión existente
     tmux attach-session -t desarrollo

     # Cerrar panel/ventana/sesión limpiamente
     #   Pane: exit (sale del shell) o Prefix + x (confirmar)
     #   Ventana: Prefix + & (confirmar)
     #   Sesión: tmux kill-session -t desarrollo

Flujo básico paso a paso (lo mínimo que necesitas)

Supongamos que ya aplicaste el cambio de prefix a Ctrl+a en ~/.tmux.conf. Si no, sustituye “Ctrl+a” por “Ctrl+b”.


     # 1. Crear una nueva sesión de trabajo
     tmux new -s web

     # 2. Crear una nueva ventana (por ejemplo para el servidor)
     #    Pulsar: Ctrl+a  c

     # 3. Renombrar la ventana actual
     #    Pulsar: Ctrl+a  ,   (escribe: servidor  y Enter)

     # 4. Volver a la ventana anterior o siguiente
     #    Siguiente: Ctrl+a  n
     #    Anterior:  Ctrl+a  p

     # 5. Ir directo a una ventana por número (las ventanas empiezan en 0)
     #    Ejemplo: Ctrl+a  0   (va a la primera) / Ctrl+a  1

     # 6. Dividir la ventana en paneles
     #    Vertical (izquierda/derecha): Ctrl+a  %
     #    Horizontal (arriba/abajo):    Ctrl+a  "

     # 7. Moverse entre paneles
     #    Ctrl+a  (flechas)  ó  Ctrl+a  o (rota)

     # 8. Redimensionar (opcional rápido)
     #    Mantén Ctrl+a y luego pulsa repetidamente: Alt + ←/→/↑/↓  (según terminal)

     # 9. Desconectarte de la sesión (dejas todo corriendo)
     #    Ctrl+a  d

     # 10. Volver más tarde
     tmux attach -t web

     # 11. Cerrar todo cuando termines
     #    Sal de cada pane con: exit
     #    O mata la sesión completa:
     tmux kill-session -t web

Mini resumen mental

  • Nueva ventana: Prefix + c
  • Cambiar ventana: Prefix + n / p / número
  • Split vertical: Prefix + %
  • Split horizontal: Prefix + "
  • Moverte: Prefix + flechas (o Prefix + o)
  • Detach: Prefix + d
  • Cerrar pane: Prefix + x (confirmar) o exit

Con esto ya puedes trabajar con múltiples procesos (editor, servidor, logs) sin abrir mil terminales separados.

Extra. man - Tu mejor aliado

Nunca memorices parámetros. El sistema tiene la documentación integrada esperándote. El comando man (manual) es tu compañero inseparable:


     # Documentación completa del comando
     man find

     # Búsqueda rápida dentro del manual (una vez dentro)
     /pattern  # Busca hacia adelante
     ?pattern  # Busca hacia atrás
     n         # Siguiente coincidencia
     q         # Salir del manual

     # Busca comandos por funcionalidad
     man -k "search files"  # Encuentra comandos relacionados con búsqueda

     # Versión corta con opciones principales
     find --help  # Funciona con la mayoría de comandos

     # Ejemplo rápido con explicación
     tldr find  # Si tienes tldr instalado (apt install tldr)

Ejemplos prácticos para empezar


     # ¿Olvidaste cómo usar grep con expresiones regulares?
     man grep
     # Busca dentro del manual: /regex

     # ¿No recuerdas las opciones de rsync?
     rsync --help | grep -E "^\s*-[a-z]"  # Solo las opciones principales

     # ¿Qué hace exactamente el flag -z en tar?
     man tar
     # Busca dentro: /-z

Tu flujo de aprendizaje

  1. Experimenta → Usa el comando básico
  2. Documéntate → man comando cuando necesites más opciones
  3. Practica → Combina con otros comandos
  4. Automatiza → Crea aliases y scripts

Combinaciones poderosas

Pipeline para análisis de logs


     # Encuentra errores únicos en logs, ordenados por frecuencia
     find /var/log -name "*.log" | \
     xargs grep -h "ERROR" | \
     awk '{for(i=3;i<=NF;i++) printf "%s ", $i; print ""}' | \
     sort | uniq -c | sort -nr | head -10

Monitoreo de aplicación en tiempo real


     # Combina tail, grep y awk para monitoreo live
     tail -f app.log | grep --line-buffered "ERROR\|WARN" | \
     awk '{print strftime("%H:%M:%S"), $0}' | \
     while read line; do echo -e "\033[31m$line\033[0m"; done

Cleanup automático de proyecto


     # Script para limpiar archivos innecesarios
     find . -name "node_modules" -type d | xargs rm -rf
     find . -name "*.log" -mtime +7 | xargs rm
     find . -name ".DS_Store" | xargs rm

Consejos para maestría

1. Crea aliases para comandos frecuentes


     # Añade a ~/.bashrc o ~/.zshrc
     alias logwatch='tail -f /var/log/app.log | grep --color=always ERROR'
     alias findjs='find . -name "*.js" -not -path "./node_modules/*"'
     alias gitclean='git branch --merged | grep -v "\*\|main\|develop" | xargs git branch -d'

2. Usa history para mejorar


     # Busca comandos anteriores con patrón
     history | grep "find.*\.js"

3. Combina con scripts


     #!/bin/bash
     # deploy.sh - Script de deployment simple
     echo "🚀 Iniciando deployment..."
     rsync -av --exclude node_modules/ ./ server:/app/
     ssh server "cd /app && npm install && pm2 restart all"
     echo "✅ Deployment completado"

Conclusión

Estos 10 comandos no son solo herramientas; son superpoderes que transformarán tu experiencia como desarrollador en Linux. La diferencia entre conocerlos superficialmente y dominarlos está en la práctica constante.

La verdadera maestría en Linux no viene de memorizar flags y opciones, sino de entender cómo combinar estas herramientas para resolver problemas reales. Cada comando es una pieza de un puzzle más grande: tu flujo de trabajo optimizado.

Recuerda: la terminal no es intimidante cuando tienes la documentación a un man de distancia.

¿Listo para ser ese desarrollador de los que hacen magia con la terminal?

Happy Coding!

Alberto Méndez
comments powered by Disqus

Artículos relacionados

Quizá te puedan interesar

Nuestro trabajo

De concepto a realidad

Retoque fotográfico en segundos con Inteligencia Artificial Editasteic
Aventuras sin límites generadas por IA dónde tus elecciones dan forma a la historia. LAIA
Crea historias sorprendentes con cada tirada, ¡la imaginación es tu única guía! Spark
Controla fácilmente y en profundidad las horas que dedicas a tu empleo y/ó proyectos. Sé dueño de tu tiempo. WorkIO