Coincidencia de Expresiones Regulares en Bash

Introducción

Este tutorial te introduce a las expresiones regulares (regex) en Bash. Las expresiones regulares son una herramienta poderosa para encontrar patrones dentro de textos. Al aprender regex, mejorarás en gran medida tus habilidades de scripting en la shell, lo que te permitirá procesar textos, extraer datos y automatizar tareas de manera más efectiva. Este tutorial está diseñado para principiantes, por lo que no se requiere experiencia previa con regex. Comenzaremos con los conceptos básicos y gradualmente aumentaremos tu conocimiento.

Comprender las Expresiones Regulares Básicas y la Coincidencia

Comencemos con los conceptos fundamentales de las expresiones regulares. Una expresión regular es una secuencia de caracteres que define un patrón de búsqueda. Piénsalo como una forma muy poderosa de buscar texto.

Aquí están los bloques de construcción básicos:

• Caracteres Literales: La mayoría de los caracteres simplemente coinciden consigo mismos. Por ejemplo, la expresión regular abc coincidirá exactamente con la cadena "abc".
• Metacaracteres: Estos son caracteres especiales que tienen un significado específico en las expresiones regulares. Veamos algunos de los más importantes:
  • . (punto): Coincide con cualquier carácter individual (excepto una nueva línea). Entonces, a.c coincidiría con "abc", "axc", "a1c", etc.
  • * (asterisco): Coincide con el carácter precedente cero o más veces. ab*c coincidiría con "ac", "abc", "abbc", "abbbc", etc.
  • ^ (circunflejo): Coincide con el inicio de una línea. ^hello coincidiría con una línea que comience con "hello".
  • $ (signo de dólar): Coincide con el final de una línea. world$ coincidiría con una línea que termine con "world".
  • [] (corchetes cuadrados): Define una clase de caracteres. Coincide con cualquiera de los caracteres dentro de los corchetes. [abc] coincidiría con "a", "b" o "c". [0-9] coincide con cualquier dígito individual.

Ahora, creemos un script de Bash para probar nuestro conocimiento. Crea un archivo llamado regex_test.sh usando el comando touch:

cd ~/project
touch regex_test.sh

A continuación, abre regex_test.sh con un editor de texto (como nano o vim) y agrega el siguiente código:

#!/bin/bash

string="Hello World"
if [[ "$string" =~ ^Hello ]]; then
  echo "The string starts with Hello"
else
  echo "The string does not start with Hello"
fi

Guarda el archivo y dale permisos de ejecución:

chmod +x regex_test.sh

Finalmente, ejecuta el script:

./regex_test.sh

La salida debe indicar que la cadena comienza con "Hello".

Trabajar con Conjuntos de Caracteres en un Script

Los conjuntos de caracteres, definidos utilizando corchetes cuadrados [], te permiten coincidir con un carácter de un grupo específico. Esto es muy útil para crear patrones más flexibles.

• Rangos de Caracteres: Dentro de [], puedes usar un guión (-) para especificar un rango. [a-z] coincide con cualquier letra minúscula, [A-Z] coincide con cualquier letra mayúscula y [0-9] coincide con cualquier dígito. Puedes combinarlos: [a-zA-Z0-9] coincide con cualquier carácter alfanumérico.
• Negación: Si colocas un ^ como el primer carácter dentro de [], niega la clase. [^0-9] coincide con cualquier carácter que no sea un dígito.

Modifiquemos nuestro script regex_test.sh para usar conjuntos de caracteres. Abre regex_test.sh con un editor de texto y reemplaza su contenido con lo siguiente:

#!/bin/bash

string="cat"
if [[ "$string" =~ c[a-z]t ]]; then
  echo "Match found!"
else
  echo "No match."
fi

Guarda el archivo y ejecútalo:

./regex_test.sh

La salida debe indicar "Match found!". Esto se debe a que c[a-z]t coincide con cualquier cadena de tres letras que comience con 'c' y termine con 't', donde el carácter del medio es una letra minúscula.

Usar Cuantificadores para Repetir Patrones en un Script

Los cuantificadores controlan cuántas veces se debe repetir un carácter o grupo. Esto le agrega un poder significativo a tus patrones de expresiones regulares.

• + (más): Coincide con el carácter precedente una o más veces. ab+c coincide con "abc", "abbc", "abbbc", etc., pero no con "ac".
• ? (signo de interrogación): Coincide con el carácter precedente cero o una vez (es decir, hace que el carácter precedente sea opcional). ab?c coincide con "ac" y "abc", pero no con "abbc".
• * (asterisco): Coincide con el carácter precedente cero o más veces. Vimos esto anteriormente.
• {n}: Coincide con el carácter precedente exactamente n veces. a{3} coincide con "aaa".
• {n,}: Coincide con el carácter precedente n o más veces. a{2,} coincide con "aa", "aaa", "aaaa", etc.
• {n,m}: Coincide con el carácter precedente entre n y m veces (incluyendo n y m). a{1,3} coincide con "a", "aa" o "aaa".

Modifiquemos nuestro script regex_test.sh para usar cuantificadores. Abre regex_test.sh con un editor de texto y reemplaza su contenido con lo siguiente:

#!/bin/bash

string="abbbc"
if [[ "$string" =~ ab+c ]]; then
  echo "Match found!"
else
  echo "No match."
fi

Guarda el archivo y ejecútalo:

./regex_test.sh

La salida debe indicar "Match found!". Esto se debe a que ab+c coincide con una cadena que comienza con 'a', seguida de una o más 'b' y termina con 'c'.

Extraer Datos con Grupos de Captura en un Script

Los paréntesis () se utilizan para agrupar partes de una expresión regular. Esto es útil para aplicar cuantificadores a múltiples caracteres y para capturar el texto coincidente.

Cuando se usan paréntesis, Bash almacena el texto coincidente por esa parte de la expresión regular en una matriz especial llamada BASH_REMATCH. BASH_REMATCH[0] contiene la cadena coincidente completa, BASH_REMATCH[1] contiene el texto coincidente por el primer grupo, BASH_REMATCH[2] el segundo, y así sucesivamente.

Modifiquemos nuestro script regex_test.sh para extraer datos utilizando grupos de captura. Abre regex_test.sh con un editor de texto y reemplaza su contenido con lo siguiente:

#!/bin/bash

string="apple123"
if [[ "$string" =~ ^([a-z]+)([0-9]+)$ ]]; then
  fruit="${BASH_REMATCH[1]}"
  number="${BASH_REMATCH[2]}"
  echo "Fruit: $fruit"
else
  echo "No match."
fi

Guarda el archivo y ejecútalo:

./regex_test.sh

La salida debe incluir "Fruit: apple". Este script extrae el nombre de la fruta de la cadena utilizando grupos de captura.

Reemplazar Texto con sed en un Script

Creemos un nuevo script llamado sed_test.sh para practicar el uso de sed.

cd ~/project
touch sed_test.sh
chmod +x sed_test.sh

Abre sed_test.sh con un editor de texto y agrega lo siguiente:

#!/bin/bash

string="apple123"
echo "$string" | sed 's/[0-9]/X/g'

Guarda el archivo y ejecútalo:

./sed_test.sh

La salida debe ser: appleXXX. Este script utiliza sed para reemplazar todos los dígitos en la cadena con la letra "X".

Resumen

Este tutorial te ha introducido a las expresiones regulares (regex) en Bash. Has aprendido sobre conceptos básicos de regex, clases de caracteres, cuantificadores, agrupación, captura y cómo usar regex con sed. Al escribir y ejecutar scripts de Bash, has adquirido experiencia práctica con estas herramientas poderosas. Recuerda practicar y experimentar con diferentes patrones de regex para consolidar tu comprensión.