Expresiones regulares

Introducción a las expresiones regulares

¿Qué son las Expresiones Regulares?

Expresiones Regulares (Regular Expression) o simplemente conocidas como REGEX son cadenas de caracteres que forman patrones de búsqueda o de sustitución. El uso de REGEX está ampliamente difundido debido a su ventajas para el manejo de cadenas en lenguajes como Java, Javascript, C++11, python y PERL, por mencionar algunos. Sin embargo, PERL es el lenguaje de referencia para expresiones regulares ya que integra un potente motor dentro de su sintaxis y ha ayudado a la evolución de las expresiones regulares.

Algunos de los usos más comunes para REGEX son:

• Extracción de información en archivos, como: código fuente, logs, archivos de configuración, hojas de cálculo, documentos, etc.
• Búsqueda de patrones.
• Validación de cadenas.
• Sustitución de patrones y cadenas.

En sistemas operativos UNIX/Linux, las expresiones regulares se volvieron populares gracias a sed y grep sin mencionar el lenguaje de programación PERL.

Como un dato curioso el principio lógico de las expresiones regulares se basa en las máquinas de estado finito (autómatas de estado finito), a continuación veremos el uso de grep, sed y awk.

Uso de grep

GREP

El uso de la instrucción grep es una de las herramientas más importantes dentro de cualquier distribución de GNU/Linux y que también es posible encontrar en sistemas operativos tipo BSD, OSX, Unix. Grep nos permite obtener de forma rápida información contenida en logs, archivos, documentos, flujos de salida de instrucciones mediante patrones de búsqueda, mejor conocidos como regex, que permiten el filtrado y depuración de la información.

La estructura básica de la instrucción grep es:

grep [banderas] 'patrón' archivo...

A continuación se presenta una referencia rápida a gran parte de los caracteres, sintaxis, comodines (wildcards) más empleados con grep.

Metacaracter	Nombre	Explicación
Elementos para coincidir con un simple caracter
.	Punto	Cualquier carácter.
[…]	Clase de caracteres	Cualquier carácter listado en los corchetes.
[^…]	Caracter de negación	Cualquier carácter NO listado en los corchetes.
\char	Caracter de escape	El carácter después de la diagonal literalmente será empleado.
Elementos que coinciden con una posición
^	Acento circunflejo	Comienzo de la línea / negación.
$	Signo de pesos/dólares	Final de la línea.
\<	Menor que	Inicio de una palabra.
\>	Mayor que	Final de una palabra.
Cualificadores
?	Interrogación	Opcional, considerado un cualificador
*	Asterisco	Cualquier número de veces, incluyendo cero.
+	Suma	Una o más veces la expresión precedente.
{N}	Coincidencias exactas	Coincidencia exáctamente N veces.
{N, }	Coincide al menos	Coincide al menos N veces.
{min, max}	Rango especificado	Coincidencias entre un mínimo y un máximo.
Otros
|	Alternancia / pipe	Coincide para cualquier expresión dada.
–	Guión	Indica un rango.
\1, \2, …	Referencia inversa	Sustituye con el texto previo que coincide dentro de los paréntesis (ej. el primer conjunto, segundo conjunto, etc).
\b	Delimitador de palabra	Conjunto de caracteres que comúnmente indica el fin de una palabra ().
\B	Diagonal invertida	Alternativa al uso de “\\” para coincidencia de cualquier carácter de palabra (ej. cualquier letra, número, guión bajo).
\w	Caracter de palabra	Empleado para la coincidencia de cualquier carácter de palabra como letras, números, guión bajo.
\W	Caracter de no palabra	Busca coindicencias de cualquier carácter que no sea empleado en palabras.
\`	Inicio del búfer	Inicio de las coincidencias de un búfer enviado a grep.
\’	Fin del búfer	Fin de las coincidencias de un búfer enviado a grep.

Ejemplos usando el archivo /proc/cpuinfo:

Buscará todas las líneas que contengan la palabra “Intel”

grep 'Intel' /proc/cpuinfo

Contará todas las palabras “yes”

grep -wc 'yes' /proc/cpuinfo

Mostrará en pantalla todas las líneas que comiencen con las vocales en minúsculas

$grep '^[aeiou]' /proc/cpuinfo

Busca todas las líneas que tengan la secuencia de caracteres Hz, esperando cualquier caracter previo (.)

grep '.Hz' /proc/cpuinfo

Busca todas las líneas que terminen en algún número dado en el intervalo de 0 a 3

grep '[0-3]$' /proc/cpuinfo

Video: Ejemplo de grep

Para el siguiente ejemplo del uso básico de las expresiones regulares y grep, se recomienda el uso de libro de dominio público de “Alicia en el país de las maravillas” de Lewis Carroll que puede ser obtenido libremente por medio del proyecto Gunteberg.

Descarga el libro

 

 

Uso de sed Mover página: Uso de sed

SED

sed es el acrónimo en inglés para Stream EDitor el cuál es una herramienta que nos permite modificar el contenido de las diferentes líneas de un archivo en base a una serie de instrucciones o un archivo de instrucciones.

La estructura básica de la instrucción sed es:

sed [banderas] '/patrón/' archivo...

Entre las diversas cosas que se pueden hacer con sed, está al sustitución con el comandos como ‘s/REGEX/Reemplazo/banderas’.

Con la siguiente línea se hará la sustitución de day por night en la palabra Sunday.

echo Sunday | sed 's/day/night/'

Para poder comprender las siguientes instrucciones sobre el uso de sed, suponga que tenemos un archivo con el siguiente contenido:

one two three, one two three
four three two one
one hundred

al ejecutar la siguiente instrucción, con el contenido previamente mencionado.

sed 's/one/ONE/' < file

Su salida deberá ser algo así

ONE two three, one two three
four three two ONE
ONE hundred

Note que al imprimir el contenido de file éste no presenta cambios, para efectuarlos sobre el mismo archivo sólo tendría que agregar la bandera de -i.

El caracter seguido de s es el delimitador de los campos por ejemplo:

Cuando el delimitador es / y se requiere escapar / debido a que se emplea en el texto con el que se hará match.

echo "/usr/loca/bin" | sed 's/\/usr\/local\/bin/\/common\/bin/' /common/bin

El delimitador en esta ocasión son los dos puntos :

echo "/usr/local/bin" | sed 's:/usr/local/bin:/common/bin:' /common/bin

Empleando el signo de exclamación de cierre !

echo "/usr/local/bin" | sed 's!/usr/local/bin!/common/bin!' /common/bin

Empleo del signo de ampersand & como coincidencia de cadenas.

Suponga que quiere colocar entre paréntesis las letras abc, una forma de hacerlo es de la siguiente manera:

echo "abcdefghijkl" | sed 's/abc/(abc)/' (abc)defghijkl

Sin embargo sed nos ofrece el caracter especial de & (en caso de que sea parte de la cadena a reemplazar o a buscar es necesario escaparlo) que nos permite sustituir a nuestra cadena de búsqueda sin importar lo larga que sea, ejemplo:

echo "abcdefghijkl" | sed 's/abc/(&)/' (abc)defghijkl

Ahora bien, también podemos repetir el patrón

echo "abcdefghijkl" | sed 's/abc/& (&) &/' abc (abc) abcdefghijkl

Como se puede notar el ampersand nos permite sustituir nuestra cadena de búsqueda en la salida

/g como reemplazo global

En la mayoría de los sistemas basados en UNIX, sed va leyendo linea y a la primera ocurrencia cambia el patrón de búsqueda por la cadena de reemplazo mas no continua haciendo cambios si es que el patrón se repite en múltiples ocasiones en la línea, (vea el ejemplo del fichero file, en donde en la primera línea se cuenta dos veces con la palabra one y solamente la primera es modificada). Para solventar ese problema sólo bastará con agregar al final del patrón la letra g, como se muestra a continuación:

sed 's/one/ONE/g' < file ONE two three, ONE two three four three two ONE ONE hundred

sed también permite el uso de expresiones regulares, de la misma forma en que se han trabajado previamente con ellas en esta lección.

Para consultar un detallado más amplio sobre el uso de sed puede consultar el manual de sed con la siguiente instrucción que además cuenta con varios ejemplos sobre su uso.

info sed

Video: Ejemplo del uso de sed

A continuación se mostrará el uso de la instrucción sed, para ello se recomienda descargar el archivo adjunto a esta página.

Descarga el archivo aquí.

 

Uso de AWK

AWK

AWK un programa de asociación de patrones para el procesamiento de archivos, tiene un gran potencial ya que permite el manejo de expresiones regulares así como de modificar la salida para agilizar la lectura o el formato de los campos obtenidos.

Existen tres versiones de awk

• awk: originalmente desarrollado por AT&T.
• nawk: new-awk desarollado como una mejora del propio AT&T.
• gawk: la versión GNU de awk, desarrollado por The Free Software Foundation.

Algo bastante interesante es que awk en los sistemas modernos GNU/Linux es una liga suave hacia gawk. Pruebe haciendo un:

ls -lha /usr/bin/awk

su salida debe ser algo semejante a:

/usr/bin/awk -> /etc/alternatives/awk

y si hicieramos un:

ls -lha /etc/alternatives/awk

su salida es una liga suave a gawk:

/etc/alternatives/awk -> /usr/bin/gawk

Así que al emplear awk en realidad estaremos empleado gawk.

La estructura básica de awk es:

awk [banderas] 'patrón' archivo...

Dos importantes patrones son los especificados por las palabras en inglés “BEGIN” y “END”. Como indican, estas dos palabras especifican acciones que tomarán lugar antes de leer y después de la última línea del archivo a procesar.

BEGIN { print "START" }
{ print }
END { print "STOP" }

Las columnas de los campos separados por los delimitadores se enumeran del 1 a N (se puede hacer una desreferencia si se coloca el signo de $ al inicio del número, recordemos que son variables), según el delimitador que se emplea, el delimitador por defecto es el espacio y no es necesario especificarlo, en caso de que se quiera cambiar el delimitador puede emplearse la bandera -F seguido del delimitador, ejemplo:

El delimitador serán los dos puntos (:) -F’:’

El delimitador será la coma -F’,’

O múltiples delimitadores haciendo uso de corchetes como se muestra a continuación: -F'[/=]’

A continuación se listan las variables más empleadas en awk:

Variable	Nombre	Explicación
$FS	Separador de campos	Indica el carácter de separación de campos. Por omisión es un espacio. Se puede indicar un carácter alternativo mediante una instrucción de asignación como FS = “/”. Si se deja vacío, cada lectura se realiza dejando un carácter en cada campo.
$NF	Número de campos	Número total de campos que contiene el registro separados por espacios.
$RS	Separador de registro	Contiene el carácter que indica a awk en qué punto del archivo acaba un registro y empieza el siguiente. Es “\n” por omisión.
$NR	Número de registros	Número del registro que se está procesando.
$OFS	Salida OFS	Separador de campos para la salida generada por awk. La instrucción print inserta en la salida un carácter de separación cada vez que aparece una coma en el código.

 

Algunos ejemplos de uso de awk:

Imprime la columna 1 del archivo /etc/passwd separado por :

awk -F: '{ print $1 }' /etc/passwd

Imprime antes de procesar el archivo “Archivo: /etc/passwd”, procesa los registros del archivo y termina con un “- DONE -”

awk -F: 'BEGIN {print "File: /etc/passwd"} {print $1} END {print "- DONE -"}' /etc/passwd

Imprime los usuarios, que en su UID (User ID, Identificador de usuario) sea mayor a 500 en la tercera columna donde el delimitador son dos puntos (:), imprimirá el nombre del usuario, su UID y el shell por defecto para dicho usuario, posteriormente su salida será ordenada en forma inversa. Toma como documento a procesar el /etc/passwd.

awk 'BEGIN { print "Usuario UID Shell\n------------ ---- ----------" } $3 >= 500 \ { printf "%-12s %4d %-10s\n", $1, $3, $7 | "sort -r"}' FS=":" /etc/passwd

Obtiene la carga de trabajo de la computadora en donde el separador por defecto es el espacio al no especificarse, y del último registro (NF) se obtienen los 3 últimos por medio de una desreferencia de NF, dando los tiempos de carga de hace 1 min, 5 min y 15 min.

uptime | awk '{print $(NF - 2), $(NF - 1), $NF}'

Video: Ejemplo del uso de AWK

Uso de TR

TR

TR proviene de TRanslate, es una de las instrucciones de GNU/Linux que nos permiten la sustitución, a completado y eliminación de letras en un texto, ya sea un archivo o por el uso de tuberías y redireccionamiento.

Su estructura es muy sencilla se puede sintetizar de la siguiente manera:

tr [opciones] grupo1 [grupo2]

En donde las opciones puede ir o no las siguientes banderas.

Opción	Acción
-c, -C, – complement	Usa el complento para el grupo1
-d, –delete	Borra los caracteres en el grupo1, no hace ninguna traducción
-s, –squeeze-repeats	Reemplazar cada secuencia de entrada de un carácter repetido que aparece en el grupo1 con una sola aparición de ese personaje
-t, –truncate-set1	Trunca el grupo 1 a la longitud del grupo2

 

En el caso de los grupos, tanto puede ser expresiones regulares como patrones de búsqueda GNU.

Opción GNU	Descripción
[:alnum:]	Todas las letras y números
[:alpha:]	Todas las letras
[:blank:]	Todos los espacios en blanco horizontales
[:cntrl:]	Todos los caracteres de control
[:digit:]	Todos los dígitos
[:graph:]	Todos los caracteres imprimibles, no incluye el espacio
[:lower:]	Todas las letras minúsculas
[:print:]	Todos los caracteres imprimibles, incluye el espacio
[:punct:]	Todos los signos de puntuación
[:space:]	Todos los espacios horizontales y verticales
[:upper:]	Todas las letras mayúsculas
[:xdigit:]	Todos los dígitos en hexadecimal

 

Para el uso de escape de caracteres

Escape de caracteres	Descripción
\\	Barra invertida
\b	Retroceso
\n	Nueva línea
\r	Regreso
\t	Tabulador horizontal

 

Ejemplos de uso de tr:

Convierte la cadena “Linux Para Todos” de minúsculas a mayúsculas.

echo "Linux Para Todos" | tr [:lower:] [:upper:]

Convierte la cadena hola de minúsculas a mayúsculas, haciendo uso de tanto de las opciones GNU como de expresiones regulares.

echo "hola" | tr [:lower:] 'A-Z'

Convierte la cadena “texto simple” de minúsculas a Mayúsculas solo en el intervalo de la “A” a la “Z” y de “a” a la “j”

echo "texto simple" | tr [:lower:] 'A-j'

Sustituye todas las letras en el intervalo de la “a” a la “j” en minúsculas por equivalente en mayúsculas

tr 'a-j' 'A-J' <> texto_prueba.txt

Sustituye todas las vocales en minúsculas por mayúsculas

tr 'aeiou' 'AEIOU' <> texto_prueba.txt

Elimina todas las vocales en minúsculas

tr -d 'aeiou' <> texto_prueba.txt

Todos los caracteres no contenidos en el primer grupo serán sustituidos por ? (segundo grupo)

tr -c '[a-z][A-Z][0-9]\ ' ? <> texto_prueba.txt