Como hacer una pagina web y ganar dinero
Creada para aprender lo que mas nesesitas porque la calidad es mejor que la cantidad.
Blog

Expresiones regulares en PHP (parte 2)

Tags: expresiones, regulares, validar, php, metacaracteres, rango, alternancia, manual, agrupadores
publicado el 2010-06-09   leido 3953 leídas

Metacaracteres de rango


Los corchetes [] incluidos en un patrón permiten especificar el rango de caracteres válidos a comparar. Basta que exista cualquiera de ellos para que se de la condición:
<?php

[abc] // El patrón coincide con la cadena si en esta hay
// cualquiera de estos tres carácteres: a, b, c

[a-c] // coincide si existe una letra en el rango ("a", "b" o "c")
c[ao]sa // coincide con casa y con cosa

[^abc] // El patrón coincide con la cadena si en esta NO hay
// ninguno de estos tres carácteres: a, b, c
// Nota que el signo ^ aqui tiene un valor excluyente

c[^ao]sa // Coincide con cesa, cusa, cisa (etc); no coincide
// con casa ni cosa

[0-9] // Coincide con una cadena que contenga cualquier
// número entre el 0 y el 9

[^0-9] // Coincide con una cadena que NO contenga ningun
// número

[A-Z] // Coincide con cualquier carácter alfabetico,
// en mayúsculas. No incluye numeros.

[a-z] // Como el anterior, en minúsculas

?>
Una cuestión a recordar es que las reglas de sintaxis de las expresiones regulares no se aplican igual dentro de los corchetes. Por ejemplo, el metacarácter ^ no sirve aqui de ancla, sino de caracter negador. Tampoco es necesario escapar todos los metacaracteres con la barra invertida. Solo será necesario escapar los siguientes metacaracteres: ] ^ -

El resto de metacaracteres pueden incluirse ya que son considerados -dentro de los corchetes- caracteres normales.

patrón: [aeiou]
el ala aleve del leve abanico

patrón: [^aeiou]
el ala aleve del leve abanico

patrón: [a-d]
el ala aleve del leve abanico

Como estos patrones se usan una y otra vez, hay atajos:
<?php
// atajo equivale a significado

d [0-9] // numeros de 0 a 9
D [^0-9] // el contrario de d

w [0-9A-Za-z] // cualquier numero o letra
W [^0-9A-Za-z] // contrario de w, un carácter que no


// sea letra ni numero

s [ \t\n\r] // espacio en blanco: incluye espacio,

// tabulador, nueva linea o retorno

S [^ \t\n\r] // contrario de \s, cualquier carácter
// que no sea espacio en blanco

// solo regex POSIX
[[:alpha:]] // cualquier carácter alfabético aA - zZ.
[[:digit:]] // Cualquier número (entero) 0 - 9
[[:alnum:]] // Cualquier carácter alfanumérico aA zZ 0 9
[[:space:]] // espacio
?>

Metacaracteres de alternancia y agrupadores

<?php
(xyz) // coincide con la secuencia exacta xyz
x|y // coincide si esta presente x ó y

(Don|Doña) // coincide si precede "Don" o "Doña"
?>
patrón: (al)
el ala aleve del leve abanico

patrón: a(l|b)
el ala aleve del leve abanico

Los paréntesis sirven no solamente para agrupar secuencias de caracteres, sino también para capturar subpatrones que luego pueden ser devueltos al script (backreferences). Hablaremos mas de ello al tratar de las funciones POSIX y PCRE, en las paginas siguientes.

Un ejemplo típico sería una expresion regular cuyo patrón capturase direcciones url validas y con ellas generase links al vuelo:
<?php
$text = "una de las mejores páginas es http://www.paginaweb2.com";
$text = ereg_replace("http://(.*.(com|net|org))",
"1", $text);
print $text;
?>

El anterior ejemplo produciría un enlace usable, donde la url se tomaría de la retro-referencia y la parte visible de la retro-referencia 1 una de las mejores páginas es www.ignside.net

Fijate que en el ejemplo anterior usamos dos grupos de parentesis (anidados), por lo que se producirian dos capturas: La retro-referencia coincide con la coincidencia buscada. Para capturarla no es preciso usar parentesis.

La retro-referencia 1 coincide en este caso con "www.paginaweb2.com" y es capturada por el parentesis (.*.(com|net|org))

La retro-referencia 2 coincide con "net" y se corresponde con el parentesis anidado (com|net|org)

Ten en cuenta que esta caracteristica de capturar ocurrencias y tenerlas disponibles para retroreferencias consume recursos del sistema. Si quieres usar parentesis en tus expresiones regulares, pero sabes de antemano que no vas a reusar las ocurrencias, y puedes prescindir de la captura, coloca despues del primer parentesis ?:
<?php
$text = ereg_replace("http://(.*.(?:com|net|org))","<a href="">1</a>", $text);
?>
Al escribir (?:com|net|org) el subpatron entre parentesis sigue agrupado, pero la coincidencia ya no es capturada.

Como nota final sobre el tema, PHP puede capturar hasta 99 subpatrones a efectos de retro-referencia, o hasta 200 (en total) si buscamos subpatrones sin capturarlos.

Ejemplo con validacion de correo


Hemos dicho que las expresiones regulares son uno de los instrumentos mas útiles en cualquier lenguaje de programación. ¿Para que podemos usarlas?. Uno de sus usos mas típicos es el de validar entradas de datos que los visitantes de una página puedan mandarnos a través de formularios html.

El ejemplo mas corriente es el de una dirección email. Imaginemos que queremos filtrar las direcciones introducidas por los visitantes, para evitar introducir en la base de datos la típica dirección basura ghghghghghghg. Todos sabemos la estructura de una dirección email, formada por la cadena nombreusuario, el signo @ y la cadena nombredominio. Tambien sabemos que nombredominio esta formado por dos subcadenas, 'nombredomino', un '.' y un sufijo 'com', 'net', 'es' o similar.

Por tanto la solución a nuestro problema es idear una expresión regular que identifique una dirección email valida típica, y confrontarla con la cadena (dirección email) pasada por el visitante

Por ejemplo:
<?php
^[^@ ]+@[^@ ]+.[^@ .]+$
?>
Vamos a diseccionar nuestra expresión regular:
<?php
^ // queremos decir que el primer carácter que buscamos
// debe estar al principio de la cadena a comparar.

[^@ ] // ese primer signo no debe ser ni el signo @
// ni un espacio

+ // y se repite una o mas veces
@ // luego buscamos el signo @

[^@ ]+ // Seguido de otro signo que no es un @ ni un
// espacio y se repite una o mas veces

. // Seguido de un .

[^@ .] // Seguido de un carácter que no sea ni @,
// ni espacio ni punto

+$ // Que se repite una o mas veces y el último esta
// al final de la cadena
?>
Y para comprobarlo en la práctica, usamos una de las funciones de php relacionadas con las expresiones regulares:ereg().

Acudiendo al manual php, podemos averiguar que esta función tiene la siguiente sintaxis:
ereg (string pattern, string string)
Busca en string las coincidencias con la expresión regular pattern. La búsqueda diferencia entre mayúsculas y minúsculas.

Devuelve un valor verdadero si se encontró alguna coincidencia, o falso in no se encontraron coincidencias u ocurrió algún error. Podríamos usar esta funcion para un validador email con algo asi como:
<?php

// establecemos una secuencia condicional: si la variable $op no existe y
// es igual a "ds", se muestra un formulario

if ($op != "ds") { ?>
<form>
<input type=hidden name="op" value="ds">
<strong>Tu email:</strong><br />
<input type=text name="email" value="" size="25" />
<input type=submit name="submit" value="Enviar" />
</form>

<?php
}

// Si $op existe y es igual a "ds"m, se ejecuta la función ereg buscando
// nuestra cadena dentro del patrón $email que es la direccion enviada por
// el usuario desde el formulario anterior

else if ($op == "ds")
{
if (ereg("^[^@ ]+@[^@ ]+.[^@ .]+$", $email ) )
{
print "<BR>Esta dirección es correcta: $email"; }
else {echo "$email no es una dirección valida";}
}

?>
No hace falta advertir que se trata de un ejemplo muy elemental, que dará por válida cualquier dirección email que tenga una mínima apariencia de normalidad (por ejemplo, daria por valida '[email protected]')

Para tener a mano ...
Una breve referencia de los meta carácteres y su significado, tomada de un comentario del manual de php.net.
<?php

^ // Comienzo de la zadena
$ // Final de la cadena

n* // Cero o mas "n" (donde n es el carácter precedente)
n+ // Uno o mas "n"
n? // Un posible "n"

n{2} // Exactamente dos "n"
n{2,} // Al menos dos o mas "n"
n{2,4} // De dos a cuatro "n"

() // Parentesis para agrupar expresiones
(n|a) // o "n" o "a"

. // Cualquier carácter

[1-6] // un número entre 1 y 6
[c-h] // una letra en minuscula entre c y h
[D-M] // una letra en mayúscula entre D y M
[^a-z] // no hay letras en minuscula de a hasta z
[_a-zA-Z] // un guion bajo o cualquier letra del alfabeto

^.{2}[a-z]{1,2}_?[0-9]*([1-6]|[a-f])[^1-9]{2}a+$

/* Una cadena que comienza por dos carácteres cualquiera
Seguidos por una o dos letras (en minuscula)
Seguidos por un guion _ bajo opcional
Seguidos por cero o mas números
Seguidos por un numero del 1 al 6 o una letra de la -a- a la -f-
Seguidos por dos carácteres que no son números del 1 al 9
Seguidos de uno o mas carácteres al final de la cadena
Tomado de una anotacion al manual de php.net, de mholdgate -
wakefield dot co dot uk */

?>

Te gust?

Expresiones regulares en PHP (parte 1)

Funciones PHP para expresiones regulares

 
Información
Christian Valencia publicado porPor: Ero-Fierce

Suscribete
Recibe los ultimos articulos en tu email:

Indice.
Php y MySQL

Ultimos Artculos
Hacer SEO en el 2016 - 2017
Habilitar sonido al pulsar las teclas Bloq Mayús, Bloq Num y Bloq Des
10 trucos viejos, seo que nunca te dijeron
15 Efectos carrusel como pagina de libro animado con ejemplos
No se pudo generar una instancia de usuario de SQL Server debido a un error (.mdf
Solucion Error 26. No se encontró el servidor o éste no estaba accesible. Sql

Todos los tutoriales

Hacer una web paso a paso Php y MySQL Javascript
Posicionamiento Web SEO Cómo ganar dinero con tu web Herramientas y Programas Web
Maquetación con CSS Hosting y Dominios MySQL y Phpmyadmin
Ajax UML: Analisis y Diseño Programacion Orientada a Objetos
Java
 
Copyright © 2009 - pagina Web 2 - Todos los derechos Reservados