Expresiones Regulares

Timba Software 2010

Guillermo Freire
Definición

Una expresión regular es una forma sencilla de buscar un patrón o reemplazar un string. Para esto se
utiliza un string (regexp) que contiene la expresión regular, otro string que es el que se desea procesar
(target) o reemplazar y una librería propia del lenguaje en que se programa.
Se dice que una cadena cumple (match) con la expresion regular si la cadena tiene el patron que esta
describe.

Ejemplo de uso

Apex:

String regexp = '(.*?)((?:123)+)(.*)'; // una cadena que tenga cualquier cosa, varios 123 y despues
cualquier cosa.
String target = 'Test123123123Test';
String toReplace = '$1Timba$3';

pattern myPattern = pattern.compile(regexp);

matcher myMatcher = myPattern.matcher(target);
if(myMatcher.matches()){
//Imprimir cada grupo capturado por los parentesis de la expresion regular
for(Integer i=0; i<=myMatcher.groupCount(); i++){
System.debug('Grupo '+i+': '+myMatcher.group(i));
}
}
else{
System.debug('No match');
}

//Reemplazar utilizando grupos en la expresion regular

System.debug('Reemplazado: '+target.replaceAll(regexp,toReplace));

Javascript:

var regexp = /(.*?)((?:123)+)(.*)/;

var target = "Test123123123Test";
var toReplace = "$1Timba$3";
var result=regexp.exec(target);
if(result != null){ //Matches
for(var i = 0; i < result.length; i++){
document.write("Grupo "+i+ ": "+result[i]+"<br/>");
}
}
else{
document.write(“No match”);
}
document.write("Reemplazado: "+target.replace(regexp,toReplace));
Sintaxis

La estructura en general para formar expresiones regulares es sencilla. Se escribe el carácter o grupo de
caracteres que se espera que tenga el string a procesar y luego se indica cuantos de esos se esperan
(cuantificador).

Expresión regular Strings aceptados por la expresión Comentarios

(regexp) (target)
a a Escribir solo la letra obliga a que el texto
contenga esa letra. Aunque no se indica
cuantificador, se asume 1. No hay mas
strings que sean aceptados por esta
expresión
Abc Abc Espera que venga una A (mayúscula),
luego una b y luego una c. No hay mas
strings que sean aceptados por esta
expresión
a* (el string vacio) El cuantificador * indica 0 o mas
a repeticiones de la expresion que esta
aaa antes, en este caso la expresion a. El
aaaaaaaaaaaaaaaaa string vacio corresponde al caso en que a
se repite 0 veces.
Abc* Ab Se espera una A, una b y 0 o mas c
Abc
Abccccc
Abcccccccccccccccc
(Abc)* (el string vacio) Se usan paréntesis para asignarle un
Abc cuantificador a una expresión. De esta
AbcAbc forma se le pide que venga Abc 0 o mas
AbcAbcAbcAbcAbcAbc veces.
Ab(cd)*ef Abef Espera una A, una b, 0 o mas cd y luego
Abcdef ef
abcdcdcdcdcdcdef
a+ a El cuantificador + indica al menos una
aaaa repetición de la expresión que esta antes,
aaaaaaaaaaaaaaa en este caso la expresión a. Por esta razon
no acepta el string vacio. Es equivalente a
escribir aa*.
Abc+ Abc
Abcccccccccccc
a? (el string vacio) El cuantificador ? indica que la expresión
a anterior puede estar o no.
A(bc)? A
Abc
Expresión regular Strings aceptados por la expresión Comentarios
(regexp) (target)
a{4} aaaa {4} indica que deben venir 4 a. Es
equivalente a escribir aaaa
a{4}a* aaaa 4 a y luego 0 o mas a lo que es lo mismo
aaaaaaaaaaaaaaaaa que decir que acepta al menos 4 a.
(Abc){4}(Abc)+ AbcAbcAbcAbcAbc Al menos 5 veces Abc
AbcAbcAbcAbcAbcAbcAbc
(Ab|bc) Ab El pipe | es similar a un Or logico. Acepta
bc Ab o bc.
[Abcde] A Los parentesis rectos indican que
b cualquier carácter que este ahi dentro se
c acepta en forma individual una vez.
Equivale a (A|b|c)
[Ab-e]* (el string vacio) Cualquier carácter que este dentro del
bbbb parentesis recto puede venir 0 o varias
bAcAAcAeAAbbb veces. b-e es un atajo para bcde
[^Abc] E El ^ al comienzo de un parentesis recto
$ indica que puede venir cualquier carácter
h que NO este dentro de los parentesis
rectos.
[^Abc]* (el string vacio) 0 o mas caracteres que no esten dentro del
;%yxC@ paréntesis recto
. A El punto es un comodin, acepta cualquier
$ carácter.
;
h
.* (el string vacio) Cualquier carácter puede venir 0 o mas
Hello world! veces. (en definitiva, cualquier string es
aceptado por esta expresión regular).
.*Hello.* Hello Cualquier cosa, luego Hello, luego
Hello Carol cualquier cosa. Todos los strings que
Hello Carol, Hello Paul. contengan Hello
Hello.* Hello Los strings que comienzan con Hello
Hello Carol
.*Hello Hello Los strings que terminan con Hello
Hi, Hello
Los parentesis curvos ademas de agrupar caracteres para aplicarle cuantificadores, sirven para guardar
la parte del target que fue aceptado por esa parte entre parentesis de la expresion regular. A cada
parentesis ( que NO empieza con ?: se le asigna un numero de izquierda a derecha que puede ser
consultado luego con las funciones de grupo que tenga el lenguaje de programacion especifico.

Expresión regular Strings aceptados por la expresión Grupos

(regexp) (target)
(a*)((abc)*)(j+) aaaaabcabcjjj Grupo 0: aaaaabcabcjjj
Grupo 1: aaaa
Grupo 2: abcabc
Grupo 3: abc
Grupo 4: jjj
(a*)((?:abc)*)(j+) aaaaabcabcjjj Grupo 0: aaaaabcabcjjj
Grupo 1: aaaa
Grupo 2: abcabc
Grupo 3: jjj

?: solamente indica que no se guarde en

ningun grupo esa expresion.

Los operadores * y + intentan consumir la mayor cantidad posible de caracteres para que se cumpla la
expresion regular. Para indicarles que consuman la menor cantidad posible de caracteres, se agrega ?
luego de * o +

Expresión regular Strings aceptados por la expresión Grupos

(regexp) (target)
(.*)(abc)(.*) First abc, second abc, and third Grupo 0: First abc, second abc, and third
Grupo 1: First abc, second
Grupo 2: abc
Grupo 3: , and third
(.*?)(abc)(.*) First abc, second abc, and third Grupo 0: First abc, second abc, and third
Grupo 1: First
Grupo 2: abc
Grupo 3: , second abc, and third

Al reemplazar con expresiones regulares se puede especificar que coloque lo capturado en el grupo 1
con $1, lo del grupo 2 con $2, etc

Expresión Strings aceptados por la Reemplazo Resultado

regular expresión (target)
(regexp)
(.*)(abc)(.*) First abc, second abc, and and third $1$2 bcd $2$3 First abc, second abc bcd
abc, and third

Una referencia mas amplia de comodines se puede ver en:

http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Pattern.html