Guía completa de grep: desde lo básico hasta ripgrep

grep extrae líneas que coinciden con una expresión regular del texto — la herramienta de búsqueda fundamental para análisis de logs, búsqueda de código y filtrado de configuraciones en cualquier sistema Unix/Linux. Como alternativa moderna y más rápida, ripgrep añade búsqueda multi-hilo y respeto automático de .gitignore. Este artículo cubre los fundamentos de grep, patrones regex, casos de uso reales y la transición a ripgrep.

"Necesito extraer solo los errores de un archivo de log." "Quiero encontrar cada ocurrencia de una función en toda la base de código." "Quiero ver solo las líneas activas en un archivo de configuración, sin comentarios."

Estos son los momentos en los que grep entra en acción. Y su evolución, ripgrep escrito en Rust, lleva las cosas aún más lejos.

¿Qué es grep?

grep significa Global Regular Expression Print. Es un comando filtro que extrae líneas que coinciden con una expresión regular del texto — una de las herramientas más fundamentales del mundo Unix/Linux.

Características clave:

• Caballo de batalla de los pipelines — diseñado para encadenarse con otros comandos vía |
• Preinstalado en prácticamente todos los sistemas Linux — listo para usar en cualquier servidor
• Búsqueda flexible con regex — desde cadenas simples hasta patrones complejos
• Ligero y rápido — maneja archivos de log masivos sin despeinarse

El nombre proviene del comando del editor ed g/re/p (global / regular expression / print), escrito por Ken Thompson en 1973. Ha estado en uso activo durante más de 50 años. Consulta el manual oficial de GNU grep para la referencia completa.

Uso básico

Empecemos con las opciones esenciales de grep. Solo con estas cubrirás la gran mayoría de tus tareas de búsqueda diarias.

Búsqueda de cadenas

grep "error" logfile.txt

Cada línea que contiene "error" en el archivo se imprime en stdout.

Opciones de uso frecuente

# Búsqueda sin distinguir mayúsculas/minúsculas
grep -i "error" logfile.txt

# Mostrar números de línea
grep -n "error" logfile.txt

# Búsqueda recursiva en directorios
grep -rn "TODO" src/

# Mostrar líneas que NO coinciden (filtro de exclusión)
grep -v "debug" logfile.txt

# Contar líneas que coinciden
grep -c "error" logfile.txt

# Mostrar solo nombres de archivo que contienen coincidencias
grep -l "error" *.log

Mostrar contexto

Cuando quieres ver las líneas circundantes, usa -A (After/Después), -B (Before/Antes) o -C (Context/Contexto).

# Mostrar 3 líneas después y 1 línea antes de cada coincidencia
grep -A 3 -B 1 "error" logfile.txt

# Mostrar 3 líneas de contexto en ambos lados (igual que -A 3 -B 3)
grep -C 3 "error" logfile.txt

Múltiples patrones

# Búsqueda OR (regex extendido)
grep -E "error|warning|fatal" logfile.txt

# Búsqueda de cadena fija (desactiva interpretación de regex)
grep -F "console.log(" src/app.js

Patrones regex

El verdadero poder de grep reside en las expresiones regulares. Hay dos variantes: Expresiones Regulares Básicas (BRE) y Expresiones Regulares Extendidas (ERE, activadas con -E). Ambas están definidas en la especificación POSIX de expresiones regulares.

Referencia de patrones comunes

BRE vs ERE

En las Expresiones Regulares Básicas (BRE), los metacaracteres como +, ?, {}, | y () requieren una barra invertida. Las Expresiones Regulares Extendidas (ERE, vía -E) permiten usarlos directamente.

# BRE: se requiere barra invertida
grep "error\|warning" logfile.txt
grep "ab\{2,4\}" data.txt

# ERE: sintaxis más limpia (preferida)
grep -E "error|warning" logfile.txt
grep -E "ab{2,4}" data.txt

PCRE (Expresiones Regulares Compatibles con Perl)

El flag -P habilita regex compatible con Perl, desbloqueando atajos como \d (dígito), \s (espacio en blanco) y aserciones lookahead/lookbehind.

# Coincidir un patrón de código postal (3 dígitos, guión, 4 dígitos)
grep -P "\d{3}-\d{4}" addresses.txt

# Extraer cadenas tipo email
grep -oP "[\w.+-]+@[\w-]+\.[\w.]+" contacts.txt

Casos de uso reales

Análisis de archivos de log

Este es el caso de uso más común en operaciones de servidor.

# Extraer errores de una fecha específica (logs con marca de tiempo)
grep "2026-03-08.*ERROR" /var/log/app.log

# Extraer solo direcciones IP
grep -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b" access.log

# Contabilizar códigos de estado HTTP (combo grep + awk + sort)
grep -oE "HTTP/[0-9.]+ [0-9]+" access.log | awk '{print $2}' | sort | uniq -c | sort -rn

Búsqueda en la base de código

Para búsquedas a gran escala, combina grep con find para un filtrado de archivos más flexible.

# Encontrar todos los comentarios TODO/FIXME en el proyecto
grep -rn "TODO\|FIXME" --include="*.ts" src/

# Localizar llamadas a funciones específicas
grep -rn "useState(" --include="*.tsx" src/

# Buscar sentencias import
grep -rn "^import.*from" --include="*.ts" --include="*.tsx" src/

Filtrado de archivos de configuración

# Quitar comentarios y líneas en blanco para mostrar solo ajustes activos
grep -v "^#" /etc/ssh/sshd_config | grep -v "^$"

# Extraer una sección específica
grep -A 10 "\[database\]" config.ini

Combinaciones con pipelines

grep brilla más cuando se combina con otros comandos. Combínalo con xargs para pasar los resultados como argumentos al siguiente comando.

# Verificar procesos nginx en ejecución (excluye el propio proceso grep)
ps aux | grep "[n]ginx"

# Buscar comandos relacionados con git en el historial
history | grep "git"

# Extraer errores de mensajes del kernel
dmesg | grep -i "error"

# Filtrar un listado de archivos por extensión
find . -type f | grep "\.mdx$"

ripgrep: la alternativa moderna

ripgrep (comando: rg) es un reemplazo de grep escrito en Rust por Andrew Gallant (@BurntSushi). Con más de 50,000 estrellas en GitHub y adoptado como motor de búsqueda interno de VS Code, se ha convertido en la herramienta de búsqueda predeterminada para muchos desarrolladores.

Ventajas clave:

• Velocidad asombrosa — búsqueda paralela multi-hilo
• Respeto automático de .gitignore — omite node_modules, dist, etc. por defecto
• Soporte Unicode completo — maneja caracteres CJK sin problemas
• Omisión automática de archivos binarios — ignora imágenes y archivos compilados
• Recursivo por defecto — no necesitas -r

Instalación

winget install BurntSushi.ripgrep.MSVC

Uso básico

# Búsqueda recursiva desde el directorio actual (no necesita -r)
rg "TODO"

# Buscar por tipo de archivo
rg "TODO" --type js
rg "TODO" -t py

# Usar patrones glob para acotar el alcance de la búsqueda
rg "TODO" -g "*.tsx"

# Búsqueda de cadena fija (desactiva regex)
rg -F "console.log("

# Búsqueda sin distinguir mayúsculas/minúsculas
rg -i "error"

# Los números de línea siempre se muestran por defecto
rg "error" src/

Funcionalidades avanzadas

# Salida JSON (útil para integración con herramientas)
rg "error" --json

# Vista previa de reemplazo (NO modifica archivos)
rg "old_func" -r "new_func"

# Imprimir solo la porción coincidente (como grep -o)
rg -o "\d{3}-\d{4}" addresses.txt

# Incluir archivos ocultos en la búsqueda
rg --hidden "SECRET_KEY"

# Ignorar .gitignore y buscar en todos los archivos
rg --no-ignore "password"

.rgignore para exclusiones personalizadas

Coloca un archivo .rgignore en la raíz del proyecto para definir exclusiones específicas de ripgrep. La sintaxis es idéntica a .gitignore.

# .rgignore
dist/
coverage/
*.min.js
*.map

grep vs ripgrep

Con ambas herramientas comprendidas, aquí tienes una comparación lado a lado para guiar tu decisión.

Cuándo usar cuál:

• En servidores — grep es la única opción. No necesita instalación adicional.
• En tu máquina de desarrollo — ripgrep es abrumadoramente más cómodo. Instálalo.
• En scripts de shell — usa grep para portabilidad. Usa rg si el script solo corre en tu propio entorno.

Conocer ambos significa que nunca estarás atascado. Domina grep para los fundamentos, luego añade ripgrep para la productividad.

Técnicas avanzadas

Coincidencia de patrones multilínea con ripgrep

El flag --multiline (-U) coincide con patrones que abarcan varias líneas. Útil para encontrar definiciones de funciones o entradas de log multilínea.

# Encontrar bloques de función vacíos
rg -U "function.*\{[\s]*\}" --type js

# Encontrar bloques try-catch
rg -U "try\s*\{[\s\S]*?\}\s*catch" --type ts

Tipos de archivo personalizados en ripgrep

--type-add te permite definir tipos de archivo personalizados. Práctico para extensiones específicas del proyecto.

# Definir y buscar archivos MDX
rg --type-add 'mdx:*.mdx' -t mdx "Callout"

# Definir un tipo de configuración con múltiples extensiones
rg --type-add 'config:*.{conf,cfg,ini,toml,yaml,yml}' -t config "database"

Configura export RIPGREP_CONFIG_PATH=~/.rgrc en tus dotfiles para persistir tipos personalizados.

# ~/.rgrc
--type-add=mdx:*.mdx
--type-add=config:*.{conf,cfg,ini,toml,yaml,yml}
--smart-case

Estadísticas de búsqueda con --stats

El flag --stats imprime conteos de coincidencias, archivos buscados y tiempo transcurrido. Útil para evaluar el alcance del impacto antes de una refactorización grande.

rg "deprecated_function" --stats

Grep en vivo con ripgrep + fzf

Canaliza los resultados de ripgrep a fzf para filtrado interactivo con vistas previas y apertura directa de archivos.

# Filtrar interactivamente resultados de rg, abrir en vim
rg --line-number --no-heading "TODO" | \
  fzf --delimiter ':' \
      --preview 'bat --color=always --highlight-line {2} {1}' \
      --bind 'enter:execute(vim {1} +{2})'

FAQ

¿Debería usar grep o ripgrep?

En tu máquina de desarrollo, usa ripgrep. Respeta .gitignore automáticamente, ejecuta búsquedas multi-hilo y tiene soporte Unicode completo por defecto. En servidores o en scripts de shell portables, quédate con grep — viene preinstalado en todas partes. Lo ideal es aprender ambos.

¿Por qué grep -P no funciona en macOS?

macOS incluye BSD grep, no GNU grep. El flag -P (PCRE) es una característica de GNU grep. Puedes instalar GNU grep vía brew install grep, o usar el flag --pcre2 de ripgrep como alternativa.

¿Cómo busco en todos los archivos con ripgrep ignorando .gitignore?

Usa rg --no-ignore "patrón" para omitir las exclusiones de .gitignore. Para incluir también archivos ocultos, añade --hidden: rg --no-ignore --hidden "patrón".

¿Cómo hago una búsqueda AND con grep (líneas que contengan dos patrones)?

grep no tiene un operador AND nativo. Encadena dos greps con pipe: grep "patrón1" archivo | grep "patrón2". El mismo enfoque funciona con ripgrep.

¿Puede ripgrep reemplazar contenido en archivos?

rg "old" -r "new" muestra una vista previa del reemplazo pero no modifica archivos. Para aplicar cambios, combínalo con sed: rg -l "old" | xargs sed -i 's/old/new/g'.

¿Cuál es la diferencia entre grep -r y grep -R?

-r no sigue enlaces simbólicos, mientras que -R sí los sigue. Usa -r por defecto para evitar descender accidentalmente a directorios no deseados a través de symlinks.

¿Qué editores y herramientas se integran con ripgrep?

VS Code usa ripgrep como su motor de búsqueda interno. Telescope de Neovim, counsel-rg de Emacs y fzf también se integran con ripgrep. Si la búsqueda de tu IDE se siente lenta, vale la pena probar un plugin basado en ripgrep.

¿Cómo maneja ripgrep archivos que no son UTF-8?

ripgrep busca en UTF-8 por defecto y maneja archivos con BOM. Para otras codificaciones, usa el flag -E: rg -E shift-jis "patrón". GNU grep puede manejar archivos no UTF-8 vía la variable de entorno LANG, pero es más propenso a errores.

Conclusión

grep es la base de la búsqueda de texto, y es inevitable si trabajas con Linux. Combinado con expresiones regulares, maneja el análisis de logs, la búsqueda de código y el filtrado de configuraciones con facilidad.

ripgrep construye sobre esa base, añadiendo velocidad y comodidad significativas. Una vez que experimentas el respeto automático de .gitignore y la búsqueda multi-hilo, no hay vuelta atrás.

Como siguiente paso, explora la transformación de texto con sed y awk, o prueba combinar ripgrep con fzf para búsqueda interactiva. Combinar búsqueda con transformación aumenta drásticamente tu productividad en CLI.

Artículos relacionados:

• Guía práctica de sed y awk: el dúo clásico del procesamiento de texto
• Guía completa de fzf: búsqueda difusa que lo cambia todo
• Herramientas CLI modernas en Rust: eza, bat, fd, zoxide y más
• Guía completa de jq: domina el procesamiento JSON en la terminal
• El kit de herramientas CLI del desarrollador: un mapa completo