Cómo usar el comando Grep en Linux

Introducción

El grep que significa "impresión de expresión regular global" es uno de los comandos más poderosos y de uso común en Linux.

Grep busca uno o más archivos de entrada buscando líneas que coincidan con un patrón particular y escribe cada línea coincidente en la salida estándar. Si no se especifica ningún archivo, grep lee la entrada estándar, que suele ser la salida de otro comando.

En este tutorial, le mostraremos cómo usar el grep través de ejemplos prácticos y explicaciones detalladas de las grep

Sintaxis del comando grep

Antes de entrar en cómo usar el grep, comencemos mirando la sintaxis básica.

La sintaxis de grep toma la siguiente forma:

grep [OPTIONS] PATTERN [FILE...]

Los elementos entre corchetes son opcionales.

• OPTIONS: cero o más opciones. Grep ofrece una serie de opciones que controlan su comportamiento.
• PATTERN - Modelo de búsqueda.
• FILE: cero o más nombres de archivo de entrada.

Para poder buscar el archivo, el usuario que ejecuta el comando debe tener acceso de lectura al archivo.

Cómo usar grep para buscar una cadena en archivos

El uso más básico del grep es buscar una cadena (texto) en un archivo.

Por ejemplo, para ver líneas del /etc/passwd contiene la bash, puede usar el siguiente comando:

grep bash /etc/passwd

La salida debería verse así:

root:x:0:0:root:/root:/bin/bash
 noviello:x:1000:1000:noviello:/home/noviello:/bin/bash

Si la cadena incluye espacios, debe encerrarse entre comillas simples o dobles:

grep "Gnome Display Manager" /etc/passwd

Invertir coincidencia (excluir)

Para mostrar líneas que no coinciden con el valor buscado, use la -v (o --invert-match ).

Por ejemplo, para ver líneas en el /etc/passwd que no contienen la cadena nologin puede usar el siguiente comando:

grep -v nologin /etc/passwd

root:x:0:0:root:/root:/bin/bash
 colord:x:124:124::/var/lib/colord:/bin/false
 git:x:994:994:git daemon user:/:/usr/bin/git-shell
 noviello:x:1000:1000:noviello:/home/noviello:/bin/bash

Cómo usar Grep para buscar una cadena en la salida del comando

En lugar de especificar los archivos de entrada, puede redirigir la salida de otro comando a grep y luego solo mostrar líneas que coincidan con un patrón determinado.

Por ejemplo, para averiguar qué procesos se están ejecutando en el sistema como usuario, www-data puede usar el siguiente ps

ps -ef | grep www-data

www-data 18247 12675 4 16:00 ? 00:00:00 php-fpm: pool www
 root 18272 17714 0 16:00 pts/0 00:00:00 grep --color=auto --exclude-dir=.bzr --exclude-dir=CVS --exclude-dir=.git --exclude-dir=.hg --exclude-dir=.svn www-data
 www-data 31147 12770 0 Oct22 ? 00:05:51 nginx: worker process
 www-data 31148 12770 0 Oct22 ? 00:00:00 nginx: cache manager process

También puede encadenar múltiples tuberías a pedido. Como puede ver en la salida anterior, también hay una línea que contiene el proceso grep Si no desea ver esa línea, pase la salida a otra grep, como se muestra a continuación.

ps -ef | grep www-data | grep -v grep

www-data 18247 12675 4 16:00 ? 00:00:00 php-fpm: pool www
 root 18272 17714 0 16:00 pts/0 00:00:00 grep --color=auto --exclude-dir=.bzr --exclude-dir=CVS --exclude-dir=.git --exclude-dir=.hg --exclude-dir=.svn www-data
 www-data 31147 12770 0 Oct22 ? 00:05:51 nginx: worker process
 www-data 31148 12770 0 Oct22 ? 00:00:00 nginx: cache manager process

Búsqueda recursiva

Para buscar de forma recursiva un patrón a utilizar, utilice la -r (o --recursive ). Esto buscará en todos los archivos en el directorio especificado, omitiendo los enlaces simbólicos que se encuentran de forma recursiva. Para seguir todos los enlaces simbólicos, use la -R (o --dereference-recursive ).

En el siguiente ejemplo, buscamos la cadena noviello.it en todos los archivos dentro del directorio /etc

grep -r noviello.it /etc

El comando imprimirá las líneas correspondientes precedidas por la ruta completa al archivo.

/etc/hosts:127.0.0.1 node2.noviello.it
 /etc/nginx/sites-available/noviello.it: server_name noviello.it www.noviello.it;

Si en lugar de usar la -r usa la -R, el grep seguirá todos los enlaces simbólicos:

grep -R noviello.it /etc

Observe la última línea de la salida. Esa línea no está impresa en el ejemplo anterior porque los archivos dentro del sites-enabled son enlaces simbólicos a los archivos de configuración dentro del directorio de sites-available

/etc/hosts:127.0.0.1 node2.noviello.it
 /etc/nginx/sites-available/noviello.it: server_name noviello.it www.noviello.it;
 /etc/nginx/sites-enabled/noviello.it: server_name noviello.it www.noviello.it;

Mostrar solo el nombre de archivo

Para suprimir la grep e imprimir solo los nombres de archivo que contienen el patrón coincidente, puede usar la -l (o --files-with-matches ).

Por ejemplo, para buscar en todos los archivos que terminan con .conf en el directorio de trabajo actual e imprimir solo los nombres de archivo que contienen el tipo de cadena noviello.it:

grep -l noviello.it *.conf

La salida se verá así:

tmux.conf
 haproxy.conf

La -l se usa normalmente junto con la -R recursiva:

grep -Rl noviello.it /tmp

Búsqueda sin distinción entre mayúsculas y minúsculas (Insensible)

De forma predeterminada, el grep mayúsculas y minúsculas. Esto significa que los caracteres en mayúsculas y minúsculas se tratan como distintos.

Para ignorar el caso al buscar, use la -i (o --ignore-case ).

Por ejemplo, al buscar Zebra sin ninguna opción, el siguiente comando no mostrará ningún resultado, es decir, hay líneas coincidentes:

grep Zebra /usr/share/words

Pero si realiza una búsqueda que no distingue entre mayúsculas y minúsculas utilizando la -i, coincidirá con letras mayúsculas y minúsculas:

grep -i Zebra /usr/share/words

Especificar "Zebra" coincidirá con "zebra", "ZEbrA" o cualquier otra combinación de letras mayúsculas y minúsculas para esa cadena.

zebra
 zebra's
 zebras

Búsqueda completa de palabras

Al buscar "gnu", grep imprimirá líneas donde "gnu" está incrustado en palabras más grandes, como "cygnus" o "magnum".

grep gnu /usr/share/words

cygnus
 gnu
 interregnum
 lgnu9d
 lignum
 magnum
 magnuson
 sphagnum
 wingnut

Para devolver solo aquellas líneas donde la cadena especificada es una palabra completa (encerrada por caracteres que no son palabras), use la -w (o --word-regexp ).

Los caracteres de palabra incluyen caracteres alfanuméricos ( az, AZ y 0-9 ) y guiones bajos ( _ ). Todos los demás caracteres se consideran caracteres que no son palabras.

Si ejecuta el mismo comando anterior, incluida la -w, el grep solo devolverá aquellas líneas donde gnu se incluye como una palabra separada.

grep -w gnu /usr/share/words

gnu

Mostrar números de línea

Para mostrar el número de líneas que contienen una cadena que coincide con un patrón, use la -n (o --line-number ). Al usar esta opción, grep imprimirá coincidencias en la salida estándar con el prefijo del número de línea en el que se encontró.

Por ejemplo, para mostrar líneas del /etc/services contiene la cadena bash con el prefijo del número de línea correspondiente, puede usar el siguiente comando:

grep -n 10000 /etc/services

El resultado a continuación muestra que las coincidencias están en las líneas 10423 y 10424.

10423:ndmp 10000/tcp
 10424:ndmp 10000/udp

Contando resultados

Para imprimir un recuento de líneas correspondiente a la salida estándar, use la -c (o --count ).

En el siguiente ejemplo, contamos el número de cuentas que tienen /usr/bin/zsh como shell.

grep -c '/usr/bin/zsh' /etc/passwd

3

Buscar varias cadenas (patrones)

Puede unir dos o más patrones de búsqueda utilizando el |.

De forma predeterminada, grep interpreta el patrón como una expresión regular básica donde metacaracteres como | pierden su significado especial y deben usarse sus versiones inversas.

En el siguiente ejemplo, buscamos todas las apariciones de las palabras fatal, error y critical en el archivo de registro de errores de Nginx:

grep 'fatal\|error\|critical' /var/log/nginx/error.log

Si usa la opción de expresión regular extendida -E (o --extended-regexp ), el | no necesita ser guardado, como se muestra a continuación:

grep -E 'fatal|error|critical' /var/log/nginx/error.log

Modo silencioso

El -q (o --quiet ) le dice a grep no escriba nada en la terminal (salida estándar). Si se encuentra una coincidencia, el comando saldrá con el estado 0. Esto es útil cuando se usa grep en el shell donde desea verificar si un archivo contiene una cadena y realizar una determinada acción en función del resultado.

Aquí hay un ejemplo del uso de grep en modo silencioso como comando de prueba en una declaración if

if grep -q PATTERN filename
 then
 echo pattern found
 else
 echo pattern not found
 fi

Expresión regular básica

GNU Grep tiene dos conjuntos de funciones de expresión regular, Básica y Extendida. De forma predeterminada, grep interpreta el patrón como una expresión regular básica.

Cuando se usa en el modo de expresión regular básico, todos los demás caracteres excepto los metacaracteres son en realidad expresiones regulares que se corresponden con ellos mismos. A continuación se muestra una lista de los metacaracteres más utilizados:

Utilice el ^ (signo de intercalación) para hacer coincidir la expresión al principio de una línea. En el siguiente ejemplo, la ^kangaroo coincidirá solo si aparece al principio de una línea.

grep "^kangaroo" file.txt

Utilice el $ (dólar) para hacer coincidir la expresión con el final de una línea. En el siguiente ejemplo, la cadena kangaroo$ solo coincidirá si aparece al final de una línea.

grep "kangaroo$" file.txt

Utilice el . símbolo (punto) para que coincida con un solo carácter. Por ejemplo, para hacer coincidir cualquier cosa que comience con kan luego tenga dos caracteres y termine con la cadena roo, puede usar el siguiente patrón:

grep "kan..roo" file.txt

Utilice [ ] (paréntesis) para hacer coincidir cualquier carácter entre paréntesis. Por ejemplo, busque líneas que contengan accept o accent, puede usar el siguiente patrón:

grep "acce[np]t" file.txt

Utilice [^ ] (paréntesis) para hacer coincidir cualquier carácter individual entre paréntesis. El siguiente patrón coincidirá con cualquier combinación de cadenas que contengan co(any_letter_except_l)a, como coca, cobalt, etc., pero no coincidirá con las líneas que contengan cola,

grep "co[^l]a" file.txt

Para escapar de un carácter especial posterior, use el \ (barra invertida).

Expresiones regulares extendidas

Para interpretar el patrón como una expresión regular extendida, use la -E (o --extended-regexp ). Las expresiones regulares extendidas incluyen todos los metacaracteres básicos, junto con metacaracteres adicionales para crear patrones de búsqueda más complejos y poderosos. Aquí hay unos ejemplos:

Haga coincidir y extraiga todas las direcciones de correo electrónico de un archivo determinado:

grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" file.txt

Haga coincidir y extraiga todas las direcciones IP válidas de un archivo determinado:

grep -E -o '(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)' file.txt

La -o se usa para imprimir solo la cadena coincidente.

Imprimir líneas antes de un resultado

Para imprimir un número específico de líneas antes de las líneas coincidentes, use la -B (o --before-context ).

Por ejemplo, para mostrar cinco líneas de contexto inicial antes de las líneas coincidentes, use el siguiente comando:

grep -B 5 root /etc/passwd

Imprimir líneas después de un resultado

Para imprimir un número específico de líneas después de -A opción -A (o --after-context ).

Por ejemplo, para mostrar cinco líneas de contexto final después de hacer coincidir las líneas, use el siguiente comando:

grep -A 5 root /etc/passwd

Conclusión

El grep permite buscar un patrón dentro de los archivos. Si se encuentra una coincidencia, grep imprimirá las líneas que contienen el patrón especificado.