Expresiones regulares

Muchos comandos de procesamiento y búsqueda de texto como ed, grep, egrep, sed, awk o vi usan expresiones regulares:

• permiten reconocer una serie de cadenas de caracteres que obedecen a cierto patrón
• Ejemplos
  • egrep unix tmp.txt
    busca en el fichero tmp.txt las líneas que contienen la palabra unix
  • egrep '[Uu]nix' tmp.txt
    busca las líneas que contienen unix o Unix
  • egrep 'hel.' tmp.txt
    busca las líneas que contienen hel seguido de cualquier carácter
  • egrep 'ab*c' tmp.txt
    localiza las cadenas que empiecen por a, que continúen con 0 o más b, y que sigan con una c, por ejemplo: abbbc o aaacb, pero no axc o cba
  • egrep 't[^aeiouAEIOU][a-zA-Z]*' tmp.txt
    localiza las cadenas que empiecen por t, seguido de algún carácter no vocálico y 0 o más apariciones de otro carácter

Importante: no debemos confundir las expresiones regulares con la sustitución de nombres de ficheros (globbing)

• si ponemos el último ejemplo sin comillas

  egrep t[^aeiouAEIOU][a-zA-Z]* tmp.txt

  la shell extiende los comodines y convierte este comando en:

  egrep tmp.txt tmp.txt

• para evitar esto, siempre usar comillas con las expresiones regulares

Comandos grep y sed

grep y sed son dos comandos que usan REGEXP

grep

Busca en ficheros por un patrón determinado

grep [opciones] patrón [fichero...]

Opciones:

• -E o egrep: usa expresiones regulares extendidas
• -F o fgrep: interpreta los patrones no como expresiones regulares sino como cadenas de caracteres fijas
• -R o rgrep: lee todos los ficheros bajo cada directorio, recursivamente
• -i o --ignore-case: busca ignorando diferencias entre mayúsculas y minúsculas
• -w o --word-regexp: para forzar que la cadena reconocida sea una palabra completa
• -l o --files-with-matches: no muestra el contenido de la linea encontrada pero si que muestra el fichero que contiene la cadena buscada
• -n o --line-number: muestra el número de línea dentro del fichero
• -v o --invert-match: en lugar de sacar la lineas que cumplen la búsqueda sacará las que no cumplen

Si no especificamos fichero, grep usa la entrada estándar:

• podemos usarlo para probar las expresiones regulares:

  $ egrep '[Uu]nix'
  unix
  unix
  Unix
  Unix
  Linux
  

sed (stream editor)

Editor de flujo; permite realizar transformaciones básicas de un flujo de entrada (un fichero o una entrada desde una tubería)

Formato (para substituciones):

sed [opciones] 's/REGEXP/reemplazo/flag' [fichero]

Algunos comandos:

• s substitución
• d borrado
• i\, a\, añade antes/después de la línea afectada
• c\ reemplaza la línea afectada

Algunas ociones:

• -e comando: añade comando
• -i edita el fichero in-place
• -n suprime la salida

Algunos flags:

• g: aplica los cambios globalmente (por defecto, sólo se cambia la primera aparición en cada línea)
• p imprime las líneas afectadas, incluso con la opción -n.
• NUMERO: reemplaza la aparición número NUMERO
• w fichero: escribe las líneas con sustituciones al fichero indicado

Ejemplo: cambia, en el fichero amigos, todas las apariciones de pepe y paco por Pepe y Paco, respectivamente:

$ sed -e 's/pepe/Pepe/g' -e 's/paco/Paco/g' amigos (también sed 's/pepe/Pepe/g ; s/paco/Paco/g' amigos)

Ejemplo: cambia pepe por Pepe, pero sólo en las líneas que tengan Potamo

$ sed '/Potamo/s/pepe/Pepe/g' amigos

Ejemplo: muestra sólo las lineas que contengan jaime

$ sed -n '/jaime/p' amigos

Ejemplo: borra las lineas que contengan jaime

$ sed '/jaime/d' amigos

Ejemplo: cambia las lineas que contengan jaime por otra cosa

$ sed '/jaime/c\BORRADO' amigos

Ejemplo: inserta una línea, con la palabra 'APARICION', antes de las líneas que contengan jaime

$ sed '/jaime/i\APARICION' amigos

Ejemplo: reemplaza, en cada línea de fichero, la quinta ocurrencia de stop por STOP

$ sed 's/stop/STOP/5' fichero

Ejemplo: igual que antes pero guarda cada línea reemplazada en el fichero f2

$ sed 's/stop/STOP/5w f2' fichero

Indicación de líneas:

podemos especificar las líneas del fichero en las que queremos que se realicen las operaciones:

sed '3s/stop/STOP/g' (reemplaza sólo en la línea 3)
sed '3,10s/stop/STOP/g' (reemplaza de la línea 3 a la 10)
sed '3,$s/stop/STOP/g' (reemplaza de la línea 3 al final)
sed '!3s/stop/STOP/g' (reemplaza en todas las líneas menos la 3)

Operador &:

se sustituye por el patrón reconocido

Ejemplo: reemplaza stop por <stop>

$ sed '3s/stop/<&>/g' fichero

Comandos desde fichero:

la opción -f permite leer comandos de sed agrupados en un fichero

Ejemplo: reemplazo desde la línea 1 hasta una línea que comience por END (o el final, si no hay ninguna)

$ cat file.sed
1,/^END/{
    s/[Ll]inux/GNU\/Linux/g
    s/samba/Samba/g
}
$ sed -f file.sed fichero

Más información:

sed es un comando muy complejo con muchas posibilidades

Para saber más:

• mirar la página de info de sed
• Sed - An Introduction
• Ejemplos con sed
• Sed by example, IBM developerworks
• sed & awk, by Dale Dougherty, Arnold Robbins, O'Reilly

o, simplemente, busca sed tutorial en google

Expresiones regulares básicas

UNIX admite dos tipos de expresiones regulares: básicas y extendidas

• las básicas son las clásicas de UNIX, aunque se consideran obsoletas en POSIX
• aplicaciones como grep o sed las usan por defecto
• para usar las extendidas:
  • grep --> egrep o grep -E
  • sed --> sed -r
• las expresiones extendidas proporcionan más potencia

La mayoría de los caracteres son tratados como literales:

• concuerdan (match) consigo mismos:
  • a concuerda con a, ab con ab, etc.
• la excepción son los metacaracteres:

  . [ ] ^ $ * ( ) \

ER de un sólo carácter

ER concuerda con

. cualquier carácter

[ ] cualquiera de los caracteres entre corchetes, p.e. [abc] concuerda con a, b o c; [a-z] concuerda con cualquier letra minúscula

[^ ] cualquier carácter que no esté entre corchetes

^ principio de línea

$ final de línea

* 0 o más ocurrencias de la expresión regular anterior

\( \) permite agrupar ER

\ escapa un metacarácter

• Dentro de [ ] los metacaracteres pierden su significado especial: p.e. [a.]c concuerda con ac y .c
• Para incluir un carácter ] en una lista colocarlo al principio; para incluir un ^ en cualquier lugar menos al principio; para incluir un - al final: p.e. [a^]c concuerda con ac y ^c

Ejemplos:

ER concuerda con

a..c cadena que empiece por a, seguida por dos caracteres y c: a00c, xaxxcxx, aacc,...

0[abc]0 cadenas que tengan un 0 seguido de un carácter a, b, o c y seguido de otro 0: 0a0, 00ab0b0, bc0c0,...

0[^abc]0 cadenas que tengan un 0 seguido de un carácter distinto a a, b, o c y seguido de otro 0

0[a-z]0 cadenas que tengan un 0 seguido de una letra minúscula, y 0

^abc líneas que empiecen por abc

abc$ líneas que terminen por abc

ab*c cadenas que empiecen por a, que continúen con 0 o más b, y una c: abc, ac, abbc, aaccab,...pero no cba o aaab

b[cq]*e cadenas que empiecen por b, que continúen con 0 o más c o q, y una e: be, bcce, bccqqee o bqqqce

.* cualquier cadena

abc.* cualquier cadena que empiece por abc

0\(abc\)*0 cadenas que tengan un 0 seguido de 0 o más ocurrencias de abc, y seguido de otro 0: 0abc0, 00, 0abcabc0,..., pero no 0ac0 o 0cba0

^#.*\.$ línea que empiece por # y termine por . (notar que el segundo . está escapado por la \; la ER .* implica 0 o más caracteres cualquiera)

Repetición

Podemos repetir una regexp usando \{ \}

Constructor Propósito

\{n\} concuerda con exactamente n ocurrencias de la RE previa

\{n,\} concuerda con al menos n ocurrencias de la RE previa

\{n, m\} concuerda con entre n y m ocurrencias de la RE previa

Ejemplos:

• a\{5\}: 5 ocurrencias del carácter a
  
• .\{5,\}: al menos 5 ocurrencias de cualquier carácter

Expresiones regulares extendidas

Los sistemas UNIX actuales admiten extensiones a las expresiones regulares básicas:

• debemos usar egrep, grep -E, sed -r

ER concuerda con

+ una o más ocurrencias de la RE anterior

? cero o una ocurrencia de la RE anterior

Además, \( \) y \{ \} se reemplazan por ( ) y { }

• Ejemplos:
  • ab+c concuerda con abc, abbc, pero no con ac
  • ab?c concuerda con ac, abc, pero no con abbc
• Para usar los caracteres (, ), { o } escaparlos con \

Alternancia

El carácter | permite alternar entre 2 o más RE

• (a|b)c concuerda con ac o bc

Etiquetado

Las RE que se ponen entre ( ) quedan etiquetadas, y podemos hacer referencia a esos elementos mediante \n, con n el número de la etiqueta

• Ejemplos:
  • (.)oo\1 concuerda con moom, noon, pero no con moon
  • (.)oo\1-(.)aa\1\2 concuerda con moom-paamp

Otros caracteres

Además de los ya vistos, pueden usarse otros metacaracteres:

ER concuerda con

\n, \r, \t LF, CR y tab (no siempre funcionan)

[:space:] caracteres en blanco ([ \t\n\r\f\v])

[:blank:] espacio y tabulado

[:alnum:] o \w caracteres alfánuméricos (letras y números)

[:digit:] dígitos

[:alpha:] alfabéticos

[:upper:] mayúsculas

[:lower:] minúsculas

[:xdigit:] dígitos hexadecimales

[:punct:] signos de puntuación

[:cntrl:] caracteres de control

[:graph:] caracteres imprimibles (sin espacio)

[:print:] caracteres imprimibles (con espacio)

\<, \> inicio/fin de palabra

\b posición entre palabras

\B posición en medio de una palabra

• [[:upper:]]bc concuerda con Abc, pero no abc
• \babc\b concuerda con ab abc df, pero no con abcdef
• \Babc\B concuerda con ababcdf, pero no con ab abc df

Más ejemplos

1. \w+@\w+\.\w+((\.\w+)*)? concuerda con direcciones de e-mail
2. (0[1-9]|[12][0-9]|3[01])-(0[1-9]|1[012])-(19|20)[0-9]{2} concuerda con fechas en el formato dd-mm-yyyy (años entre el 1900 y 2099)
3. [-+]?([0-9]*\.)?[0-9]+([eE][-+]?[0-9]+)? concuerda con números en punto flotante (con o sin exponente)

Ejemplos de uso con sed:

$ echo "abc1234def" | sed -r "s/[0-9]+/NUMERO/"
abcNUMEROdef
$ echo "abc1234def" | sed -r 's/[0-9]+/<&>/'
abc<1234>def
# En el siguiente ejemplo, notar que las ER intentan siempre reconocer la secuencia más larga posible
$ echo "000x111x222x333" | sed 's/x.*x/<&>/'
000<x111x222x>333
# Eliminar blancos a principio y al final de línea y sustituir más de un blanco seguido por uno solo
$ sed -r "s/^_+// ; s/_+$// ; s/__+/_/g" fich
# Pon los 4 primeros caracteres de cada línea al final de la misma
$ sed -r 's/^(.{4,4})(.*)/\2\1/' fich
# 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)
$ sed 's/^M$//'⁴
# también funcionaría
$ sed 's/\r//'

Para más información: Regular-expressions.info