LPIC-1 Tema 103.7: buscar texto con expresiones regulares

Con el Tema 103.7 de LPIC-1 se intenta evaluar a los candidatos para determinar su manejo para manipular y buscar texto en archivos usando expresiones regulares. Para ello, tendrás que ser capaz de crear simples expresiones regulares, entender las diferencias entre expresiones regulares básicas y extendidas, comprender los conceptos de caracteres especiales, clases, cuantificadores y anclas.

Además, tendrás que saber cómo usar algunas herramientas útiles en combinación con las expresiones regulares que permitirán hacer búsquedas a través de los sistemas de archivos y dentro de los propios archivos, y cómo usar expresiones regulares para eliminar, cambiar y sustituir texto.

Expresiones regulares / regex

Una expresión regular es una serie de caracteres especiales que permiten describir un texto. Por ejemplo, cuando usamos grep para filtrar, la palabra o patrón que le sigue será una expresión regular. Por ejemplo grep linux para buscar la palabra «linux». En ese caso es fácil, ya que es una simple palabra. Pero la cosa se complica cuando se necesita buscar cosas más específicas o sustituirlas, etc.

Son complejas, practica mucho con ellas y mira cuantos más ejemplos mejor.

No debes confundir las expresiones regulares con los patrones de ficheros, aunque usen algunos caracteres comunes. Por ejemplo, el patrón *.* se puede corresponder a la expresión regular ^.*\..*$. Además, también deberás saber distinguir entre los tipos de expresiones regulares que existen. No todos los programas usan las mismas, aunque existen algunos tipos más o menos estandarizados y recogidos dentro de POSIX que son las usadas en Linux y que se dividen en:

  • Básicas: el motor BRE (Basic Regular Expressions), que usan muchos de los programas de Linux, como grep, egrep, fgrep, etc. Otros, como sed, solo pueden entender algunas BRE. Son las clásicas en Unix, aunque se consideran obsoletas en POSIX. Estas expresiones básicas se componen por los metacaracteres:
    • . para cualquier caracter
    • [ ] cualquiera de los caracteres entre corchetes, como [a-z] para minísculas, [A-Z] para mayúsculas, números [0-9], etc.
    • [^ ] cualquier carácter que no esté entre los corchetes, es decir, es una especie de negación de lo anterior.
    • ^ para especificar al principio de una línea, por ejemplo ^abc son las líneas que empiecen por abc.
    • $ indica el final de línea
    • * 0 o más ocurrencias de la expresión regular anterior.
    • \ escapa un metacarácter. Por ejemplo ^#.*\.$ o lineas que empiecen por # y terminen por $.
    • \( \) permite agrupar ER, por ejemplo 0\ (abc\)*0 sería la línea que tengan 0 seguido de 0 o más ocurrencias de abc y seguido de otro 0. La \ delante de los caracteres del paréntesis es porque se deben escapar.
  • Extendidas: el motor ERE (Extended Regular Expressions), son las usadas en algunos lenguajes de programación y contienen más patrones como la comparación de dígitos y palabras. Herramientas como awk usan ERE. Por ejemplo:
    • + para una o más ocurrencias. Por ejemplo ab+c concuerda con abc, abbc, pero no con ac.
    • ? para cero o  una ocurrencias. Por ejemplo, ab?c concuerda con ac, abc, pero no con abbc.
    • | para alternar entre 2 o más expresiones regulares. Por ejemplo con (a|b)c concuerda ac o bc.
    • [:space:] para caracteres en blanco.
    • [:upper:] para mayúsculas.
    • [:lower:] para minúscuclas.
    • [:digit:] para dígitos.
    • [:alpha:] para caracteres alfabéticos.
    • [:alnum:] para alfanuméricos.
    • etc.
#Consulta más en 
man 7 regex

También existen otras expresiones regulares al estilo Perl, o las usadas en vim, Emacs, otros lenguajes de programación etc. Pero ahora solo me interesan las anteriores.

Herramientas básicas

Las herramientas más básicas para trabajar con estas expresiones regulares son…

grep

Con grep se pueden buscar coincidencias en archivos o en las entradas y salidas extándar de Linux. Tan solo necesitas especificar el patrón con el que debe coincidir o usar expresiones regulares.

#Algo básico sería buscar en la salida del concatenador  las palabras printf
cat hola.c | grep printf

#O también
ps aux | grep firefox

#Buscar un patrón password en contraseñas.txt
grep password contraseñas.txt

#Buscar el patrón linux en todos los ficheros y extensiones y escribir los resultados en resultados.txt
grep linux *.* > resultados.txt


#Si quieres que la búsqueda no sea sensible a mayúsculas y minúsculas, por lo que buscará Prueba, PRUEBA, prueba, pRueba, etc. 
grep -i prueba ejemplo.txt

#Búsqueda recursiva en subdirectorios
grep -r test /home

#Mostrar el número de línea donde coinciden
grep -n test pruebas.txt

#Buscar líneas que comienzan por #
grep ^# limits.conf

#O las que terminen por Error
grep Error $ sys.log

#Mostrar todas las líneas menos las que coinciden con el patrón
grep -v ALERT code

#Buscar líneas que solo tienen un único carácter
grep '^.$' hola.s

#Buscar las que tienen solo un punto
grep '^\.$' hola.s

#Las que tengan al menos una letra mayúscula o minúscula
grep '[a-zA-Z]' inicio.html

#Líneas donde txt se encuentre precedido de un carácter
grep -w '.txt' listado.txt

#Buscar desde la stdout de dmesg todo lo que contenga caracteres alafanuméricos
dmesg | grep sd[a-z][0-9]




egrep

Será como grep usado con -E, también para buscar coincidencias y usando expresiones regulares. Es decir, la opción -E es la que permite usar expresiones regulares extendidas.

#Por ejemplo, imagina que quieres buscar en un archivo network.txt si contiene dos IPs concretas
egrep '(192.168.1.1|192.168.1.2)' network.txt

#O también podrías usar []
egrep 192.168.1.[1,2] network.txt

#Para rangos puedes usar
egrep 192.168.1.[0-255] network.txt

#Imagina que quieres una IP cuyo último campo empiece por 1,2 o 3 y el último número sea 8 o 9
egrep 192.168.1.[1-3][8-9] network.txt

#También podrías solo buscar líneas que contengan mayúsculas
egrep [[:upper:]] network.txt

#O todas las líneas que empicen por hostname
egrep ^hostname network.txt

fgrep

Es como usar grep con la opción -F, es decir, para mostrar líneas que coincidan con un determinado patrón. La diferencia entre fgrep y grep/egrep es que interpretará el patrón como una lista de cadenas fijas, en vez de expresiones regulares, separadas por nuevas líneas. Por ejemplo:

#Imagina que quieres usar las palabras de diccionario.txt para buscar las coincidencias de toda la lista de palabras que contenga dentro de otro archivo llamado prueba.txt
fgrep diccionario.txt prueba.txt

sed

Es un potente editor de texto para filtrar y transformar cadenas. Se maneja gracias a las expresiones regulares. Por ejemplo:

#Eliminar espacios en blanco al principio y al final de cada línea y sustituir sustituir si existen varios espacios en blanco intermedios por uno solo
$ sed -r "s/^_+// ; s/_+$// ; s/__+/_/g" mifichero

# Pon los 4 primeros caracteres de cada línea al final de la misma
$ sed -r 's/^(.{4,4})(.*)/\2\1/' mifichero

# Cambia de minúsculas a mayúsculas la primera letra de cada palabra
$ sed -r 's/\<./\u&/g'

# Convierte DOS newlines (CR/LF) a formato Unix (LF). Usa uno de estos: 
$ sed 's/^M$//'4
$ sed 's/\r//'

#También puedes usarlo directamente para manipular stdin, sustituyendo este por mi
echo "Bienvenido a este tutorial de LPIC" | sed 's/este/mi/'

#Más en
man sed

Isaac

Apasionado de la computación y la tecnología en general. Siempre intentando desaprender para apreHender.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

A %d blogueros les gusta esto:

Si continuas utilizando este sitio aceptas el uso de cookies. más información

Los ajustes de cookies de esta web están configurados para "permitir cookies" y así ofrecerte la mejor experiencia de navegación posible. Si sigues utilizando esta web sin cambiar tus ajustes de cookies o haces clic en "Aceptar" estarás dando tu consentimiento a esto.

Cerrar