PDF de programación - Regular Expressions

Regular Expressions

s/\(Regular\).*/Expresiones \1es/

Definición

Una expresión regular, también llamada

regex o regexp, es una secuencia de

caracteres que forma un patrón de

búsqueda, principalmente utilizada para

la búsqueda de patrones de cadenas de

caracteres u operaciones de sustituciones

Historia

Las regex fueron creadas
en 1956 por el matemático
Stephen Kleene, quien entre
otras cosas también es uno
de los padres de la teoría
de las funciones
recursivas

Regex en Unix

Las regex se volvieron
populares en 1968 gracias
a Ken Thompson, quién las
implementó en el editor ed
y más tarde (1973) en grep

Ken Thompson

Creador, junto con
Dennis Ritchie, de UNIX
(1969), creador del
lenguaje B (precursor
del C). Co-creador de la
codificación UTF-8.
Actualmente
desarrollando el
lenguaje Go

g/re/p

globally search a regular expression and print

grep es una herramienta de línea de comandos que

imprime todas aquellas líneas de un archivo de
texto que matcheen contra una expresion regular

Así se ve una regex

^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+

(\.[a-z0-9-]+)*(\.[a-z]{2,4})$

Las regex usan metacaracteres

\ ^ $ . [ ] * + | ? ( ) { }

POSIX standard

El estándar POSIX posee tres tipos de
expresiones regulares

● BRE - Basic Regular Expressions
● ERE - Extended Regular Expressions
● SRE - Simple Regular Expressions(*)

(*) Deprecated

Qué es POSIX ?

POSIX es el acrónimo de

"Portable Operating System Interface for UNIX"

POSIX es una familia de estándares

para mantener compatibilidad

entre distintas variantes de UNIX.

Basic Regular Expression Vs.
Extended Regular Expressions

La diferencia principal entre BRE y ERE

es la cantidad de

metacaracteres detectados

Metacaracteres en BRE

\ ^ $ . [ ] *

Metacaracteres en BRE

\ ^ $ . [ ] * \+ \| \? \( ) \{ }

Metacaracteres en ERE

\ ^ $ . [ ] * + | ? ( ) { }

Estructura de una
regex de sustitución

s/pattern/replace/[modifiers]

Punto

El . indica cualquier caracter
menos fin de línea

s/./x/g

Cómo matchear el punto?

Rangos

Con [] puedo definir rangos de
caracteres y especificar mi búsqueda

:%s/[abc]/x/g

Ejemplos de rangos

[0-9]
[0-9a-zA-Z]
[^abc]

caracteres del 0 al 9
números + letras
cualquier cosa menos a, b y c

Clases de caracteres

Los rangos más
comunes tienen una
forma más corta de
escritura

\d [0-9]
\D [^\d]
\w [A-Za-z0-9_]
\W [^\w]
\s [ \t\r\n]
\S [^\s]

Contadores

0 o más ocurrencias
1 o más ocurrencias

*
\+
\? 0 o 1 ocurrencia

Contadores

$ echo "ala olla pollo polo" | sed 's/l*//g'
aa oa poo poo

$ echo "ala olla pollo polo" | sed 's/ol\?/_/g'
ala _la p_l_ p__

$ echo "alaa olla pollo polo" | sed 's/a\+/a/g'
ala olla pollo polo

Contadores

$ find assets -regex ".*[0-9]+.png"
assets/admin/v3/js/select2/select2.png
assets/admin/v3/js/select2/select2x2.png
assets/admin/images/coquelux2.png
assets/images/tarjetas/8d1860cb15f3b57d5456bd83309a0a79.png
assets/images/v2/tabla_talles/Talles-Ropa_10.png
assets/admin/images/admin/ventas/35.png
assets/admin/images/admin/ventas/0.png

Más contadores

\{n,m}
\{n}
\{,m}
\{n,}

matchea de n a m ocurrencias
matchea n ocurrencias
matchea hasta m ocurrencias (de 0 a m)
matchea al menos n ocurrencias

Más contadores

$ grep --color '10\{2,3\}' /etc/group
users:x:100:
it:x:1000:
xleo:x:1001:
wireshark:x:1002:xleo

Más contadores

$ grep '2014:1[1-3]:[0-9]\{2\}' access.log
127.0.0.1 - - [16/Dec/2014:11:53:02 -0300] "GET …
...
127.0.0.1 - - [16/Dec/2014:12:16:39 -0300] "GET ...

Extremos

^
$

Inicio de la línea
Final de la línea

Extremos ^

$ ls -l /usr/local/ | grep ^d
drwxr-xr-x 2 root root 4096 oct 22 06:25 bin
drwxr-xr-x 2 root root 4096 oct 17 2012 etc
drwxr-xr-x 5 root root 4096 nov 7 00:09 lib
drwxr-xr-x 2 root root 4096 oct 17 2012 sbin
drwxr-xr-x 7 root root 4096 sep 30 13:14 share
drwxr-xr-x 2 root root 4096 oct 17 2012 src

Extremos $

1 mi··¬
2 editor y yo····¬
3 ···¬
4 dejamos espacios·¬
5 donde no corresponde¬
6 ···¬

:%s/ \+$//

Group & Back reference

$ printf "%s\n" \
"I love cats" "I love dogs" "I love rabbits" \
| sed 's/love \(cats\|dogs\)/hate \1/'
I hate cats
I hate dogs
I love rabbits

Group & Back reference

$ echo -e "Juan Manuel Alsina\nCarlos Ramirez" \
| sed 's/^\(.*\) \(\w*\)$/\2, \1/'
Alsina, Juan Manuel
Ramirez, Carlos

Links

● http://xkcd.com/208/
● http://www.regular-expressions.info/
● http://www.regexr.com/

Gracias!