Esta página puede ser redistribuida libremente bajo los términos de la licencia GPL. Vease ( GPL texto original ) o si lo prefiere (Traducción española no oficial de la GPL) Al margen de las obligaciones legales que se derivan del uso de esta licencia rogamos sea respetada la referencia a su lugar de publicación original www.ciberdroide.com. y a su autor original Antonio Castro Snurmacher (Madrid 01/01/2000).

Ausencia de Garantía

Esta ausencia de garantía se hace extensa a cualquier tipo de uso de este material y muy especialmente a las prácticas, ejercicios, y de ejemplos que encuentre en estas páginas. Deberá trabajar siempre salvo indicación contraria con un SO Linux y con un usario distinto de 'root' sin privilegios especiales. Como directorio de trabajo se procurará usar el directorio '/tmp' o algún otro que no contenga información valiosa. Tampoco se considera buena idea practicar en una máquina que contenga información valiosa.

Todo esto son recomendaciones de prudencia. En cualquier caso si algo sale mal toda la responsabilidad será únicamente suya. En ningún caso podrá reclamar a nadie por daños y perjuicios derivados del uso de este material. Para más información lea el contenido de la licencia GPL y abstengase de hacer prácticas si no está dispuesto a asumir toda la responsabilidad.

EXPRESIONES REGULARES

Introducción
Vamos a explicar las expresiones regulares porque se utilizan a menudo desde una gran variedad de aplicaciones en los SO tipo Unix como Linux. Permiten reconocer una serie de cadenas de caracteres que obedecen a cierto patrón que llamamos expresión regular. Por ejemplo si deseamos buscar lineas que contenga las palabras 'hola' o 'adiós' en los ficheros del directorio actual haremos: 

$ egrep 'hola|adiós' *

No todos los comandos usan de forma idéntica las expresiones regulares. Algunos de los comandos que usan expresiones regulares son 'grep', 'egrep', 'sed', 'vi', y 'lex'. Este último en linux se llama 'flex' y es un analizador sintáctico muy potente pero no lo explicaremos porque para usarlo hay que saber lenguaje 'C'. Actualmente algunos lenguajes modernos como el 'perl' incluyen capacidad de manejar expresiones regulares lo cual les da una gran potencia y para lenguajes más antiguos como el 'C' existen librerías para poder usar expresiones regulares. En resumen las expresiones regulares están sinedo incorporadas en distintos sitios y ya no están limitadas a su uso en SO tipo Unix. Cada comando o aplicación implementa la expresiones regulares a su manera aunque en general son todas bastantes parecidas. Por ejemplo 'grep' permite usar expresiones regulares sencillas mientras que 'egrep' es capaz de usar expresiones regulares más complejas. Otros comandos adaptan el uso de expresiones a sus particulares necesidades y por ello si bien se puede hablar en general de ellas hay que tener en cuenta las peculiaridades de cada caso que deberán ser consultadas en las paginas del manual de cada comando. Las expresiones regulares vienen a ser una especie de lenguaje y cada comando usa su propio dialecto. En realidad las diferencias entre los distintos dialectos suelen ser muy pocas. Por ejemplo si un comando usa los paréntesis y además admite el uso de expresiones regulares extendidas se establecerá una forma de distinguir si los paréntesis deben ser interpretados como patrón de la expresión regular o como otra cosa. Para ello se suele usar los paréntesis precedidos del carácter escape '\'. Vamos a tomar a 'egrep' y 'sed' como comandos para aprender expresiones regulares porque este curso tiene un enfoque práctico. Usaremos el comando 'egrep' con distintos patrones y veremos cuando cumple y cuando no cumple y de esa forma se entenderá perfectamente.

Operadores usados en expresiones regulares.

* El elemento precedente debe aparecer 0 o más veces.
+ El elemento precedente debe aparecer 1 o más veces.
. Un carácter cualquiera excepto salto de linea.
? Operador unario. El elemento precedente es opcional
| O uno u otro.
^ Comienzo de linea
$ Fin de linea
[...] Conjunto de caracteres admitidos.
[^...] Conjunto de caracteres no admitidos.
- Operador de rango
(...) Agrupación.
\ Escape
\n Representación del carácter fin de linea.
\t Representación del carácter de tabulación.

Esta lista no es completa pero con esto es suficiente para hacer casi todo lo que normalmente se hace con expresiones regulares.

Ejemplos para cada operador con 'egrep'
Empezaremos usando un ejemplo lo más sencillo posible para ilustrar cada uno de estos operadores

Ejemplo para el operador '*' con el patrón 'ab*c'
Este patrón localizará las cadenas de caracteres que
empiecen por 'a', que continúen con 0 o más 'b', y
que sigan con una 'c'.

La 4 falla porque la 'a' y la 'c' no van seguidas ni
existen caracteres 'b' entre ambas. La 5 falla por no
tener una sola 'c'. y la 6 tiene los caracteres adecuados
pero no en el orden correcto. 

$ egrep 'ab*c' <<FIN
< 1 ac
< 2 aac
< 3 abbbc
< 4 axc
< 5 aaab
< 6 cba
< 7 aacaa
< FIN

1 ac
2 aac
3 abbbc
7 aacaa

Ejemplo para el operador '+' con el patrón 'ab+c'
Este patrón localizará las cadenas de caracteres que
empiecen por 'a', que continúen con 1 o más 'b', y
que sigan con una 'c'.

Solo la línea 3 cumple la expresión regular. 

$ egrep 'ab*c' <<FIN
< 1 ac
< 2 aac
< 3 abbbc
< 4 axc
< 5 aaab
< 6 cba
< 7 aacaa
< FIN

3 abbbc

Ejemplo para el operador '.' con el patrón 'a..c'
Este patrón localizará las cadenas de caracteres que
empiecen por 'a', que continúen con dos caracteres
cualesquiera distintos de salto de línea y que sigan
con una 'c'. 

$ egrep 'a..c' <<FIN
< a00c
< axxcxx
< aacc
< abc
< ac
< axxxc
< FIN

a00c
axxcxx
aacc

Ejemplo para el operador '?' con el patrón 'ab?cd'
Este patrón localizará las cadenas de caracteres que
empiecen por 'a', y que opcionalmente continúen con
una 'b' y que continúe con los caracteres 'cd'.
 

$ egrep 'ab?cd' <<FIN
< abcd
< acd
< cd
< abbcd
< FIN

abcd
acd

Ejemplo para el operador '|' con el patrón 'ab|cd'
Este patrón localizará las cadenas de caracteres que
contengan 'ab', 'cd', o '123'
 

$ egrep 'ab|cd|123' <<FIN
< xxxabzzz
< xxxcdkkk
< badc
< dbca
< x123z
< FIN

xxxabzzz
xxxcdkkk
x123z

Ejemplo para el operador '^' con el patrón '^abc'
Este patrón localizará las lineas que empiecen
por 'abc'. 

$ egrep '^abc' <<FIN
< abcdefgh
< abc xx
< 00abc
< FIN

abcdefgh
abc xx

Ejemplo para el operador '$' con el patrón 'abc$'
Este patrón localizará las lineas que terminen
por 'abc'. 

$ egrep 'abc$' <<FIN
< abcd
< 000abc
< xxabcx
< abc
< FIN

000abc
abc

Ejemplo para el operador '[ ]' con el patrón '0[abc]0'
Este patrón localizará las cadenas que tengan un '0'
seguido de un carácter que puede ser 'a', 'b', o 'c' y
seguido de otro '0'. 

$ egrep '0[abc]0' <<FIN
< 0abc0
< 0a0
< 0b0
< 0c0
< xax
< FIN

0a0
0b0
0c0

Ejemplo para el operador '^' (negación) dentro de '[ ]'
con el patrón '0[^abc]0'
Este patrón localizará las cadenas que tengan un '0'
seguido de un carácter que no podrá ser ni 'a', ni 'b',
ni 'c' y seguido de otro '0'. 

$ egrep '0[^abc]0' <<FIN
< 0abc0
< 0a0
< 000
< x0x0x
< 0c0
< FIN

000
x0x0x

Ejemplo para el operador '-' (rango) dentro de '[ ]'
con el patrón '0[a-z]0'
Este patrón localizará las cadenas que tengan un '0'
seguido de una letra minúscula, y seguido de otro '0'.
 

$ egrep '0[a-z]0' <<FIN
< 0a0
< 000
< 0Z0
< x0x0x
< FIN

0a0
x0x0x

Ejemplo para el operador '()' (agrupación) con el
patrón '0(abc)?0'
Este patrón localizará las cadenas que tengan un '0'
seguido opcionalmente de la secuencia abc, y seguido
de otro '0'. 

$ egrep  '0(abc)?0' <<FIN
< hh00hh
< s0abc0s
< s0ab0s
< 0abc
< FIN

hh00hh
s0abc0s

Ejemplo para el operador '\' (escape) con el
patrón '0\(abc\)?0'
Este patrón localizará las cadenas que tengan un '0'
seguido opcionalmente de la secuencia abc, y seguido
de otro '0'.
 

$ egrep  '0\(abc\)?0' <<FIN
< 0(abc)0xx
< 0(abc0xx
< hh00hh
< FIN

0(abc)0xx
0(abc0xx

Ampliando conocimientos sobre 'egrep'
Hemos aprendido cosas de egrep para ilustrar el uso de las expresiones regulares pero tanto grep como egrep permiten el uso de ciertas opciones que aún no hemos comentado y que no vamos a ilustrar con ejemplos porque no están relacionadas con las expresiones regulares. Solo vamos a señalar las opciones más útiles para que las conozca.

Para un mayor detalle consultar las páginas del manual. Se trata de un comando de gran utilidad y le recomendamos que practique por su cuenta con el. Exísten varias modalidades de este comando.

Uso de expresiones regulares en 'sed'
Ahora veremos unos ejemplos con 'sed'. Este comando es capaz de editar un flujo o chorro de caracteres lo cual es de enorme utilidad dado que muchos comandos se comunican a través de entrada salida mediante chorros de caracteres. No podemos ver todas las posibilidades de 'sed' porque lo que nos interesa es su uso con expresiones regulares. Para ello usaremos un nuevo operador '&' que en la parte de substitución de 'sed' indica la parte que coincide con la expresión regular.

Para usar 'sed' se pone como primer argumento a continuación del comando la orden adecuada. Opcionalmente se puede poner un segundo parámetro que indicaría el nombre de un fichero. De no existir ese segundo parámetro esperará la entrada por la entrada estándar.

Se intentan reconocer las secuencias más largas posibles ^ y $ no consumen carácter '\n' si.

Empezamos con una sustitución sencillita. 

$ echo "abc1234def" | sed "s/[0-9][0-9]*/NUMERO/"

abcNUMEROdef

Ahora usamos el operador '&'. Observe como se sustituye por el patrón reconocido. 

$ echo "abc1234def" | sed "s/[0-9][0-9]*/<&>/"

abc<1234>def

Después eliminamos la secuencia numérica. 

$ echo "abc1234def" | sed "s/[0-9][0-9]*//"

abcdef

Vamos a comprobar que en las expresiones regulares se intenta siempre reconocer la secuencia más larga posible. 

$ echo "000x111x222x333" | sed "s/x.*x/<&>/"

000<x111x222x>333

Vamos ahora a trabajar sobre un fichero. Como siempre recordamos que trabaje con un usuario sin privilegios y dentro de /tmp. Ya sabe como hacerlo así que cambie ahora a /tmp antes de continuar. Para suprimir del fichero la palabra 'Hola' en las lineas de la 3 a la 4. 

# Creamos un ficherito de prueba
$ cat <<FIN > prueba-sed.txt
< Hola este es un fichero con datos de prueba
< Hola otra vez.
< Hola otra vez.
< Hola otra vez.
< Hola otra vez y otra y otra y otra y otra y otra.
< Fin de los datos de prueba
< FIN
$ sed "3,4s/Hola//" prueba-sed.txt

Hola este es un fichero con datos de prueba
Hola otra vez.
 otra vez.
 otra vez.
Hola otra vez y otra y otra y otra y otra y otra.
Fin de los datos de prueba

El fichero no ha cambiado. El resultado sale por salida estándar. Ahora veamos que pasa si intentamos sustituir la palabra 'otra' por la palabra 'una' en todo el fichero. 

$ sed "s/otra/una/" prueba-sed.txt

Hola este es un fichero con datos de prueba
Hola una vez.
Hola una vez.
Hola una vez.
Hola una vez y otra y otra y otra y otra y otra.
Fin de los datos de prueba

Vemos que solo se ha cambiado la primera ocurrencia de cada línea. Para obtener el resultado deseado tendríamos que usar la g al final. 

$ sed "s/otra/una/g" prueba-sed.txt

Hola este es un fichero con datos de prueba
Hola una vez.
Hola una vez.
Hola una vez.
Hola una vez y una y una y una y una y una.
Fin de los datos de prueba

Ampliando conocimientos sobre 'sed'
Hemos aprendido cosas de sed para ilustrar el uso de las expresiones regulares pero sed tiene muchas más posibilidades que aún no hemos comentado. Comentaremos solo algo más pero sin extendernos demasiado. En sed se pueden especificar varias instrucciones separando con ';' cada una de ellas o usando la opción -e antes de cada instrucción. También podemos aprovechar el segundo introductor de la shell. 

$ sed "s/otra/vez/g ; s/vez/pez/g" prueba-sed.txt

Hola este es un fichero con datos de prueba
Hola pez pez.
Hola pez pez.
Hola pez pez.
Hola pez pez y pez y pez y pez y pez y pez.
Fin de los datos de prueba

# Idéntico resultado podríamos haber conseguido usando 
$ sed -e "s/otra/vez/g"  -e "s/vez/pez/g" prueba-sed.txt
# Una tercera forma para conseguir lo mismo
$ sed "
< s/otra/vez/g
< s/vez/pez/g
< " prueba-sed.txt

Por último podemos obtener el mismo resultado usando la opción -f y un fichero de instrucciones para 'sed'. 

$ cat  <<FIN > prueba-sed.sed
< s/otra/vez/g
< s/vez/pez/g
FIN
$ sed -f prueba-sed.sed prueba-sed.txt

Existen posibilidades más avanzadas para usar 'sed' pero con lo que hemos mencionado se pueden hacer muchas cosas.

Podemos eliminar los blancos a principio y al final de linea así como sustituir mas de un blanco seguido por un solo blanco. 

$ cat  <<FIN > trim.sed
< s/^  *//g
< s/  *$//g
< s/  */ /g
< FIN

Test
Puede comprobar sus conocimientos respondiendo el siguiente test.
Para ello seleccione las opciones que se ajusten a la verdad y luego pulse el boton para ver el resultado de su test.

1 [0-9a-zA-Z][a-zA-Z]* Reconocería los patrones 'CTA37', '25FEB', y 'LUIS'
2 \[[1-9]*\] Reconocería los patrones '[034]', '[322]' y '[]'
3 [A-Z][^A-Z0-9] Reconocería los patrones 'Ax', 'Bz', 'Fp' y 'Xx'
4 [Ff][Ii][Nn] Reconocería la palabra 'fin' en mayúsculas, en minúsculas, o con mezcla de ambas.
5 #.* Reconocería comentario en shell-script
6 ^[0-9] Reconocería las lineas que empiecen por algo distinto de un número
7 A(12|21)?B Reconecería las secuencias 'A12B', 'AB', o 'A21B'
8 /)$ Reconocería las líneas terminadas en ')'
9 [0-9][0-9]* Equivale a [0-9]+
10 -?(([0-9]+)|([0-9]*\.[0-9]+)
([eE][-+]?[0-9]+)?) 		Reconocería un número decimal.
11 0[0-7]* Reconocería un número Octal (Solo dígitos entre 0 y 7)

Resultado del test

Si quiere hacernos llegar alguna duda, aclaración,
crítica, o contribución personal, utilice nuestro
formulario de contacto y nosotros le contestaremos		 contacto