Comando Grep en Linux (Buscar texto en archivos)

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

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

En este artículo, le mostraremos cómo usar grep comando a través de ejemplos prácticos y explicaciones detalladas de los grep de GNU más comunes opciones.

grep Sintaxis del comando #

La sintaxis para grep El comando es el siguiente:

grep [OPTIONS] PATTERN [FILE...]

Los elementos entre corchetes son opcionales.

• OPTIONS - Cero o más opciones. Grep incluye una serie de opciones que controlan su comportamiento.
• PATTERN - Patrón de búsqueda.
• FILE - Cero o más nombres de archivos de entrada.

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

Buscar una cadena en archivos #

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

Por ejemplo, para mostrar todas las líneas que contienen la cadena bash desde el /etc/passwd archivo, ejecutaría el siguiente comando:

grep bash /etc/passwd

La salida debería verse así:

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

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

grep "Gnome Display Manager" /etc/passwd

Invertir coincidencia (excluir) #

Para mostrar las líneas que no coinciden con un patrón, use -v ( o --invert-match ) opción.

Por ejemplo, para imprimir las líneas que no contienen la cadena nologin usarías:

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
linuxize:x:1000:1000:linuxize:/home/linuxize:/bin/bash

Uso de Grep para filtrar la salida de un comando #

La salida de un comando se puede filtrar con grep a través de la tubería, y solo las líneas que coincidan con un patrón determinado se imprimirán en el terminal.

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

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 varias tuberías a la orden. Como puede ver en el resultado anterior, también hay una línea que contiene grep proceso. Si no desea que se muestre esa línea, pase la salida a otro grep instancia 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
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 recursivamente un patrón, invoque grep con el -r opción (o --recursive ). Cuando se usa esta opción grep buscará en todos los archivos del directorio especificado, omitiendo los enlaces simbólicos que se encuentran de forma recursiva.

Para seguir todos los enlaces simbólicos, en lugar de -r , use el -R opción (o --dereference-recursive ).

Aquí hay un ejemplo que muestra cómo buscar la cadena linuxize.com en todos los archivos dentro de /etc directorio:

grep -r linuxize.com /etc

La salida incluirá líneas coincidentes con el prefijo de la ruta completa al archivo:

/etc/hosts:127.0.0.1 node2.linuxize.com
/etc/nginx/sites-available/linuxize.com:    server_name linuxize.com   www.linuxize.com;

Si usa el -R opción, grep seguirá todos los enlaces simbólicos:

grep -R linuxize.com /etc

Observe la última línea de la salida a continuación. Esa línea no se imprime cuando grep se invoca con -r porque los archivos dentro de los sites-enabled de Nginx directorio son enlaces simbólicos a archivos de configuración dentro de sites-available directorio.

/etc/hosts:127.0.0.1 node2.linuxize.com
/etc/nginx/sites-available/linuxize.com:    server_name linuxize.com   www.linuxize.com;
/etc/nginx/sites-enabled/linuxize.com:    server_name linuxize.com   www.linuxize.com;

Mostrar solo el nombre de archivo #

Para suprimir el grep predeterminado generar e imprimir solo los nombres de los archivos que contienen el patrón coincidente, utilice -l ( o --files-with-matches ) opción.

El siguiente comando busca en todos los archivos que terminan en .conf en el directorio de trabajo actual e imprime solo los nombres de los archivos que contienen la cadena linuxize.com :

grep -l linuxize.com *.conf

La salida se verá así:

tmux.conf
haproxy.conf

El -l La opción generalmente se usa en combinación con la opción recursiva -R :

grep -Rl linuxize.com /tmp

Número de búsqueda que no distingue entre mayúsculas y minúsculas

Por defecto, grep distingue entre mayúsculas y minúsculas. Esto significa que los caracteres en mayúsculas y minúsculas se tratan como distintos.

Para ignorar mayúsculas y minúsculas al buscar, invoque grep con el -i opción (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 usando -i opción, 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

Buscar palabras completas #

Al buscar una cadena, grep mostrará todas las líneas donde la cadena está incrustada en cadenas más grandes.

Por ejemplo, si busca "gnu", todas las líneas en las que "gnu" está incrustado en palabras más grandes, como "cygnus" o "magnum", coincidirán:

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 (entre caracteres que no son palabras), use -w (o --word-regexp ) opción.

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

Si ejecuta el mismo comando que el anterior, incluido el -w opción, el grep el comando devolverá solo aquellas líneas donde gnu se incluye como una palabra separada.

grep -w gnu /usr/share/words

gnu

Mostrar números de línea #

El -n ( o --line-number ) la opción le dice a grep para mostrar el número de línea de las líneas que contienen una cadena que coincide con un patrón. Cuando se usa esta opción, grep imprime las coincidencias en la salida estándar con el prefijo del número de línea.

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

grep -n 10000 /etc/services

El siguiente resultado nos muestra que las coincidencias se encuentran en las líneas 10423 y 10424.

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

Recuento de coincidencias #

Para imprimir un recuento de líneas coincidentes en la salida estándar, use -c ( o --count ) opción.

En el siguiente ejemplo, estamos contando la cantidad de cuentas que tienen /usr/bin/zsh como un caparazón.

regular expressiongrep -c '/usr/bin/zsh' /etc/passwd

4

Modo silencioso n.º

El -q (o --quiet ) le dice a grep para funcionar en modo silencioso para no mostrar nada en la salida estándar. Si se encuentra una coincidencia, el comando sale con el estado 0 . Esto es útil cuando se usa grep en scripts de shell en los que desea verificar si un archivo contiene una cadena y realizar una determinada acción según el resultado.

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

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

Expresión regular básica #

GNU Grep tiene tres conjuntos de características de expresión regular, básico, extendido y compatible con Perl.

Por defecto, grep interpreta el patrón como una expresión regular básica donde todos los caracteres, excepto los metacaracteres, son en realidad expresiones regulares que coinciden.

A continuación se muestra una lista de los metacaracteres más utilizados:

• Usa el ^ (símbolo de intercalación) para que coincida con la expresión al comienzo de una línea. En el siguiente ejemplo, la cadena kangaroo coincidirá solo si ocurre al principio de una línea.

  grep "^kangaroo" file.txt

• Usa el $ (dólar) para que coincida con la expresión al final de una línea. En el siguiente ejemplo, la cadena kangaroo coincidirá solo si ocurre al final de una línea.

  grep "kangaroo$" file.txt

• Usa el . (punto) símbolo para que coincida con cualquier carácter individual. Por ejemplo, para hacer coincidir cualquier cosa que comience con kan luego tiene dos caracteres y termina con la cadena roo , podría usar el siguiente patrón:

  grep "kan..roo" file.txt

• Usar [ ] (corchetes) para que coincida con cualquier carácter individual encerrado entre corchetes. Por ejemplo, busque las líneas que contienen accept o “accent , podría usar el siguiente patrón:

  grep "acce[np]t" file.txt

• Usa [^ ] para que coincida con cualquier carácter único que no esté entre corchetes. El siguiente patrón coincidirá con cualquier combinación de cadenas que contengan co(any_letter_except_l)a , como coca , cobalt y así sucesivamente, pero no coincidirá con las líneas que contienen cola ,

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

Para escapar del significado especial del siguiente carácter, use el \ (barra invertida).

Expresiones regulares extendidas #

Para interpretar el patrón como una expresión regular extendida, use -E (o --extended-regexp ) opción. Las expresiones regulares extendidas incluyen todos los metacaracteres básicos, junto con metacaracteres adicionales para crear patrones de búsqueda más complejos y potentes. A continuación se muestran algunos 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 dado:

  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

El -o La opción se usa para imprimir solo la cadena coincidente.

Buscar múltiples cadenas (patrones) #

Se pueden unir dos o más patrones de búsqueda usando el operador OR | .

Por defecto, grep interpreta el patrón como una expresión regular básica donde los metacaracteres como | pierden su significado especial y deben usarse sus versiones con barra invertida.

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

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

Si usa la opción de expresión regular extendida -E , entonces el operador | no se debe escapar, como se muestra a continuación:

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

Imprimir líneas antes de una coincidencia #

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

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

grep -B 5 root /etc/passwd

Imprimir líneas después de una coincidencia #

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

Por ejemplo, para mostrar cinco líneas de contexto final después de las líneas coincidentes, usaría el siguiente comando:

grep -A 5 root /etc/passwd

Conclusión #

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

Hay mucho más para aprender sobre Grep en la página del Manual del usuario de Grep.

Si tiene alguna pregunta o comentario, no dude en dejar un comentario.