Expresiones regulares básicas — patrones de grep

Una herramienta para probar tu regex

También puedes probar los patrones de este artículo en el Probador de regex que funciona en el navegador. Te muestra dónde coincide tu patrón con tu texto de entrada, al instante.

Expresiones regulares básicas — ^ $ . * []

Una expresión regular es una forma de describir un patrón en el texto. grep interpreta la cadena que buscas como una expresión regular, así que puedes encontrar líneas por condiciones como 'empieza con este carácter' o 'aquí un carácter cualquiera', no solo por una cadena fija. Los 5 símbolos que hay que aprender para las expresiones regulares básicas son ^, $, ., * y [].

^ y $ son anclas para el inicio y el fin de una línea. . coincide con un carácter cualquiera y * significa cero o más repeticiones del carácter anterior. [abc] coincide con cualquiera de los caracteres entre corchetes y [a-z] coincide con un carácter en minúscula por rango. Combínalos para hacer búsquedas flexibles.

echo -e 'cat\ncot\ndog' > words.txt   # crear material
grep '^c' words.txt                       # cat y cot, que empiezan con c
grep 't$' words.txt                       # cat y cot, que terminan con t
grep 'c.t' words.txt                      # cat y cot que coinciden con c?t

① Crea un archivo material de 3 líneas con echo -e 'cat\ncot\ndog' > words.txt.

② Pasa a grep un patrón con el ancla de inicio de línea y muestra solo las líneas que empiezan con c.

③ Después, con un patrón que use el ancla de fin de línea, muestra las líneas que terminan con t.

④ Por último, con un patrón que ponga el símbolo de carácter cualquiera en medio, muestra las líneas donde hay un carácter entre c y t. (Ejecútalo correctamente y aparecerá una explicación.)

Repetición y clases de caracteres — * y []

* significa cero o más repeticiones del carácter anterior. ab*c coincide con líneas donde hay cero o más b, como ac, abc y abbc. [] coincide con cualquiera de los caracteres entre corchetes, así que [cb]at captura tanto cat como bat. Escribir un rango como [a-z] representa un carácter en minúscula.

echo -e 'ac\nabc\nabbc\naxc' > rep.txt   # crear material
grep 'ab*c' rep.txt                       # ac abc abbc, con cero o más b
echo -e 'cat\nbat\nrat' > cls.txt      # crear material
grep '[cb]at' cls.txt                     # las 2 líneas cat y bat

① Crea material para comprobar la repetición con echo -e 'ac\nabc\nabbc\naxc' > rep.txt.

② Pasa a grep un patrón que use el símbolo de cero o más repeticiones del carácter anterior y muestra las líneas donde puede haber cualquier número de b entre a y c.

③ Crea material para comprobar las clases de caracteres con echo -e 'cat\nbat\nrat' > cls.txt.

④ Con un patrón que use la clase de caracteres entre corchetes, muestra solo cat y bat.

O — coincidir con uno u otro con \|

En las expresiones regulares básicas, | (o) se trata tal cual como un carácter ordinario.

Para expresar la alternancia, añade una barra invertida y escribe \|, así que grep 'cat\|dog' coincide con las líneas que contienen cat o dog.

Con grep -E, que aprenderás más adelante, puedes escribir | directamente en lugar de \|.

echo -e 'cat\ndog\nfox' > sel.txt   # crear material
grep 'cat\|dog' sel.txt              # las 2 líneas que contienen cat o dog

① Crea un archivo material de 3 líneas con echo -e 'cat\ndog\nfox' > sel.txt.

② Para expresar 'o' en las expresiones regulares básicas, añade una barra invertida a |. Pasa a grep el patrón 'cat\|dog' y muestra las líneas que contienen cat o dog.

③ Confirma que fox no se imprime porque no coincide con ninguno.

Regex extendidas e imprimir la coincidencia — grep -E / grep -o

En las expresiones regulares básicas, + | ( ) necesitan escaparse, como \+ \| \( \), pero con grep -E puedes escribirlos directamente. grep -E habilita las expresiones regulares extendidas (ERE). Ahora puedes escribir directamente + (uno o más), | (o) y () (grupo), que necesitaban escaparse en las regex básicas. grep -E 'cat|dog' coincide con las líneas que contienen cat o dog.

grep -o imprime solo la subcadena coincidente, no toda la línea coincidente. Si hay varias coincidencias en una línea, imprime cada una en una línea separada. Resulta útil cuando quieres extraer solo las coincidencias de un log y contarlas.

Regex más avanzadas

grep -P (regex compatible con Perl) es una extensión de GNU grep. En este curso aprendes las expresiones regulares básicas (^ $ . * []), grep -E para habilitar las regex extendidas y grep -o para imprimir solo la coincidencia. Funcionan igual en cualquier Linux.

echo -e 'cat\ndog\nfox' > animals.txt   # crear material
grep -E 'cat|dog' animals.txt              # las 2 líneas cat o dog
echo -e 'ac\nabc\nabbc' > plus.txt      # crear material
grep -E 'ab+c' plus.txt                    # abc abbc, con uno o más b
echo -e 'cat cat dog' > line.txt         # crear material
grep -o cat line.txt                       # imprime cada cat coincidente en su propia línea

① Crea un archivo material con echo -e 'cat\ndog\nfox' > animals.txt.

② Añade a grep la opción que habilita las regex extendidas y muestra las líneas que contienen cat o dog.

③ Crea material con echo -e 'ac\nabc\nabbc' > plus.txt y, con la regex extendida grep -E 'ab+c', muestra las líneas con uno o más b.

④ Crea material con varias palabras en una línea con echo -e 'cat cat dog' > line.txt.

⑤ Añade a grep la opción que imprime solo la coincidencia, busca cat y confirma que cada palabra coincidente sale en su propia línea.

Filtrar la salida de un comando — | grep

grep puede buscar no solo en un archivo pasado como argumento, sino también en la salida de otro comando pasada a través de un pipe |.

Canaliza el resultado de ls o cat a | grep para acotarlo solo a las líneas que necesitas.

ls cmds | grep '^c' muestra solo los nombres que empiezan con c del listado del directorio cmds, y cat archivo | grep palabra filtra el contenido de un archivo de la misma forma.

mkdir -p cmds                                # pequeño directorio material
touch cmds/cat cmds/cut cmds/sort            # preparar 3 nombres
ls cmds | grep '^c'                          # cat y cut, que empiezan con c
echo -e 'apple\nbanana\ncherry' > fruit.txt   # crear material
cat fruit.txt | grep an                      # solo banana, que contiene an

① Prepara un pequeño directorio material con mkdir -p cmds y touch cmds/cat cmds/cut cmds/sort.

② Canaliza la salida de ls cmds a grep con | y muestra solo los nombres que empiezan con c.

③ Crea material de 3 líneas con echo -e 'apple\nbanana\ncherry' > fruit.txt, luego canaliza la salida de cat fruit.txt a | grep y muestra solo las líneas que contienen an.