Entendido.

Este sitio utiliza cookies para analizar la navegación. Si continúa navegando se entiende que acepta su uso. Ver más detalles.";

Aprende Web

Crea y diseña tus sitios en la Web.

Manual de Javascript

Javascript: lenguaje interactivo para dinamizar la web.

Y ahora tambien aprende a programar en C++ con Aprende Web C++

Manuales para la creación y diseño de páginas web

Básicos					Avanzados					Practicas
Inicio	HTML	CSS	Complementos	Gestores de Contenido	Javascript	PHP básico	Nuevas Tendencias	Programación	Librerías	Mi primera web	Prácticas Web

RSS. Suscribir canal.



15. Resumen (X)

15.10 Expresiones regulares

Definición

Las expresiones regulares son objetos que sirven para comprobar si un determinado elemento se ajusta a unas determinadas características.

En javascript se utilizan para saber si una cadena de texto se ajusta a un determinado patrón. La expresión regular marca el patrón a seguir, y luego mediante los métodos y propiedades comprobamos si la cadena se ajusta a ese patrón y realizamos acciones como buscar, remplazar, etc.

Las expresiones regulares utilizan un lenguaje propio.

No son exclusivas de javascript, otros lenguajes de programación como Java o PHP también las usan.

Crear un objeto de la clase RegExp

Las expresiones regulares tienen una sintaxis propia. Toda expresión regular empieza y acaba por una barra inclinada: / (código) /. Esto las distingue el resto de variables, por lo que podemos crearlas al definir la variable:

var exp = /texto/

También podemos crearlas mediante el método general para crear objetos.

var exp = new RegExp(texto)

En este caso no debemos poner el código entre barras inclinadas.

Comprobar patrones

Comprobar un texto

El caso más simple es comprobar si una determinada cadena está contenida en otra. En la expresión indicamos la cadena a comprobar.

exp = /martes/

Podemos comprobar ahora si un determinado texto contiene la palabra "martes". Aunque veremos más adelante los métodos, utilizamos de momento el método test().

resultado = exp.test(texto)

En el ejemplo exp es la expresión regular, y texto es la cadena de texto. El método devuelve un valor booleano: true si hay coincidencia, o false si no la hay.

Comprobar grupos de caracteres

Si lo que se quiere comprobar es que la cadena contenga alguno de los caracteres indicados en un grupo éstos se pondrán entre corchetes:

exp = /[0123456789]/;

Aquí se buscará si el texto contiene algún número.

Cuando los elementos de dentro del corchete forman grupos homogéneos, podemos poner la primera y la última y entre medio un guión:

exp = /[a-z]/;

Aquí se buscará si el texto contiene alguna de las letras del alfabeto.

Para incluir el guión en la expresión anterior podemos ponerlo al final, o también al principio, pero con una barra inclinada inversa que indica que es un carácter de escape.

exp = /[a-z-]/;

exp = /[\-a-z]/;

Estas dos RegExp buscan si el texto contiene cualquier letra del abecedario o un guión.

Los caracteres de escape tienen la misma función que en los textos, y sirven para incluir caracteres que en el código de las RegExp se usan también para otras cosas.

Clases de caracteres

Para los casos más habituales hay unos caracteres especiales que indican si la cadena contiene un determinado tipo de caracteres:

• /\w/ : Contiene caracteres alfanuméricos.
• /\W/ : Devuelve false si sólo contiene caracteres alfanuméricos.
• /\d/ : Contiene digitos 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.

Tenemos también la expresión /./ que indica "cualquier caracter" y que se utiliza para saber si una cadena no está vacía.

Los signos ^ y $ al principio y final de la RegExp, indican que ésta debe coincidir completamente con la cadena de texto (no sólo una parte).

Cuantificadores

Además del patrón o texto a buscar, hay unos signos que ponemos detrás y que indican las veces que debe aparecer el texto para ajustarse al patrón. Son los cuantificadores:

• /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 patón debe aparecer cero o una vez.
• /a{3}/ : El patón debe aparecer exactamente tres veces (en lugar del 3 puede ser cualquier otro número).
• /a{3,8}/ : El patón debe aparecer entre 3 y 8 veces (ambos inclusive).

Modificadores

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.

Métodos de RegExp.

La clase RegExp tiene varios métodos. Además también podemos usar algunos métodos de la clase String con las expresiones regulares.

Métodos de RegExp

Nombre	Ejemplo y explicación
test()	buscar = exp.test(texto)
	Devuelve un valor booleano que indica si la expresión (exp) está contenida o no en la cadena(texto).
compile()	compilado = exp.compile(exp);
	Convierte la expresió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 RegExp en bucles.
exec()	buscar = expresion.exec(texto);
	Busca la expresion en el texto, y devuelve el primer texto que concuerda con la expresión buscada. Si no encuentra ninguna coincidencia, entonces devuleve null.

El método exec tiene además dos propiedades: .index, que nos indica la posición en la que se encuentra la cadena buscada; y .input, que devuelve la cadena completa en la que estamos realizando la búsqueda.

Métodos de String para RegExp.

Los siguientes métodos de la clase String pueden usarse para trabajar con expresiones regulares. En ellos la RegExp se pasa siempre como argumento.

Métodos de String para RegExp

Nombre	Ejemplo y explicación
search()	buscar = texto.search(expresion)
	Busca la expresión en el texto. si la encuentra devuelve un número indicando la posición del primer carácter, empezando a contar desde 0, si no la encuentra devuelve -1.
split()	miArray = texto.split(expresion);
	Transforma el texto en un array, la expresion indica cual es el delimitador que separa los elementos del array.
replace()	cadena = texto.replace(expresion,nuevo_texto)
	Devuelve el texto original, en la que se ha remplazado las coincidencias encontradas por la expresion, por un nuevo_texto pasado como segundo argumento.

Propiedades de RegExp

Las propiedades del objeto RegExp se usan directamente sobre el objeto RegExp, por tanto se escribirán de la forma: RegExp.propiedad

Son de sólo lectura, sin embargo se actualizan automáticamente cada vez que se emplea un método, ya sea de RegExp o de String; por lo que el valor obtenido corresponderá al último método empleado.

Propiedades de RegExp

Propiedad	Ejemplo y explicación
$1 ... $9	indice = RegExp.$1
	Índices que contienen las partes agrupadas con paréntesis en el patrón de búsqueda.
input	texto = RegExp.input
	Devuelve la última cadena que se ha explorado mediante un método.
lastMatch	texto = RegExp.lastMatch
	Devuelve la última coincidencia encontrada.
multiline	comprobar = RegExp.multiline
	Devuelve una variable booleana que indica si la cadena explorada incluye saltos de línea.
lastParent	texto = RegExp.lastParent
	Devuelve la última coincidencia encontrada con un patrón entre paréntesis.
leftContext	texto = RegExp.leftContext
	En la última cadena explorada devuelve desde el principio hasta la última coincidencia hallada.
rightContext	texto = RegExp.rightContext
	En la última cadena explorada devuelve desde la última coincidencia hasta el final.

Expresiones Regulares habituales

Los ejemplos vistos hasta ahora tienen expresiones regulares sencillas. Sin embargo la cosa puede complicarse cuando tratamos de hacer expresiones regulares que se ajusten a patrones más complejos, para comprobar que algunas cadenas están escritas correctamente.

En estos casos lo más sencillo es recurrir a una lista con las RegExp más habituales. Veamos algunas de ellas:

• E-mail : /^[\w]+@{1}[\w]+\.[a-z]{2,3}$/
• Página web : /^http[s]?:\/\/[\w]+([\.]+[\w]+)+$/
• Nombre propio de persona : /^([A-ZÁÉÍÓÚ]{1}[a-zñáéíóú]+[\s]*)+$/
• Núm. teléfono de España : /^[9|6]{1}([\d]{2}[-]*){3}[\d]{2}$/

---

En la siguiente página veremos cómo guardar datos en unos elementos llamados cookies .

Cookies.