Cómo usar grep para buscar cadenas en archivos en la terminal de Linux

El comando GREP en Linux - una visión general

El comando grep en Linux es una poderosa utilidad de búsqueda de texto que permite a los usuarios buscar a través de archivos o flujos de texto para patrones específicos. Significa “ global regular expression print“, y admite la búsqueda por cadenas de texto simples y expresiones regulares más complejas. El comando a menudo se combina con otros comandos para filtrar y refinar la salida. Por defecto, grep devuelve todas las líneas que contienen el patrón. Sin embargo, ofrece varias opciones para personalizar la búsqueda, como la sensibilidad a mayúsculas, contar ocurrencias o buscar recursivamente a través de directorios. Esto lo convierte en una herramienta esencial para administradores de sistemas, desarrolladores y cualquier persona que trabaje con grandes conjuntos de datos en un entorno similar a Unix.

El comando grep se utiliza principalmente para buscar un texto o archivo por líneas que contienen una coincidencia con las palabras/cadenas especificadas. Por defecto, grep muestra las líneas coincidentes, y se puede usar para buscar líneas de texto que coincidan con una o más expresiones regulares, y solo muestra las líneas coincidentes.

Requisitos previos

El comando grep es parte de las utilidades base de cualquier distribución de Linux, por lo que está preinstalado por defecto en AlmaLinux, CentOS, Debian, Linux Mint, Ubuntu, RHEL y RockyLinux.

La sintaxis básica del comando grep

La sintaxis básica del comando grep es la siguiente:

grep 'word' filename
grep 'word' file1 file2 file3
grep 'string1 string2'  filename
cat otherfile | grep 'something'
command | grep 'something'
command option1 | grep 'data'
grep --color 'data' fileName

Cómo usar el comando grep para buscar en un archivo

En el primer ejemplo, buscaré al usuario “tom” en el archivo passwd de Linux. Para buscar en el archivo /etc/passwd al usuario “tom”, necesitas ingresar el siguiente comando:

grep tom /etc/passwd

A continuación se muestra la salida de ejemplo:

tom:x:1000:1000:tom,,,:/home/tom:/bin/bash

Tienes la opción de instruir a grep para que ignore la distinción entre mayúsculas y minúsculas, es decir, coincidir abc, Abc, ABC, y todas las combinaciones posibles con la opción -i como se muestra a continuación:

grep -i "tom" /etc/passwd

Uso recursivo de grep

Si tienes un montón de archivos de texto en una jerarquía de directorios, por ejemplo, los archivos de configuración de Apache en /etc/apache2/ y deseas encontrar el archivo donde se define un texto específico, entonces usa la opción -r del comando grep para hacer una búsqueda recursiva. Esto realizará una operación de búsqueda recursiva a través de archivos para la cadena “197.167.2.9” (como se muestra a continuación) en el directorio /etc/apache2/ y todos sus subdirectorios:

grep -r "mydomain.com" /etc/apache2/

Alternativamente, se puede usar el siguiente comando:

grep -R "mydomain.com" /etc/apache2/

A continuación se muestran las salidas de ejemplo para una búsqueda similar en un servidor Nginx:

grep -r "mydomain.com" /etc/nginx/  
/etc/nginx/sites-available/mydomain.com.vhost:        if ($http_host != "www.mydomain.com") {

Aquí, verías el resultado para mydomain.com en una línea distinta precedida por el nombre del archivo (por ejemplo, /etc/nginx/sites-available/mydomain.com.vhost) en el que se encontró. La inclusión de los nombres de los archivos en los datos de salida se puede suprimir fácilmente usando la opción -h (como se explica a continuación): grep -h -R “mydomain.com” /etc/nginx/. A continuación se muestra la salida de ejemplo:

grep -r "mydomain.com" /etc/nginx/  
if ($http_host != "www.mydomain.com") {

Usando grep para buscar solo palabras

Cuando buscas abc, grep coincidirá con todo tipo de cosas, es decir, kbcabc, abc123, aarfbc35, y muchas más combinaciones sin obedecer los límites de palabras. Puedes obligar al comando grep a seleccionar solo aquellas líneas que contienen coincidencias para formar palabras completas (aquellas que coinciden solo con la palabra abc), como se muestra a continuación:

grep -w "abc" file.txt

Ejemplo:

Usando grep para buscar dos palabras diferentes

Para buscar dos palabras diferentes, debes usar el comando egrep como se muestra a continuación:

egrep -w 'word1|word2' /path/to/file

Contar líneas para palabras coincidentes

El comando grep tiene la capacidad de informar cuántas veces se ha coincidido un patrón particular para cada archivo usando la opción -c (contar) (como se muestra a continuación):

grep -c 'word' /path/to/file

Además, los usuarios pueden usar la opción ‘-n’ precediendo cada línea de salida con el número de la línea en el archivo de texto del cual se obtuvo (como se muestra a continuación):

grep -n 'root' /etc/passwd

A continuación se muestran las salidas de ejemplo:

1:root:x:0:0:root:/root:/bin/bash

Coincidencia inversa de grep

Los usuarios pueden hacer uso de la opción -v para imprimir las coincidencias inversas, lo que significa que solo coincidiría con aquellas líneas que no contienen la palabra dada. Por ejemplo, imprime todas las líneas que no contienen la palabra par usando el siguiente comando:

grep -v par /path/to/file

Cómo listar solo los nombres de archivos coincidentes

Debes usar la opción -l para listar los nombres de archivos cuyos contenidos mencionan una palabra particular, por ejemplo, la palabra ‘primary’, usando el siguiente comando:

grep -l 'primary' *.c

Por último, tienes la opción de obligar a grep a mostrar la salida en colores específicos usando el siguiente comando:

grep --color root /etc/passwd

A continuación se muestran las salidas de ejemplo:

Cómo hacer que el comando grep maneje múltiples patrones de búsqueda

Podría haber situaciones en las que desees buscar múltiples patrones en un archivo dado (o conjunto de archivos). En tales escenarios, debes usar la opción de línea de comando ‘-e‘ que proporciona grep.

Por ejemplo, supongamos que deseas buscar las palabras “how”, “to” y “forge” en todos los archivos de texto presentes en tu directorio de trabajo actual, entonces aquí está cómo puedes hacerlo:

grep -e how -e to -e forge *.txt

Aquí está el comando en acción:

La opción de línea de comando ‘-e‘ también ayuda en escenarios en los que el patrón comienza con un guion (-). Por ejemplo, si deseas buscar, digamos, “-how”, entonces el siguiente comando no será útil:

grep -how *.txt

Es cuando usas la opción de línea de comando -e, el comando entiende exactamente lo que estás tratando de buscar en este caso:

grep -e -how *.txt

Aquí están ambos comandos en acción:

Cómo limitar la salida de grep a un número particular de líneas

En caso de que desees limitar la salida de grep a un número particular de líneas, puedes hacerlo usando la opción de línea de comando ‘-m‘. Por ejemplo, supongamos que deseas buscar la palabra “how” en testfile1.txt que contiene las siguientes líneas:

Pero el requisito es que grep debe dejar de buscar después de que se hayan encontrado 3 líneas que contengan el patrón buscado. Entonces, para hacer esto, puedes ejecutar el siguiente comando:

grep "how" -m3 testfile1.txt

Aquí está el comando en acción:

Continuando, aquí está lo que dice la página del manual del comando:

Si la entrada es la entrada estándar de un archivo regular, y se generan NUM líneas coincidentes, grep asegura que la entrada estándar esté posicionada justo después de la última línea coincidente antes de salir, independientemente de la presencia de líneas de contexto finales. Esto permite que un proceso de llamada reanude una búsqueda.

Así que, por ejemplo, si tienes un script bash que tiene un bucle, y deseas obtener una coincidencia por iteración del bucle, entonces usar ‘grep -m1’ hará lo necesario.

Cómo hacer que grep obtenga patrones de un archivo

Si lo deseas, también puedes hacer que el comando grep obtenga patrones de un archivo. La opción de línea de comando -f de la herramienta te permite hacer esto.

Por ejemplo, supongamos que deseas buscar todos los archivos .txt en el directorio actual para las palabras “how” y “to”, pero deseas suministrar estas cadenas de entrada a través de un archivo llamado, digamos, “input”, entonces aquí está cómo puedes hacerlo:

grep -f input *.txt

Aquí está el comando en acción:

Cómo hacer que grep muestre solo aquellas líneas que coincidan completamente con el patrón de búsqueda

Hasta ahora, hemos visto que por defecto grep coincide y muestra líneas completas que contienen patrones de búsqueda. Pero si el requisito es hacer que grep solo muestre aquellas líneas que coinciden completamente con el patrón buscado, entonces esto se puede hacer usando la opción de línea de comando ‘-x’.

Por ejemplo, supongamos que el archivo testfile1.txt contiene las siguientes líneas:

Y el patrón que deseas buscar es “how are you?”. Así que para asegurarte de que grep solo muestre líneas que coincidan completamente con este patrón, úsalo de la siguiente manera:

grep -x "how are you?" *.txt

Aquí está el comando en acción:

Cómo forzar a grep a no mostrar nada en la salida

Podría haber situaciones en las que no necesites que el comando grep produzca nada en la salida. En su lugar, solo deseas saber si se encontró o no una coincidencia según el estado de salida del comando. Esto se puede lograr usando la opción de línea de comando -q.

Mientras que la opción -q silencia la salida, el estado de salida de la herramienta se puede confirmar con el comando ‘echo $?’. En el caso de grep, el comando sale con un estado ‘0’ cuando tiene éxito (es decir, se encontró una coincidencia), mientras que sale con estado ‘1’ cuando no se encontró ninguna coincidencia.

La siguiente captura de pantalla muestra ambos escenarios exitosos y no exitosos:

Cómo hacer que grep muestre el nombre de archivos que no contienen el patrón de búsqueda

Por defecto, el comando grep muestra el nombre de archivos que contienen el patrón de búsqueda (así como las líneas coincidentes). Esto es bastante lógico, ya que eso es lo que se espera de esta herramienta. Sin embargo, podría haber casos en los que el requisito podría ser obtener los nombres de aquellos archivos que no contienen el patrón buscado.

Esto también es posible con grep: la opción -L te permite hacer esto. Así que, por ejemplo, para encontrar todos esos archivos de texto en el directorio actual que no contienen la palabra “how”, puedes ejecutar el siguiente comando:

grep -L "how" *.txt

Aquí está el comando en acción:

Cómo suprimir los mensajes de error producidos por grep

Puedes obligar a grep a silenciar cualquier mensaje de error que muestre en la salida si lo deseas. Esto se puede hacer usando la opción de línea de comando -s. Por ejemplo, considera el siguiente escenario en el que grep produce un error/advertencia relacionado con el directorio que encuentra:

Así que en este tipo de escenario, la opción de línea de comando -s ayuda. Ver abajo.

Así que puedes ver que el error/advertencia se ha silenciado.

Cómo hacer que grep busque directorios recursivamente

Como se desprende del ejemplo utilizado en el punto anterior, el comando grep no realiza una búsqueda recursiva por defecto. Para asegurarte de que tu búsqueda con grep sea recursiva, usa la opción de línea de comando -d y pasa el valor ‘recurse’ a ella.

grep -d recurse "how" *

Nota 1 : El mensaje de error/advertencia relacionado con el directorio que discutimos en el punto anterior también se puede silenciar usando la opción -d: todo lo que tienes que hacer es pasar el valor ‘skip’ a ella.

Nota 2 : Usa la opción ‘–exclude-dir=[DIR]’ para excluir directorios que coincidan con el patrón DIR de búsquedas recursivas.

Cómo hacer que grep termine los nombres de archivos con un carácter NULL

Como ya hemos discutido, la opción de línea de comando -l de grep se usa cuando solo deseas que la herramienta muestre nombres de archivos en la salida. Por ejemplo:

Ahora, debes saber que cada nombre en la salida anterior está separado/terminado por un carácter de nueva línea. Aquí está cómo puedes verificar eso:

Redirige la salida a un archivo, y luego imprime el contenido del archivo:

Así que, la salida del comando cat confirma la presencia de un carácter de nueva línea entre los nombres de archivos.

Pero como ya sabes, el carácter de nueva línea también puede ser parte de un nombre de archivo. Así que, al tratar con casos en los que los nombres de archivos contienen un nueva línea y están separados/terminados por nueva línea, se vuelve difícil trabajar en la salida de grep (especialmente al acceder a la salida a través de un script).

Sería bueno si el carácter separador/terminador no fuera un nueva línea. Bueno, te alegrará saber que grep proporciona una opción de línea de comando -Z que asegura que los nombres de archivos sean seguidos por un carácter NULL y no por un nueva línea.

Así que, en nuestro caso, el comando se convierte en:

grep -lZ "how" *.txt

Aquí está cómo confirmamos la presencia del carácter NULL:

A continuación se muestra una opción de línea de comando relacionada que debes conocer:

 -z, --null-data  
Trata la entrada como un conjunto de líneas, cada una terminada por un byte cero (el carácter NUL ASCII) en lugar de un nueva línea. Al igual que la opción -Z o --null, esta opción se puede usar con comandos como sort -z para procesar nombres de archivos arbitrarios.

Cómo usar GREP para encontrar errores en archivos de registro

Grep es la navaja suiza del administrador de Linux cuando se trata de depurar errores en servicios. La mayoría de los servicios de Linux tienen archivos de registro donde informan errores. Estos archivos de registro pueden ser enormes, y grep es un comando versátil y rápido para buscar, por ejemplo, la dirección IP de un sistema que se conecta, una cadena de error o la dirección de correo electrónico de un usuario de correo afectado en el mail.log.

Ejemplos:

Busca conexiones relacionadas con una dirección de correo electrónico específica. Aquí, ‘[email protected]’ está en el archivo de registro del servidor mail.log.

grep [email protected] /var/log/mail.log

Resultado:

Aug 22 09:45:10 mail dovecot: pop3-login: Login: user=<[email protected]>, method=PLAIN, rip=192.168.0.112, lip=78.46.229.46, mpid=17596, TLS, session=<3uoa5ffQovld3Uep>  
Aug 22 09:45:10 mail dovecot: pop3([email protected])<17596><3uoa5ffQovld3Uep>: Disconnected: Logged out top=0/0, retr=1/6647, del=1/1, size=6630  
Aug 22 09:45:10 mail dovecot: pop3-login: Login: user=<[email protected]>, method=PLAIN, rip=192.168.0.112, lip=78.46.229.46, mpid=17673, TLS, session=  
Aug 22 09:45:10 mail dovecot: pop3([email protected])<17673>: Disconnected: Logged out top=0/0, retr=0/0, del=0/0, size=0  
Aug 22 09:45:10 mail dovecot: pop3-login: Login: user=<[email protected]>, method=PLAIN, rip=192.168.0.112, lip=78.46.229.46, mpid=17868, TLS, session=  
Aug 22 09:45:10 mail dovecot: pop3([email protected])<17868>: Disconnected: Logged out top=0/0, retr=0/0, del=0/0, size=0  
Aug 22 09:45:10 mail dovecot: pop3-login: Login: user=<[email protected]>, method=PLAIN, rip=192.168.0.112, lip=78.46.229.46, mpid=17964, TLS, session=  
Aug 22 09:45:10 mail dovecot: pop3([email protected])<17964>: Disconnected: Logged out top=0/0, retr=0/0, del=0/0, size=0  
Aug 22 09:45:10 mail postfix/smtpd[6932]: NOQUEUE: reject: RCPT from unknown[1.2.3.4]: 504 5.5.2 <1.2.3.4>: Helo command rejected: need fully-qualified hostname; from=<[email protected]> to=<[email protected]> proto=ESMTP helo=<1.2.3.4>

Para monitorear continuamente un archivo de registro en busca de conexiones para esta dirección de correo electrónico, combina los comandos tail y grep así:

tail -f /var/log/mail.log | grep [email protected]

Para salir de la función de vigilancia, presiona las teclas [strg] + c.

Más ejemplos del comando GREP

Puedes encontrar aún más ejemplos de uso de este comando de Linux en nuestro segundo tutorial sobre el comando GREP.

• Cómo realizar una búsqueda de patrones en archivos usando Grep