COMANDO GREP

Para mostrar todas las líneas que contienen la cadena «tal» en una lista de archivos (donde
«*» representa todos los archivos en el directorio actual):

$ grep tal *

Para mostrar todas las líneas que no contengan la cadena «tal», se usa «-v»:

$ grep -v tal *

Para mostrar sólo el nombre de tales archivos, se usa «-l»:

$ grep -l tal *

Para mostrar sólo el nombre de los archivos que no contienen la cadena, se usa «-L»:

$ grep -L tal *

Para buscar recursivamente, no sólo en los archivos del directorio actual sino también en
los de sus subdirectorios (donde "." representa el directorio actual), se usa «-r»:

$ grep -r tal .

En solaris no funciona el parámetro -r. Para obtener la misma funcionalidad, se debe

utilizar además el comando «find» y el comando «exec» (Recordemos, el parámetro «-l»
mostrará únicamente el nombre del archivo que contenga la cadena "tal"):

$ find . -name "*.*" -exec grep -l "tal" {} \;

La opción -r puede no estar disponible en todas las plataformas Unix. De ser así utilizar:

$ find . -type f | xargs grep tal .

Para buscar todas las líneas que comienzan por «Ahora» y terminan con «siempre» seguido
de una cantidad arbitraria de espacio en blanco (nótese que el carácter ^ representa el inicio
de la línea, así como $ representa el final):

$ grep '^Ahora.*siempre *$'

Para hacer que grep lea de la entrada estándar, no se especifica archivo alguno. Por
ejemplo, como ps -ef lista todos los procesos actualmente en ejecución, el siguiente
comando imprime todos los procesos que está ejecutando el usuario actual:

$ ps -ef | grep $USER

o
$ ps -efa | grep $USER
Mostrará las cuentas de usuarios que presenten actividad en ese momento.

---------------------------------------------------------------------------------------------

grep

Busca en la entrada, líneas que concuerden con el patrón dado. Cualquier meta-carácter con
un significado especial debe ser protegido precediéndolo con una barra inclinada inversa
(\ ). Algunos patrones de grep se encierran entre '..' (apóstrofos) para indicarle que no es un
metacarácter del sehll. También existe en su versión zgrep para buscar en archivos
comprimidos.

grep [opciones] 'patrón' archivos

grep "ejemplo" * listara las lineas que concuerden con la cadena ejemplo de "todos" los
archivos del directorio actual.

grep -i hola pp.txt considera idénticas las mayúsculas y minúscula en la cadena de

búsqueda hola. (hola=HOLA=Hola=etc.).

grep -ri "hola" ./ busca en los archivos del directorio actual y los subdirectorios la palabra
hola.

grep -v hola pp.txt lista las líneas que no contengan la cadena hola del archivo pp.txt

grep -n hola pp.txt las líneas concordantes con la cadena hola del archivo pp.txt se
mostrarán acompañadas del número de línea.

grep -w sobre pp.txt listara solamente aquellas líneas que contienen concordancias que
forman palabras completas.

grep -A 2 hola pp.txt muestra 2 líneas de contexto después de las que concuerden con el
patrón hola.

grep -B 2 hola pp.txt muestra 2 líneas de contexto antes de las que concuerden con el patrón
hola.

grep -f patron.txt pp.txt obtiene el patrón de fichero patron.txt y listara líneas concordantes
del archivo pp.txt

grep -s "ejemplo" * suprime los mensajes de error sobre ficheros que no existen o no se
pueden leer.

grep [123] pp.txt listara las lineas que contengan los números 1, 2 o 3
grep '^L' pp.txt lista las lineas de pp.txt que comiencen la línea con el carácter L, el carácter
^ denota inicio de cadena.

grep 'h$' pp.txt lista las líneas de pp.txt que terminen en h, el carácter $ denota fin de
cadena.

grep '\<pe' pp.txt muestra todas las líneas de pp.txt que contengan palabras que comiencen
con la cadena pe.

grep '\>pe' pp.txt muestra todas las líneas de pp.txt que contengan palabras que finalicen
con la cadena pe.

grep 'xy*' pp busca en pp una x seguida por la secuencia más larga de y.

grep '^[^#]' pp.txt muestra pp.txt, ocultando las líneas que empiezan por # y las líneas
vaciás.

grep -o patron archivo muestra solo la parte de la linea que coincide con el patrón.

grep --color=always '\bing[[:space:]]' pp.txt | less -R la palabra ing seguida de un espacio

sera coloriada y esta redirigida al comando less sin perder el color.

grep -Eio '([[:alnum:]_.-]+@[[:alnum:]_.-]+?\.[[:alpha:].]{2,6})' archivo.txt muestra solo las

direcciones de e-mail (no todo la linea que la contiene), del archivo.txt.

Comando grep

El comando grep nos permite buscar, dentro de los archivos, las líneas que concuerdan con
un patrón. Bueno, si no especificamos ningún nombre de archivo, tomará la entrada
estándar, con lo que podemos encadenarlo con otros filtros.

Por defecto, grep imprime las líneas encontradas en la salida estándar. Es decir, que
podemos verlo directamente la pantalla, o redireccionar la salida estándar a un archivo.

Como tiene muchísimas opciones, vamos a ver tan sólo las más usadas:

-c En lugar de imprimir las líneas que coinciden, muestra el número de líneas que
coinciden.
-e PATRON nos permite especificar varios patrones de búsqueda o proteger aquellos
patrones de búsqueda que comienzan con el signo -.
-r busca recursivamente dentro de todos los subdirectorios del directorio actual.
-v nos muestra las líneas que no coinciden con el patrón buscado.
-i ignora la distinción entre mayúsculas y minúsculas.
-n Numera las líneas en la salida.
-E nos permite usar expresiones regulares. Equivalente a usar egrep.
-o le indica a grep que nos muestre sólo la parte de la línea que coincide con el patrón.
-f ARCHIVO extrae los patrones del archivo que especifiquemos. Los patrones del archivo
deben ir uno por línea.
-H nos imprime el nombre del archivo con cada coincidencia.

Veamos algunos ejemplos:

- Buscar todas las líneas que contengan palabras que comiencen por a en un archivo:
$ grep '\<a.*\>' archivo

Otra forma de buscar, sería:

$ cat archivo | grep "\<a.*\>"

- Mostrar por pantalla, las líneas que contienen comentarios en el archivo

/boot/grub/menu.lst:
$ grep "#" /boot/grub/menu.lst

- Enviar a un fichero las líneas del archivo /boot/grub/menu.lst que no son comentarios:
$ grep -v "#" /boot/grub/menu.lst

- Contar el número de interfaces de red que tenemos definidos en el fichero

/etc/network/interfaces:
$ grep -c "iface" /etc/network/interfaces

- Mostrar las líneas de un fichero que contienen la palabra BADAJOZ o HUELVA:

$ grep -e "BADAJOZ" -e "HUELVA" archivo

- Mostrar las líneas de un fichero que contienen la palabra BADAJOZ o HUELVA,

numerando las líneas de salida:
$ grep -n -e "BADAJOZ" -e "HUELVA" archivo

- Mostrar los ficheros que contienen la palabra TOLEDO en el directorio actual y todos sus
subdirectorios:
$ grep -r "TOLEDO" *

Veamos algunos ejemplos con expresiones regulares:

- Obtener la dirección MAC de la interfaz de red eth0 de nuestra máquina:

$ ifconfig eth0 | grep -oiE '([0-9A-F]{2}:){5}[0-9A-F]{2}'

Sacamos la dirección MAC de la interfaz eth0 de nuestra máquina haciendo un:

ifconfig eth0

Y aplicando el filtro grep:

grep -oiE '([0-9A-F]{2}:){5}[0-9A-F]{2}'

Las opciones que he usado en grep son:

-o Indica que la salida del comando debe contener sólo el texto que coincide con el patrón,
en lugar de toda la línea, como es lo habitual.
-i Lo he usado para que ignore la distinción entre mayúsculas y minúsculas.
-E Indica que vamos a usar una expresión regular extendida.

En cuanto a la expresión regular, podemos dividirla en dos partes:

([0-9A-F]{2}:){5} Buscamos 5 conjuntos de 2 carateres seguidos de dos puntos
[0-9A-F]{2} seguido por un conjunto de dos caracteres.

Como las direcciones MAC se representan en hexadecimal, los caracteres que buscamos son los números del
0 al 9 y las letras desde la A a la F.

- Extraer la lista de direcciones de correo electrónico de un archivo:

grep -Eio '[a-z0-9._-]+@[a-z0-9.-]+[a-z]{2,4}' fichero.txt

Utilizo las mismas opciones que en el caso anterior:

-o Indica que la salida del comando debe contener sólo el texto que coincide con el patrón,
en lugar de toda la línea, como es lo habitual.
-i Lo he usado para que ignore la distinción entre mayúsculas y minúsculas.
-E Indica que vamos a usar una expresión regular extendida.

Analicemos ahora la expresión regular:

[a-z0-9._-]+@[a-z0-9.-]+[a-z]{2,4}

Al igual que antes, la vamos dividiendo en partes:

[a-z0-9._-]+ Una combinación de letras, números, y/o los símbolos . _ y - de uno o más caracteres
@ seguido de una arroba
[a-z0-9.-]+ seguido de una cadena de letras, números y/o los símbolos . y -
[a-z]{2,4} seguido de una cadena de entre dos y cuatro caracteres.

- Obtener la dirección IP de la interfaz de red eth1 de nuestra máquina:

$ ifconfig eth1 | grep -oiE '([0-9]{1,3}\.){3}[0-9]{1,3}' | grep -v 255

En el ejemplo anterior, hemos tomado la información que nos ofrece ifconfig:

ifconfig eth1

Hemos filtrado dicha información con el comando grep, obteniendo todas las direcciones IP
que aparecen:
grep -oiE '([0-9]{1,3}\.){3}[0-9]{1,3}'

Por último, hemos filtrado la salida del comando anterior, para eliminar la dirección de broadcast junto con la
máscara de red para quedarnos sólo con la dirección IP de la máquina:
grep -v 255

La línea anterior no mostraría las líneas que no contengan el valor 255, es decir, las direcciones de broadcast y
máscara de red.

Analicemos ahora el comando grep:

grep -oiE '([0-9]{1,3}\.){3}[0-9]{1,3}'

Al igual que en los otros dos ejemplos de expresiones regulares uso las opciones -oiE en el
comando grep:

-o Indica que la salida del comando debe contener sólo el texto que coincide con el patrón,
en lugar de toda la línea, como es lo habitual.
-i Lo he usado para que ignore la distinción entre mayúsculas y minúsculas.
-E Indica que vamos a usar una expresión regular extendida.
- See more at: http://enavas.blogspot.com.es/2008/04/el-shell-de-linux-comando-
grep.html#sthash.wmWh14KY.dpuf

EL COMANDO grep:
Supongamos que tenemos un archivo con una lista de nombres, digamos alumnos de una
clase, y queremos encontrar a todos aquellos que se apelliden Cervantes.
Una forma fácil de hacerlo es con el comando grep:

grep Cervantes Archivo.dat

que produce la salida:

Mario Cervantes
Carmen Cervantes

grep desplegará las líneas que contienen Cervantes, incluso si es parte de una palabra más
grande, como Cervantesaavedra.
La forma general del comando grep es la siguiente:

grep Patron Archivo1 Archivo2

Supongamos, por ejemplo, que no solamente tenemos un grupo de alumnos, sino 2, y los
nombres de los alumnos están escritos en Archivo.txt y Archivo.dat, entonces la línea

grep Cervantes Archivo.dat Archivo.txt

produce

Archivo.txt:Mario Cervantes
Archivo.txt:Carmen Cervantes
Archivo.dat:Josefina Cervantes
Archivo.dat:Jose Luis Cervantes

que indica los nombres que incluyen Cervantes y dicen además de qué archivo viene. O,
usando el comodín asterísco

grep Cervantes Archivo*

que produce el mismo resultado, si es que no hay otro(s) archivo(s) cuyo nombre empiece
con la palabra Archivo que también contenga(n) la cadena Cervantes.
CONECTANDO COMANDOS POR MEDIO DE TUBERÍAS:
Si no indicamos algún archivo para grep, entonces toma los datos de la salida estándar. Por
ejemplo. Supongamos que en el sistema hay muchos usuarios pero en particular queremos
saber si el usuario elisa está logueado. Para saberlo podríamos usar una linea como esta:

who | grep elisa

y podríamos obtener algo como:

elisa pts/0 2012-06-22 21:38 (:0)

elisa pts/1 2012-06-22 22:14 (:0)
elisa pts/3 2012-06-22 23:07 (:0)
elisa pts/4 2012-06-23 00:09 (:0)

el comando who nos dice qué usuarios están en el sistema. La barra es una conexión o
“tubería” entre who y grep. | toma la salida de who y la envía como entrada a grep. El
comando grep entonces busca la cadena elisa dentro de la salida de who.
En este par de ejemplos, grep se ha usado como filtro. Debido a que who puede devolver
decenas de líneas, es necesario filtrar esa información. El comando grep es un filtrador
natural en Unix.
BUSCANDO UN PATRÓN SIN IMPORTAR MAYÚSCULAS O MINÚSCULAS:
Podría ocurrir que en alguno de los archivos en los que estamos buscando el apellido
Cervantes, apareciera el apellido de una manera distinta. Digamos CERVANTES o
cervantes; en este caso, con la sola instrucción grep Cervantes Archivo no se obtiene
ningún resultado. Para buscar coincidencias de cadenas sin importar si las letras son
mayúsculas o minúsculas, existe la opción -i en el comando grep:

grep -i Cervantes Archivo.dat

y obtenemos la salida

Josefina Cervantes
Jose Luis Cervantes
Fernando cervantes

que indica que en Archivo.dat había alguien con apellido Cervantes, que no se mostraba
antes, porque la primera letra estaba en minúsculas.
BUSCANDO CADENAS CON ESPACIOS EN BLANCO
El comando grep también puede ser usado para encontrar expresiones que contengan
espacios en blanco. Por ejemplo, vamos a suponer que deseamos encontrar en nuestra lista
de alumnos en Archivo.dat a el alumno Elisa Griensen. Para hacer la búsqueda bastará
colocar como patrón ese nombre entre comillas sencillas ‘ o comillas dobles “:

grep 'Elisa Griensen' -i Archivo.dat

En donde, puesto que ya conocemos a nuestro capturista de datos, hemos puesto la opción
-i para indicarle a grep que no debe de tomar en cuenta diferencias entre mayúsculas y
minúsculas. Esta opción puede ir antes o después del patrón. Al ejecutarlo podemos
encontrar:

Elisa griensen

y por la salida, que indica el apellido griensen en minúsculas, sabemos que hemos hecho
bien en incluir la opción -i.

INDICANDO EL NÚMERO DE LÍNEA DE LAS COINCIDENCIAS DEL PATRÓN

Si el archivo donde tenemos nuestra lista de estudiantes es muy grande, tal vez nos
interesaría saber en qué línea exactamente está nuestra coincidencia. Por ejemplo Elisa
Griensen. Para ésto usamos la opción -n del comando grep

grep 'Elisa Griensen' -in Archivo.dat

y obtenemos:

6:Elisa griensen