Clase 10 expresiones regulares

Electiva II
Clase 10
Expresiones Regulares
JavaScript
Ing. José Ricardo Tillero UPTAEB

Expresiones Regulares JavaScript
Expresiones Regulares
 Las expresiones regulares son patrones que se utilizan para hacer coincidir
combinaciones de caracteres en cadenas.
 Las expresiones regulares permiten comprobar si una cadena de texto se ajusta
a un determinado tipo de estructura o patrón.
 Las expresiones regulares no son exclusivas del lenguaje javascript, otros
lenguajes de programación también las usan, de hecho javascript las ha
importado de ellos, por lo que son muy similares tanto en Java, como en PHP y
otros lenguajes.
 Un expresión regular consiste en:
 Un patrón (pattern) que se usa para localizar textos que se ajusten a él.
 Modificadores (opcionales) que nos indican como aplicar el patrón.

Crear una Expresión Regular
 Construyes una expresión regular en una de estas dos formas:
 Usando una expresión regular literal, que consiste en un patrón encerrado
entre barras, como sigue:
> let re = /ab+c/;
o
> var re = /ab+c/;
 O llamando a la función constructora del objeto RegExp, de la siguiente
manera:
> let re = new RegExp('ab+c');
o
> var re = new RegExp('ab+c');

Escribir un patrón de Expresión Regular
 Un patrón de expresión regular se compone de caracteres simples, como /abc/, o una combinación de
caracteres simples y especiales, como /ab*c/ o /Capítulo (d).d*/.
 Usar patrones simples:
 Los patrones simples se construyen con caracteres para los que deseas encontrar una coincidencia
directa. Por ejemplo, el patrón /abc/ coincide con combinaciones de caracteres en cadenas solo
cuando ocurre la secuencia exacta "abc" (todos los caracteres juntos y en ese orden). Tal
coincidencia tendría éxito en las cadenas "Hola, ¿conoces tu abc?" y "Los últimos diseños de
aviones evolucionaron a partir de slabcraft". En ambos casos, la coincidencia es con la
subcadena "abc". Ahora para la siguiente cadena "Grab crab", no hay ninguna coincidencia porque
aunque contiene la subcadena "ab c", no contiene la subcadena "abc" exacta.
 Usar caracteres especiales:
 Cuando la búsqueda de una coincidencia requiere algo más que una coincidencia exacta, como por
ejemplo buscar una o más 'b', o encontrar espacios en blanco, puedes incluir caracteres especiales
en el patrón. Por ejemplo, para hacer coincidir una sola "a" seguida de cero o más "b" seguidas de
"c", usarías el patrón /ab*c/: el * después de "b" significa "0 o más apariciones del elemento
anterior". En la cadena "cbbabbbbcdebc", este patrón coincidirá con la subcadena "abbbbc".

Comprobar un texto con Expresiones Regulares
 El caso más simple es comprobar si una determinada cadena de texto está contenida en otra:
> expresion = /martes/;
 Esta expresión comprobará si la cadena "martes" está contenida en otra. Al aplicar un método de
búsqueda devolverá verdadero si la cadena contiene martes, se dice entonces que la cadena se ajusta al
patrón, y devolverá falso si no lo contiene.
 Para ello utilizaremos el método test(), el cual se emplea de la siguiente manera:
> resultado = expresionRegular.test("texto a comprobar");
 La variable resultado devolverá el valor booleano true si la cadena contiene la expresión al menos una
vez, y false si no la contiene.
 Veamos el ejemplo para la expresión anterior.
> texto1 = "Los martes voy al gimnasio.";
> texto2 = "Los miércoles voy a clase de inglés.";
> buscar = /martes/;
> alert(buscar.test(texto1)); //devuelve true
> alert(buscar.test(texto2)); //devuelve false

Comprobar en grupos de caracteres con Expresiones Regulares
 Si lo que se quiere buscar es un grupo de caracteres, estos irán encerrados entre corchetes:
expresion = /[aeiou]/;
 Esta expresión buscará cualquiera de las vocales en el texto y en ese caso se ajustará al patrón. Los
corchetes definen caracteres que debe contener la cadena. Probemos con un ejemplo similar al anterior:
> texto1 = "a = 4.65";
> texto2 = "b = 17.3";
> buscar = /[aeiou]/;
 En éste ejemplo el primer texto se ajusta al patrón, al tener una vocal, y el segundo no, al no contener
vocales.
 Sin embargo los elementos dentro del corchete pueden formar grupos homogéneos, tales como cifras
consecutivas o letras consecutivas del alfabeto, en ese caso ponemos la primera y la última y un guion
en medio, es decir:
/[a-f]/, es lo mismo que poner /[abcdef]/
/[1-5]/, es lo mismo que poner /[12345]/

 Si queremos incluir el guion dentro de la expresión anterior lo podemos poner al final: /[a-f-]/, o
también al principio, pero con una barra inclinada al revés para indicar que es un carácter de escape:
/[-a-f]/.
 Los caracteres de escape tienen aquí la misma función que en los textos, poder escribir ciertos
símbolos que sirven para el código.
 El siguiente ejemplo comprueba si el texto tiene alguno de los números del 1 al 5:
> texto1 = "Pedro tiene 62 años";
> texto2 = "Pablo tiene 67 años";
> buscar = /[1-5]/;

 Clases de caracteres: Para los casos más habituales hay unos caracteres especiales que indican si la cadena
tiene un determinado tipo de caracteres:
 /w/: Contiene caracteres alfanuméricos.
 /W/: Devuelve false si sólo contiene caracteres alfanuméricos.
 /d/: Contiene dígitos o cifras.
 /D/: Devuelve false si sólo contiene dígitos.
 /s/: Contiene alguno de los caracteres que definen espacios en blanco (espacio, tabulador, retorno de
carro ... ).
 /S/: Devuelve false si sólo contiene caracteres que definen espacios en blanco.
 Ejemplos con estos caracteres especiales.:
Ejemplo 1 Ejemplo 2
> texto1 = "María cumple 12 años";
> texto2 = "María cumple doce años";
> buscar = /d/;
texto1 = "Hoy es lunes";
texto2 = " ";
buscar = /w/;
alert(buscar.test(texto1)); //devuelve true
alert(buscar.test(texto2)); //devuelve false

 Otros caracteres especiales: El signo /./ indica cualquier carácter, con lo que se suele usar para comprobar
que la cadena no está vacía, tal como muestra este ejemplo::
> texto1 = "Hoy es lunes";
> texto2 = "";
> buscar = /./;
 Como se ve el punto es un carácter especial, por lo que si queremos buscar un punto en la cadena deberemos
ponerlo con una barra inclinada inversa delante: /./, así buscaremos si la cadena contiene algún punto.
 Los signos ^ al principio de la expresión regular y $ al final indican que la cadena de texto debe coincidir
completamente con la expresión regular, es decir , comprueba que la cadena se ajusta completamente al patrón
en lugar de comprobar si lo contiene. Así por ejemplo, si queremos comprobar si una cadena es un número
escribiremos: /^d$/, como en el siguiente ejemplo:
> texto1 = "casa";
> texto2 = "Mi casa es grande";
> buscar = /^casa$/;

Crear el objeto RegExp
 Las expresiones regulares tienen una sintaxis propia, esto es lo que suele hacerlas algo complicadas, ya
que no es igual que el resto de elementos de javascript. Para empezar cualquier expresión regular debe
estar encerrada entre los caracteres / ... /:
expresion = / ...codigo_expresion .../modificadores o banderas
> var myRe = /d(b+)d/g;
 Al guardar la expresión regular en una variable, ésta se convierte en un objeto del tipo RegExp. También
podemos crear la expresión regular mediante el método general para crear objetos:
expresion = new RegExp('..codigo_expresion... ', 'modificadores o banderas')
> var myRe = new RegExp('d(b+)d', 'g');
 En este caso no debemos poner el código entre barras inclinadas.

Cuantificadores de patrones de objetos RegExp
 Los cuantificadores son signos que se ponen detrás de un determinado patrón
de búsqueda, y que indican las veces que debe aparecer en el texto para
ajustarse al patrón.
 /a+/: La cadena debe contener el patrón (letra "a") una o más veces.
 /a*/: El patrón (letra a) debe aparecer cero o más veces.
 /a?/: El patrón debe aparecer cero o una vez.
 /a{3}/: El patrón debe aparecer exactamente tres veces (en lugar del 3 puede ser
cualquier otro número).
 /a{3,8}/: El patrón debe aparecer entre 3 y 8 veces (ambos inclusive).

Modificadores o banderas de objetos RegExp
 Los modificadores o "flags" son unas letras con un significado especial que se
ponen detrás de la expresión regular, y matizan la forma de buscar. Estos son
los siguientes:
 g: /a/g - Explora la cadena hasta el final.
 i: /a/i - No distingue entre mayúsculas y minúsculas.
 m: /a/m - Permite usar varios ^ y $ en la cadena.
 s: /a/s - Incluye el salto de línea en el comodín punto .
 x: /a/x - Ignora los espacios en el patrón .
 Si escribimos más de un modificador en una expresión regular, debemos
ponerlos en el mismo orden que aparecen arriba, es decir, en orden alfabético.

Propiedades de los objetos RegExp
 Las siguientes propiedades se usan con el objeto RegExp y no con cualquier expresión regular concreta, por tanto se
escribirán de la forma: RegExp.propiedad; son de sólo lectura, por lo que no las podemos modificar directamente, sin
embargo se actualizan automáticamente cada vez que se emplea un método con un objeto regular, ya sea con los
métodos de RegExp o con los métodos de String, correspondiendo la cadena explorada a la obtenida tras el último
método empleado. las propiedades son:
 $1 ... $9: índices que contienen las partes agrupadas con paréntesis en el patrón de búsqueda.
 RegExp.input: Cadena que se ha explorado.
 RegExp.lastMatch: Última coincidencia encontrada.
 RegExp.multiline: Variable booleana que indica si la cadena explorada incluye saltos de línea.
 RegExp.lastParent: Última coincidencia encontrada con un patrón entre paréntesis.
 RegExp.leftContext: Desde el principio de la cadena hasta la coincidencia hallada.
 RegExp.rightContext: Desde la coincidencia hasta el final de la cadena.
 RegExp.global: Con false (por defecto) devuelve solo el primer elemento encontrado. Con true devuelve todos los elementos
encontrados.
 RegExp.ignoreCase: Si está a true haremos el matching sensible a mayúsculas (por defecto a false).
 RegExp.lastIndex: La posición por la que empezar la búsqueda (por defecto a 0).
 RegExp.source: Contiene la expresión regular.
 Estas propiedades (excepto lastIndex) no pueden ser modificadas después de creado el objeto.

Propiedades de los objetos RegExp
 Ejemplos:
> var re = new RegExp('j.*t', 'gmi');
> re.global
< true
> re.global = false;
< false
> re.global
< true
> var re = /j.*t/ig;
> re.global
< true
> re.source
< "j.*t"

Métodos de los Objetos RegExp
 El objeto RegExp tiene varios métodos, pero también se pueden usar algunos métodos del objeto String
para trabajar con expresiones regulares.
 test(): Este método busca el patrón en el texto y devuelve el valor booleano true si el texto se ajusta, si no
es así devolverá false. Su sintaxis es:
buscar = patron.test("cadena");
Donde buscar es la variable donde se devuelve el valor (true o false); patron es la variable que contiene la
expresión regular, y "cadena" es la cadena de texto en la que se busca; si la cadena se pasa de forma
literal llevará las comillas, si la pasamos en una variable, no llevará comillas.
 exec(): Este método busca la expresión en el texto, y devuelve el primer texto que concuerda con la
expresión buscada. Si no encuentra ninguna coincidencia, entonces devuelve null. Su sintaxis es la
siguiente:
buscar = patron.exec(texto);
Donde patron es la variable que contiene la expresión regular, y texto es la variable que contiene la cadena
de texto. El resultado de este método es el trozo de cadena que se ajusta al patrón, y se guarda en la
variable buscar.

 exec(): Este método tiene además dos propiedades, la propiedad index, la cual nos indica la posición en la
que se encuentra la cadena buscada, y la propiedad input, la cual devuelve la cadena completa en la que
estamos realizando la búsqueda. La posición que indica la propiedad index es la del primer carácter
encontrado en el trozo de cadena que coincide. este se empieza a contar a partir del 0.
posicion = patron.exec(texto).index;
textoCompleto = patron.exec(texto).input;
 compile(): El método compile convierte el patrón en un formato interno para que la ejecución sea más
rápida. Por ejemplo, esto permite un uso más eficiente de expresiones regulares en bucles. Su sintaxis es la
siguiente:
compilado = patron.compile(patron);
La variable compilado guardará la expresión regular ya compilada.

 Ejemplos:
> /j.*t/.test("Javascript")
< false
> /j.*t/i.test("Javascript")
< true
> /s(amp)le/i.exec("Sample text")
< ["Sample", "amp"]
> /a(b+)a/g.exec("_abbba_aba_")
< ["abbba", "bbb"]

 Ejemplos:
<!DOCTYPE html>
<html>
<head>
<title>implementación de el método exec()</title>
<style type="text/css">
#caja { width: 400px; border: 1px black solid; float: right; }
</style>
<script type="text/javascript">
function elMetodo(){
patron = /hidalgo/gi; //expresión regular.
texto = document.getElementById("mitexto").innerHTML;
respuesta = patron.exec(texto); //buscar mediante exec()
elemento = document.getElementById("caja");
elemento.innerHTML = "palabra buscada: "+ respuesta +"<br/> ";
posicion = respuesta.index; //propiedad index: posición.
elemento.innerHTML += "posición: "+ posicion +"<br/> ";
textoCompleto = respuesta.input; //propiedad input: texto completo.
elemento.innerHTML += "Texto en que se encuentra: "+ textoCompleto;
}
</script>
</head>
<body>
<h1>Metodo exec para expresiones regulares.</h1>
<div id="caja"></div>
<h4>Texto de ejemplo:</h4>
<p id="mitexto">En un lugar de la Mancha, de cuyo nombre no quiero acordarme,
no ha mucho tiempo que vivía un hidalgo de los de lanza en astillero,
adarga antigua, rocín flaco y galgo corredor. Una olla de algo más vaca
que carnero, salpicón las más noches, duelos y quebrantos los sábados,
lentejas los viernes, algún palomino de añadidura los domingos, consumían
las tres partes de su hacienda.</p>
<h4>Buscar la palabra "hidalgo"</h4>
<form action="#" name="elmetodo">
<p><input type="button" value="Metodo exec" onclick="elMetodo()" /></p>
</form>
</body>
</html>

Métodos de String que aceptan Expresiones Regulares
 Los siguientes métodos de la clase String pueden usarse para trabajar con las expresiones regulares.
En ellos la expresión regular o patrón la escribiremos siempre como parámetro o argumento del
método, es decir, dentro del paréntesis.:
 search(): Busca la expresión regular en la cadena de texto, si la encuentra devuelve un número indicando
su posición (el del primer carácter), empezando a contar desde 0, si no la encuentra devuelve -1. Su sintaxis
es la siguiente:
buscar = texto.search(patron);
Donde texto es la variable que contiene el texto donde se busca, y patron es la expresión regular. La
variable buscar contendrá el número en el que se encuentra la primera coincidencia (empezando a contar
por el 0), si no hay coincidencia en la cadena, éste será -1.
 split(): Este método transforma la cadena en un array, la expresión regular indica cual es el delimitador
que separa los elementos del array. por ejemplo, con la siguiente expresion regular /s/ cada vez que se
encuentra un espacio se crea un nuevo elemento del array, con lo que el array contendria las palabras de la
cadena. Su sintaxis es parecida a la del método anterior:
miarray = texto.split(patron);

 match(): Devuelve un arreglo que contiene todas las coincidencias, incluidos los grupos de captura, o null
si no se encuentra ninguna coincidencia. Su sintaxis es la siguiente:
hallado = texto.match(patron);
Donde la variable texto es el texto en el que se hará el emparejamiento, patron contiene la expresión
regular, y hallado es la variable que contiene el array con todas las ocurrencias.
 replace(): Este método devuelve la cadena original, en la que se ha remplazado las coincidencias
encontradas por la expresión regular, por otro texto pasado también como argumento. Por lo tanto a este
método le pasaremos dos argumentos. que serán la expresión regular, y la cadena a remplazar. Su sintaxis
es la siguiente:
nuevoTexto = texto.replace(patron,remplazo);
Donde la variable texto es el texto en el que se explora, patron contiene la expresión regular, y remplazo
es la variable que contiene el nuevo texto que se va a poner en lugar del encontrado por la expresión .

 Ejemplos:
> var s = "HelloJavaScriptWorld“;
< undefined
> s.match(/a/);
< ["a"]
> s.match(/a/g);
< ["a", "a"]
> s.match(/j.*a/i);
< ["Java"]
> s.search(/j.*a/i);
< 5
> s.replace(/[A-Z]/g, '');
< "elloavacriptorld"
< s.replace(/[A-Z]/, '');
> s.replace(/[A-Z]/g, "_$&");
< "_Hello_Java_Script_World"
> s.replace(/([A-Z])/g, "_$1");
< "_Hello_Java_Script_World"
> function replaceCallback(match){return "_" + match.toLowerCase();}
< undefined
> s.replace(/[A-Z]/g, replaceCallback);
< "_hello_java_script_world"

 Ejemplos:
> "juanmanuel.garrido@softonic.com".replace(/(.*)@.*/, "$1");
< "juanmanuel.garrido"
> var sMail = "juanmanuel.garrido@softonic.com";
< undefined
> var rRegExp = /(.*)@(.*).(.*)/;
< undefined
> var fCallback = function () { args = arguments;
return args[1] + " de " args[2].toUpperCase(); }
< undefined
> sMail.replace(rRegExp, fCallback);
< "juanmanuel.garrido de SOFTONIC"
> args
< ["juanmanuel.garrido@softonic.com", "juanmanuel.garrido", "softonic", "com", 0,
"juanmanuel.garrido@softonic.com"]
> var csv = 'one, two,three ,four';
> csv.split(',');
< ["one", " two", "three ", "four"]
> csv.split(/s*,s*/)
< ["one", "two", "three", "four"]
> "test".replace('t', 'r')
< "rest"
> "test".replace(new RegExp('t'), 'r')
< "rest"
> "test".replace(/t/, 'r')
< "rest"

 Ejemplo usando match:
En el siguiente ejemplo, se usa match para hallar "Capítulo" seguido de 1 o más
caracteres numéricos seguidos de un punto decimal y caracteres numéricos cero o más
veces. La expresión regular incluye el flag i por lo que las mayúsculas serán ignoradas.
> cadena = "Para más información, vea Capítulo 3.4.5.1";
> expresion = /(capítulo d+(.d)*)/i;
> hallado = cadena.match(expresion);
> console.log(hallado);
Esto devuelve un array que contiene Capítulo 3.4.5.1, Capítulo 3.4.5.1,.1
"Capítulo 3.4.5.1" es el primer emparejamiento y el primer valor referenciado por
(Capítulo d+(.d)*).
".1" es el segundo valor referenciado por (.d).

 Ejemplo usando las banderas global e ignoreCase para ignorar las mayúsculas con
match:
El siguiente ejemplo demuestra el uso de los flags global e ignorar mayúsculas con match.
Todas las letras de A hasta E y de a hasta e son devueltas, en su propio elemento dentro
del array..
> var cadena = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
> var expresion = /[A-E]/gi;
> var array_emparejamientos = cadena.match(expresion);
> console.log(array_emparejamientos);
array_emparejamientos será ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']

Sintaxis de los caracteres de busquedas en Expresiones Regulares
 [abc]
Busca coincidencias en los caracteres del patrón
> "some text".match(/[otx]/g)
< ["o", "t", "x", "t"]
 [a-z]
Busca coincidencias en el rango de caracteres.
 [a-d] es lo mismo que [abcd].
 [a-z] busca todas los caracteres en minúscula.
 [a-zA-Z0-9_] busca todo los caracteres, números y el guion bajo.
> "Some Text".match(/[a-z]/g)
< ["o", "m", "e", "e", "x", "t"]
> "Some Text".match(/[a-zA-Z]/g)
< ["S", "o", "m", "e", "T", "e", "x", "t"]
 [ˆabc]
Devuelve lo que NO coincida con el patrón.
> "Some Text".match(/[^a-z]/g)
< ["S", " ", "T"]

 a|b
Devuelve a o b (la barra indica OR).
> "Some Text".match(/t|T/g);
< ["T", "t"]
> "Some Text".match(/t|T|Some/g);
< ["Some", "T", "t"] [a-z]
 a(?=b)
Devuelve a solamente si está seguida de b.
> "Some Text".match(/Some(?=Tex)/g);
< null
> "Some Text".match(/Some(?= Tex)/g);
< ["Some"]
 a(?!b)
Devuelve a solamente si NO está seguida de b.
> "Some Text".match(/Some(?! Tex)/g);
< null
> "Some Text".match(/Some(?!Tex)/g);
< ["Some"]


Carácter de escape utilizado para localizar caracteres especiales utilizados en el patrón como literales.
> "R2-D2".match(/[2-3]/g)
< ["2", "2"]
> "R2-D2".match(/[2-3]/g)
< ["2", "-", "2"]
 n
Nueva línea.
 r
Retorno de carro (Para comenzar una nueva línea se usa rn en Windows, n en Unix y r en Mac).
 f
Salto de página.
 t
Tabulación.
 v
Tabulación vertical.

 s
Espacio en blanco o cualquiera de las 5 secuencias de escape de arriba.
> "R2n D2".match(/s/g)
< ["n", " "]
 S
Lo contrario de lo de arriba. Devuelve todo excepto espacios en blanco y las 5 secuencias de escape de antes. Lo mismo
que [ˆs].
> "R2n D2".match(/S/g)
< ["R", "2", "D", "2"]
 w
Cualquier letra, numero o guion bajo. Lo mismo que [A-Za-z0-9_].
> "Some text!".match(/w/g)
< ["S", "o", "m", "e", "t", "e", "x", "t"]
 W
Lo contrario que w.
> "Some text!".match(/W/g)
< [" ", "!"]

 d
Localiza un numero. Lo mismo que [0-9].
"R2-D2 and C-3PO".match(/d/g)
< ["2", "2", "3"]
 D
Lo contrario de d. Localiza caracteres no numéricos. Lo mismo que [ˆ0-9] o [ˆd].
> "R2-D2 and C-3PO".match(/D/g)
< ["R", "-", "D", " ", "a", "n", "d", " ", "C", "-", "P", "O"]
 b
Coincide con un limite de palabra (espacio, puntuación, guion…).
> "R2D2 and C-3PO".match(/[RD]2/g)
< ["R2", "D2"]
> "R2D2 and C-3PO".match(/[RD]2b/g)
< ["D2"]
> "R2-D2 and C-3PO".match(/[RD]2b/g)
< ["R2", "D2"]
 B
Lo contrario que b.
> "R2-D2 and C-3PO".match(/[RD]2B/g)
< null
> "R2D2 and C-3PO".match(/[RD]2B/g)
< ["R2"]

 ^
Representa el principio de la cadena donde se está buscando. Si tenemos el modificador m representa el principio de
cada línea.
> "regularnregularnexpression".match(/r/g);
< ["r", "r", "r", "r", "r"]
> "regularnregularnexpression".match(/^r/g);
< ["r"]
> "regularnregularnexpression".match(/^r/mg);
< ["r", "r"]
 $
Representa el final de la cadena donde se está buscando. Si tenemos el modificador m representa el final de cada línea.
> "regularnregularnexpression".match(/r$/g);
< null
> "regularnregularnexpression".match(/r$/mg);
<4 ["r", "r"]
 .
Representa a cualquier carácter excepto la nueva línea y el retorno de carro.
> "regular".match(/r./g);
< ["re"]
> "regular".match(/r.../g);
< ["regu"]

 *
Hace matching si el patrón precedente ocurre 0 o más veces.
/.*/ devolverá todo incluido nada (cadena vacía).
> "".match(/.*/)
< [""]
> "anything".match(/.*/)
< ["anything"]
> "anything".match(/n.*h/)
< ["nyth"]
 ?
Hace matching si el patrón precedente ocurre 0 o 1 vez.
> "anything".match(/ny?/g)
< ["ny", "n"]
 +
Representa a cualquier carácter excepto la nueva línea y el retorno de carro.
> "anything".match(/ny+/g)
< ["ny"]
> "R2-D2 and C-3PO".match(/[a-z]/gi)
< ["R", "D", "a", "n", "d", "C", "P", "O"]
> "R2-D2 and C-3PO".match(/[a-z]+/gi)
< ["R", "D", "and", "C", "PO"]

 {n}
Hace matching si el patrón precedente ocurre exactamente n veces.
> "regular expression".match(/s/g)
< ["s", "s"]
> "regular expression".match(/s{2}/g)
< ["ss"]
> "regular expression".match(/bw{3}/g)
< ["reg", "exp"]
 {min,max}
Hace matching si el patrón precedente ocurre entre min y max veces.
Se puede omitir max (solo tendrá mínimo) No se puede omitir min.
> "doooooooooodle".match(/o/g)
< ["o", "o", "o", "o", "o", "o", "o", "o", "o", "o"]
> "doooooooooodle".match(/o{2}/g)
< ["oo", "oo", "oo", "oo", "oo"]
> "doooooooooodle".match(/o{2,}/g)
< ["oooooooooo"]
> "doooooooooodle".match(/o{2,6}/g)
< ["oooooo", "oooo"]

 (pattern)
Cuando el patrón está en paréntesis, se captura y se guarda para poder utilizarlo en sustituciones (captura de patrones).
Estas capturas están disponibles en $1, $2,… $9.
> "regular expression".replace(/(r)/g, '$1$1')
< "rregularr exprression"
> "regular expression".replace(/(r)(e)/g, '$2$1')
< "ergular experssion"
 {?:patternx}
Patrón no capturable (no disponible en $1, $2, …).
> "regular expression".replace(/(?:r)(e)/g, '$1$1')
< "eegular expeession"

Ejemplos de aplicación de Expresiones Regulares
Comprobar un e-mail:
 Veamos cómo construir una expresión regular en la que comprobamos que el usuario ha escrito un e-mail en un formulario cuando
se le pide. Lo que realmente comprobamos es que el texto que ha escrito el usuario tiene una cierta estructura que coincide con la
de un e-mail, es decir que tiene que tener una estructura como ésta:
micorreo@servidor.com
 Donde los símbolos arroba "@" y el punto "." son obligatorios. tanto el texto "micorreo" como "servidor" pueden ser variables;
el texto de después del punto ("com") puede ser variable con ciertas restricciones: siempre tiene que ir en minúscula, y además
tener siempre dos o tres caracteres.
 Eso en una expresión regular se traduce en lo siguiente:
/[w]+@{1}[w]+.[a-z]{2,3}/
 En primer lugar comprobamos que hay una cadena de texto; [w]+ detrás de ella debe estar el signo arroba una vez @{1},
después se escribe otra cadena de texto; [w]+, después tiene que haber escrito un punto . y por último el país u organización,
el cual está siempre escrito en letras minúsculas y con dos o tres letras: [a-z]{2,3}.
 Como lo que se trata es de comprobar que el texto escrito coincida completamente con el e-mail, y no que éste esté dentro de una
cadena, deberemos poner los signos ^ $ al principio y final de la expresión regular, por lo que ésta quedará de la siguiente forma:
/^[w]+@{1}[w]+.[a-z]{2,3}$/

Comprobar un e-mail:
 A continuación como utilizar la ER:
 En HTML tenemos el siguiente formulario:
<form action="#" name="formu1">
<p align="center"><input type="text" name="email" size="30" />Escribe un e-mail</p><br/>
<p align="center"><input type="button" onclick="comprueba()" value="Comprobar" /></p>
</form>
 Y el código JavaScript para la comprobación es la siguiente función:
function comprueba(){
tuEmail = document.formu1.email.value
tuEmail = tuEmail.toString()
patron = /^[w]+@{1}[w]+.+[a-z]{2,3}$/
respuesta = patron.test(tuEmail)
alert("resultado: "+respuesta)
}

Comprobar una URL:
 Expresión regular para comprobar páginas web. El nombre de la página tiene que estar completo, es decir con
el "http://" del principio.
patron = /^http[s]?://[w]+([.]+[w]+)+$/;
 Se comprueba que la expresión empieza por "http://" o por "https://", y después que tiene dos o más cadenas de
texto separadas por puntos.
Comprobar una URL:
 En realidad comprobamos que el el nombre empieza por una letra mayúscula, y que los caracteres que le
siguen son minúsculas y letras empleadas en español, y que no son números; en el patrón este esquema
podemos repetirlo con un espacio en medio, con lo cual se pueden poner también nombres compuestos. La
expresión es la siguiente:
/^([A-Z]{1}[a-zñáéíóú]+[s]*)+$/
 En realidad esta expresión tendría un pequeño fallo y es que no validaría nombres que empiecen por vocal si
ésta va acentuada, por ejemplo "Ángel" o Úrsula, no lo validaría, y sí si lo escribimos "Angel" y "Ursula". por
tanto haremos una pequeña corrección y la expresión regular quedará así:
/^([A-ZÁÉÍÓÚ]{1}[a-zñáéíóú]+[s]*)+$/

Comprobar número de teléfono de España:
 Se comprueba que el número tenga 9 cifras, y las cuales pueden ponerse todas seguidas o separadas por
guiones en grupos: el primero de tres, y los demás de dos (admite los formatos "000000000", ó 000-00-00-00,
también el 000-000000, pero no el 000-000-000). La expresión regular es la siguiente:
/^[d]{3}[-]*([d]{2}[-]*){2}[d]{2}$/
 Podemos ajustar más la comprobación si comprobamos también que la primera cifra sea un 9 ó un 6, ya que
todos los teléfonos normales en España empiezan por esas cifras (fijos o móviles). La expresión regular ahora
quedará así:
/^[9|6]{1}([d]{2}[-]*){3}[d]{2}$/

Clase 10 expresiones regulares

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (12)

Ähnlich wie Clase 10 expresiones regulares

Ähnlich wie Clase 10 expresiones regulares (20)

Mehr von José Ricardo Tillero Giménez

Mehr von José Ricardo Tillero Giménez (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Clase 10 expresiones regulares