LinuxParty

¿Cómo uso el comando grep en Linux o Apple macOS/OS X? ¿Cómo puedo usar el comando grep en los sistemas operativos Unix? ¿Puede darme ejemplos simples del comando grep?

Grep es un comando esencial de Linux y Unix. Se utiliza para buscar texto y cadenas en un archivo determinado. En otras palabras, el comando grep busca en el archivo dado líneas que contengan una coincidencia con las cadenas o palabras dadas. Es uno de los comandos más útiles en Linux y sistemas similares a Unix para desarrolladores y administradores de sistemas. Veamos cómo usar grep en un sistema similar a Linux o Unix.

Requisitos de la tutoría

Requisitos Linux/Unix/macOS

Privilegios de raíz No

Nivel de dificultad Fácil

Tiempo de lectura 9 minutos

¿Sabías?

El nombre, “grep”, deriva del comando usado para realizar una operación similar, usando el editor de texto de Unix/Linux ed: g/re/p

Las utilidades grep son una familia que incluye grep, egrep y fgrep para buscar archivos. Para la mayoría de los casos de uso, fgrep es suficiente debido a la velocidad y solo busca cadenas y palabras. Sin embargo, escribir grep es fácil. Por lo tanto, es una elección personal.

Ejemplos de comandos grep en Linux y Unix

A continuación se muestra un comando grep estándar explicado con ejemplos para que pueda comenzar con grep en Linux, macOS y Unix:

Busque cualquier línea que contenga la palabra en nombre de archivo en Linux:

grep 'palabra' filename

Realice una búsqueda sin distinción entre mayúsculas y minúsculas para la palabra 'bar' en Linux y Unix:

grep -i 'bar' file1

Busque en todos los archivos en el directorio actual y en todos sus subdirectorios en Linux para la palabra 'httpd':

grep -R 'httpd' .

Busque y muestre el número total de veces que aparece la cadena 'linuxparty' en un archivo llamado frontpage.md:

grep -c 'linuxparty' frontpage.md

Veamos todos los comandos y opciones en detalle.

Sintaxis

La sintaxis es la siguiente:

    grep 'palabra' nombre-de-archivo
    

    # Interprete los PATRONES como cadenas fijas, no como expresiones regulares (regex) cuando se usa fgrep.

    fgrep 'palabra-a-buscar' archivo.txt        # busca en archivo.txt

    grep -F 'patrón' nombre-del-archivo.txt     # igual que fgrep

    grep 'palabra' archivo1 archivo2 archivo3   # Buscar la misma palabra en arhivos diferentes

    grep 'cadena1 cadena2' nombre-del-archivo.dat   # buscar varias palabras en un mismo archivo

    cat archivo | grep 'algo'   # Igual que la primera opción.

    comando | grep 'algo'

    comando opción1 |   grep 'datos'

    grep --color    'datos'     fichero     # Salidas que permiten ver mejor los resultados

    grep  [-opciones]  patrón   ficheros
    
    fgrep [-options]   palabras ficheros

¿Cómo uso grep para buscar un archivo en Linux?

Busque en el archivo /etc/passswd un usuario llamado 'boo', ingrese:

grep  boo  /etc/passwd

Salidas de muestra:

foo:x:1000:1000:boo,,,:/home/boo:/bin/ksh

Podemos usar fgrep/grep para encontrar todas las líneas de un archivo que contienen una palabra en particular. Por ejemplo, para enumerar todas las líneas de un archivo llamado dirección.txt en el directorio actual que contiene la palabra "California", ejecute:

fgrep California address.txt

Tenga en cuenta que el comando anterior también devuelve líneas donde "California" es parte de otras palabras, como "Californication" o "Californian". Por lo tanto, pase la opción -w con el comando grep/fgrep para obtener solo las líneas donde se incluye "California" como una palabra completa:

fgrep -w California address.txt

Puede obligar a grep a ignorar mayúsculas y minúsculas, es decir, hacer coincidir boo, Boo, BOO y todas las demás combinaciones con la opción -i. Por ejemplo, escriba el siguiente comando:

grep  -i  "boo"   /etc/passwd

Ejemplos de comandos grep para usuarios de Linux y Unix

El último grep -i "boo" /etc/passwd puede ejecutarse de la siguiente manera usando el comando cat también:

cat  /etc/passwod  |  grep -i "boo"

Cómo usar grep recursivamente

Puede buscar recursivamente, es decir, leer todos los archivos en cada directorio para una cadena "192.168.1.5"

grep -r "192.168.1.5" /etc/

O

grep -R "192.168.1.5" /etc/

Salidas de muestra:

/etc/ppp/options:# ms-wins 192.168.1.50
/etc/ppp/options:# ms-wins 192.168.1.51
/etc/NetworkManager/system-connections/Wired connection 1:addresses1=192.168.1.5;24;192.168.1.2;

Verá el resultado de 192.168.1.5 en una línea separada precedida por el nombre del archivo (como /etc/ppp/options) en el que se encontró. La inclusión de los nombres de archivo en los datos de salida se puede suprimir usando la opción -h de la siguiente manera:

grep -h -R "192.168.1.5" /etc/

O

grep -hR "192.168.1.5" /etc/

Salidas de muestra:

# ms-wins 192.168.1.50
# ms-wins 192.168.1.51
addresses1=192.168.1.5;24;192.168.1.2

Cómo usar grep para buscar solo palabras

Cuando busque boo, grep coincidirá con fooboo, boo123, barfoo35 y más. Puede forzar el comando grep para que seleccione solo aquellas líneas que contengan

coincidencias que formen palabras completas, es decir, que coincidan solo con la palabra boo:

grep -w archivo "boo"

Cómo usar grep para buscar 2 palabras diferentes

Use el comando egrep de la siguiente manera:

egrep -w 'palabra1|palabra2' /ruta/al/archivo

Ignorar caso

Podemos obligar a grep a ignorar el caso distintivo

Podemos obligar a grep a ignorar las distinciones de mayúsculas y minúsculas en patrones y datos. Por ejemplo, cuando busco 'bar', encuentro 'BAR', 'Bar', 'BaR' y así sucesivamente:

grep -i  'bar'  /ruta/al/archivo

En este ejemplo, voy a incluir todos los subdirectorios en una búsqueda:

grep -r -i 'principal' ~/proyectos/

¿Cómo puedo contar la línea cuando las palabras se han emparejado?

El grep puede informar la cantidad de veces que el patrón se ha emparejado para cada archivo usando la opción -c (recuento):

grep -c 'palabra' /ruta/al/archivo

Pase la opción -n para preceder cada línea de salida con el número de línea en el archivo de texto del que se obtuvo:

grep  -n  'root'  /etc/passwd

1:root:x:0:0:root:/root:/bin/bash
1042:rootdoor:x:0:0:rootdoor:/home/rootdoor:/bin/csh
3319:initrootapp:x:0:0:initrootapp:/home/initroot:/bin/ksh

Forzar a grep a invertir la coincidencia (o coincidencia inversa)

Ideal para en caso de mostrar el contenido de archivos, por ejemplo sin los comentarios... usando:

grep -v "#" script.sh

Puede usar la opción -v para imprimir la coincidencia inversa; es decir, coincide solo con aquellas líneas que no contienen la palabra dada.

Por ejemplo, imprima todas las líneas que no contengan la palabra bar:

grep -v bar /ruta/al/archivo

grep -v '^root' /etc/passwd

Mostrar líneas antes de cada coincidencia.

¿Quieres ver las líneas antes de tus coincidencia? Intenta pasar la -B al grep:

grep -B NUM archivo "palabra"

grep -B 3 "foo" archivo1

De manera similar, muestre las líneas después de sus coincidencias pasando -A al grep:

grep -A NUM "cadena" /ruta/al/archivo

# Mostrar 4 líneas después de que coincida la palabra soltada en el archivo de registro del cortafuegos #

grep -A 4 "caído" /var/log/ufw.log

Podemos combinar esas dos opciones para obtener resultados más significativos:

grep -C 4  -B 5  -A 6  --color  'código de error'  /var/log/httpd/access_log

Aquí hay un script de shell de muestra que obtiene las URL de descarga del kernel de Linux:

.......
...
_out="/tmp/out.$$"
curl -s https://www.kernel.org/ > "$_out"
#######################
## grep -A used here ##
#######################
url="$(grep -A 2 '<td id="latest_button">' ${_out}  | grep -Eo '(http|https)://[^/"]+.*xz')"
gpgurl="${url/tar.xz/tar.sign}"
notify-send "A new kernel version ($remote) has been released."
echo "* Downloading the Linux kernel (new version) ..."
wget -qc "$url" -O "${dldir}/${file}"
wget -qc "$gpgurl" -O "${dldir}/${gpgurl##*/}"
.....
..

Tuberías UNIX/Linux

El comando grep se usa a menudo con shell pipes. En este ejemplo, muestre el nombre de los dispositivos de disco duro:

dmesg | egrep '(s|h)d[a-z]'

Mostrar el nombre del modelo de la CPU:

cat /proc/cpuinfo | grep -i 'Model'

Sin embargo, el comando anterior también se puede usar de la siguiente manera sin shell pipe:

grep -i 'Model' /proc/cpuinfo

[javier@localhost ~]$ grep -i 'Model' /proc/cpuinfo     
model           : 42
model name      : Intel(R) Pentium(R) CPU B950 @ 2.10GHz
model           : 42
model name      : Intel(R) Pentium(R) CPU B950 @ 2.10GHz
[javier@localhost ~]$ 

 Uno de mis usos favoritos del comando grep o egrep para filtrar la salida del comando yum/comando dpkg/comando apt/comando apt-get:

dpkg --list | grep linux-image

yum search php | grep gd

apt search maria | egrep 'server|client'

comando grep en Linux con ejemplos

Comandos grep de Linux explicados con ejemplos de shell pipes

¿Cómo enumero solo los nombres de los archivos coincidentes?

Use la opción -l para enumerar el nombre del archivo cuyo contenido menciona main():

grep -l 'main' *.c
OR

grep -Rl 'main' /path/to/project/dir/

Opción Colors

Finalmente, podemos forzar a grep a mostrar la salida en colores, ingrese:

grep --color vivek /etc/passwd

Comando Grep en acción en sistemas similares a Linux y Unix

Comando Grep en acción

En conclusión, la opción --color aumenta la legibilidad. Por ejemplo, la variable de entorno GREP_COLOR y grep --color=always se pueden usar de la siguiente manera:

GREP_COLOR='1;35' grep --color=always 'vivek' /etc/passwd
GREP_COLOR='1;32' grep --color=always 'vivek' /etc/passwd
GREP_COLOR='1;37' grep --color=always 'root' /etc/passwd
GREP_COLOR='1;36' grep --color=always nobody /etc/passwd

Agrupación visual

Además, al color rojo predeterminado ahora podemos definir colores usando la variable de shell GREP_COLOR. El color diferente nos ayuda enormemente con el grepping visual.

Guardando la salida grep en un archivo

Digamos que desea buscar la palabra clave acl y guardar esa salida en un archivo llamado my-acl.txt, y luego debe ejecutar:

grep acl squid.conf > mi-acl.txt

Podemos buscar sintonía y limitar la búsqueda a palabras que comiencen con la palabra clave llamada acl:

grep -w '^acl' squid.conf > mi-acl.txt

Vea el resultado final usando el comando cat/comando más o comando menos:

cat mi-acl.txt

Buscar caracteres especiales usando grep

¿Quiere buscar caracteres especiales [ o ' o ^ usando grep? Puede pedirle a grep que trate su entrada como una cadena fija usando la opción -F o el comando fgrep. Por ejemplo:

# coincide con '[xyz]' en el nombre del archivo

fgrep '[xyz]' filename grep -F '[xyz]' filename

Utilice \ como carácter de escape

Para hacer coincidir un carácter que es especial para egrep o grep -E, una barra invertida (\) delante del carácter. Por lo general, es más sencillo usar grep -F cuando no necesita una coincidencia de patrón especial. Por ejemplo, intente hacer coincidir 'foo' poniendo \ antes de ':

grep -E '\'foo\'' input

En orden, use fgrep o grep -F cuando no necesite usar la coincidencia de patrones usando expresiones regulares.

Conjunto de metacaracteres para una expresión regular que necesita egrep

En orden, use fgrep o grep -F cuando no necesite usar la coincidencia de patrones usando expresiones regulares.

Conjunto de metacaracteres para una expresión regular que debe escaparse si desea que coincidan

Consulte el comando egrep para obtener más información y ejemplos sobre expresiones regulares:

.
 ^
 $   [
 \   *   \{   \}   \(   \)
.   [   $   [   \   *   \{   \}   \(   \)

Los metacaracteres de expresiones regulares extendidas son:

.
^
$  [
\  *  +
?  {  }  |  (  )

Conclusión

El comando grep es muy versátil y muchos usuarios nuevos de Linux o Unix lo encuentran complicado. Por lo tanto, le sugiero que lea la página de manual de grep también. Resumamos la mayoría de las opciones de importación:

Comando grep en Unix/Linux Opciones Descripción

-i Ignorar distinciones de mayúsculas y minúsculas en Linux y Unix

-w Fuerza el PATRÓN para que coincida solo con palabras completas

-v Seleccionar líneas no coincidentes

-n Imprimir número de línea con líneas de salida

-h Suprime el prefijo del nombre del archivo Unix en la salida

-H Imprime el nombre del archivo con líneas de salida

-r Buscar directorios recursivamente en Linux

-R Igual que -r pero sigue todos los enlaces simbólicos

-l Imprime solo los nombres de los ARCHIVOS con líneas seleccionadas

-c Imprime solo un recuento de líneas seleccionadas por ARCHIVO

--color Mostrar patrón coincidente en colores

-m NÚMERO Detener comando grep NÚMERO líneas seleccionadas

-o Mostrar solo partes coincidentes de líneas

-B NÚMERO Muestra NÚMERO de líneas del contexto anterior coincidente

-UN NÚMERO Muestra NÚMERO de líneas después del contexto coincidente

-C NÚMERO Mostrar NÚMERO líneas de contexto de salida

Si disfrutó del tutorial de grep, entonces le gustaría leer nuestro tutorial "Expresiones regulares en Grep". Lea la página de manual del comando grep escribiendo el siguiente comando man:  

man grep