# Expresiones regulares

## Expresiones regulares en PHP

Las expresiones regulares permiten definir patrones de coincidencia y aplicarlas a cadenas de texto para saber si la cadena (o parte de ella) cumple el patrón e incluso realizar transformaciones de la cadena.

En PHP existen dos sistemas de expresiones regulares:

- Expresiones regulares POSIX extendido:
  - Introducidas en PHP 2.0b7 en 1996, y consideras obsoletas a partir de PHP 5.3.0 (junio de 2009).
  - Siguen la recomendación POSIX 1003.2. POSIX (Portable Operating System Interface) es un conjunto de normas redactadas por el IEEE (The Institute of Electrical and Electronics Engineers) que definen la API de Unix.
  - Las funciones correspondientes empiezan por "ereg".
- Expresiones regulares compatibles con Perl (en inglés, PCRE):
  - Introducidas en PHP 4.2.0 en 2002.
  - Siguen la sintaxis y semánticas del lenguaje de programación Perl 5. PHP 4.2.0 y posteriores incluyen la biblioteca de código libre escrita en C PCRE (Perl Compatible Regular Expressions).
  - Las funciones correpondientes empiezan por "preg".

Dado que las funciones ereg (POSIX extendido) se consideran obsoletas a partir de PHP 5.3.0 (publicado en junio de 2009), se recomienda utilizar únicamente las funciones preg (PCRE).

Volver al principio de la página

## Expresiones regulares compatibles con Perl

### Funciones de expresiones regulares compatibles con Perl

La función de expresiones regulares compatibles con Perl preg_match($patron, $cadena [, $matriz_coincidencias [, $modificadores [, $desplazamiento]]]) compara una cadena con un patrón y devuelve 1 si el patrón ha coincidido o 0 si no. La primera coincidencia encontrada se puede guardar en el argumento opcional $matriz_coincidencias y, si se añade el modificador PREG_OFFSET_CAPTURE, se guarda también en el argumento opcional $matriz_coincidencias la posición de la coincidencia encontrada. El argumento opcional $desplazamiento es un número que permite indicar en qué carácter se inicia la búsqueda.

Los patrones deben empezar y acabar con el carácter / (barra).

    <?php
    $cadena1 = "1234567";
    $cadena2 = "abcdefg";
    $patron = "/^[[:digit:]]+$/";

    if (preg_match($patron, $cadena1)) {
        print "<p>La cadena $cadena1 son sólo números.</p>\n";
    } else {
        print "<p>La cadena $cadena1 no son sólo números.</p>\n";
    }

    if (preg_match($patron, $cadena2)) {
        print "<p>La cadena $cadena2 son sólo números.</p>\n";
    } else {
        print "<p>La cadena $cadena2 no son sólo números.</p>\n";
    }
    ?>
| La cadena 1234567 son sólo números. La cadena abcdefg no son sólo números.

La función preg_match() distingue entre mayúsculas y minúsculas. Para que no distinga, debe añadirse el modificador "i" (sin comillas) al final del patrón. Este modificador no afecta las clases [[::]].

    <?php
    $cadena = "aaAA";
    $patron1 = "/^[a-z]+$/";
    $patron2 = "/^[a-z]+$/i";

    if (preg_match($patron1, $cadena)) {
        print "<p>La cadena $cadena son sólo letras minúsculas.</p>\n";
    } else {
        print "<p>La cadena $cadena no son sólo letras minúsculas.</p>\n";
    }

    if (preg_match($patron2, $cadena)) {
        print "<p>La cadena $cadena son sólo letras minúsculas o mayúsculas.</p>\n";
    } else {
        print "<p>La cadena $cadena no son sólo letras minúsculas o mayúsculas.</p>\n";
    }
    ?>
| La cadena aaAA no son sólo letras minúsculas. La cadena aaAA son sólo letras minúsculas o mayúsculas.

La función de expresiones regulares compatibles con Perl preg_match_all($patron, $cadena [, $matriz_coincidencias [, $modificadores [, $desplazamiento]]]) compara una cadena con un patrón y devuelve el número de coincidencias encontradas. Las coincidencias encontradas se pueden guardar en el argumento opcional $matriz_coincidencias y, si se añade el modificador PREG_OFFSET_CAPTURE, se guardan también en el argumento opcional $matriz_coincidencias la posición de cada coincidencia encontrada. El argumento opcional $desplazamiento es un número que permite indicar en qué carácter se inicia la búsqueda.

    <?php
    $cadena = "Esto es una cadena de prueba";
    $patron = "/de/";
    $encontrado = preg_match_all($patron, $cadena, $coincidencias, PREG_OFFSET_CAPTURE);

    if ($encontrado) {
        print "<pre>"; print_r($coincidencias); print "</pre>\n";
        print "<p>Se han encontrado $encontrado coincidencias.</p>\n";
        foreach ($coincidencias[0] as $coincide) {
            print "<p>Cadena: '$coincide[0]' - Posición: $coincide[1]</p>\n";
        }
    } else {
        print "<p>No se han encontrado coincidencias.</p>\n";
    }
    ?>
    Array
    (
        [0] => Array
            (
                [0] => Array
                    (
                        [0] => de
                        [1] => 14
                    )

                [1] => Array
                    (
                        [0] => de
                        [1] => 19
                    )

            )

    )
Se han encontrado 2 coincidencias. Cadena: 'de' - Posición: 14 Cadena: 'de' - Posición: 19

Faltan las funciones de búsqueda y sustitución

Volver al principio de la página

### Sintaxis de las expresiones regulares compatibles con Perl

Los patrones de las expresiones reguladores compatibles con Perl deben empezar y acabar con un delimitador, que normalmente es la barra (/). En caso de que la barra forme parte del patrón, se puede:

- escribir en el patrón la barra precedida de una contrabarra (\/)
- utilizar otro carácter, que no sea uno de los caracteres especiales, como delimitador (por ejemplo, !, -, etc.)

Los patrones de expresiones regulares compatibles con Perl admiten modificadores, que se incluyen en el patrón, después del limitador final.

Los siguientes patrones son comunes a POSIX extendido y a compatibles con Perl, con una diferencia muy importante que es que las clases de carácter que incluyen caracteres alfabéticos ([[:alnum:]], [[:alpha:]], etc.) en POSIX no incluyen vocales acentuadas, ñ, ç, etc, mientras que en PECR sí.

Patrón | Significado
--- | ---
c | carácter c
. | cualquier carácter
^c | empezar por el carácter c
c$ | terminar por el carácter c
c+ | 1 o más caracteres c
c* | 0 o más caracteres c
c? | 0 o 1 caracteres c
\n | nueva línea
\t | tabulador
\ | escape, para escribir delante de caracteres especiales: ^ . [ ] % ( ) | * ? { } \
(cd) | caracteres c y d agrupados
c|d | carácter c o d
c{n} | n veces el carácter c
c{n,} | n o más caracteres c
c{n,m} | desde n hasta m caracteres c
[a-z] | cualquier letra minúscula
[A-Z] | cualquier letra mayúscula
[0-9] | cualquier dígito
[cde] | cualquiera de los caracteres c, d o e
[c-f] | cualquier letra entre c y f (es decir, c, d, e o f)
[^c] | que no esté el carácter c
[[:alnum:]] | cualquier letra o dígito
[[:alpha:]] | cualquier letra
[[:digit:]] | cualquier dígito
[[:lower:]] | cualquier letra minúscula
[[:punct:]] | cualquier marca de puntuación
[[:space:]] | cualquier espacio en blanco
[[:upper:]] | cualquier letra mayúscula

Los siguientes patrones son exclusivos de compatibles con Perl y no existen en POSIX extendido:

Patrón | Significado
--- | ---
[[:ascii:]] | caracteres con código ASCII de 0 a 127
[[:blank:]] | espacios o tabuladores
[[:cntrl:]] | caracteres de control
[[:graph:]] | caracteres de impresión, salvo el espacio
[[:print:]] | caracteres de impresión, espacio incluido
[[:word:]] | cualquier letra o dígito y el guión bajo
[[:xdigit:]] | cualquier dígito hexadecimal
\w | cualquier letra o dígito y el guión bajo
\W | cualquier cosa que no sea letra o dígito y el guión bajo
\s | cualquier espacio en blanco
\S | cualquier cosa que no sea un espacio en blanco
\d | cualquier dígito
\D | cualquier cosa que no sea un dígito
\b | inicio o final de palabra
\A | comienzo
\Z | final (incluido salto de línea)
\z | final

Volver al principio de la página

## Ejemplos de expresiones regulares

Patrón | Cadena | ¿Cumple? | Comentario
--- | --- | --- | ---
abc | awbwc | No | Los caracteres tienen que estar seguidos.
34abc | Sí | No importa que hayan caracteres antes...
cbabcba | Sí | ... o después.
a2b | g1da2b3 | Sí | Las expresiones regulares detectan letras, números, ...
áb | 3áb4 | Sí | ... incluso acentos, ...
a\$b | 1a$b2 | Sí | ... salvo los caracteres ^ . [ $ ( ) | * + ? { \ € que deben llevar una contrabarra \ antes, además de \n (nueva línea) y \t (tabulador)
[aeiou] | bic | Sí | Los corchetes definen los caracteres admitidos en una posición ...
bcd | No |
[^aeiou] | bic | Sí | ... o no admitidos
aei | No |
[p-t] | avr | Sí | Se pueden definir rangos de caracteres...
av1 | No |
[B-D] | PMD | Sí | ... en minúsculas o mayúsculas ...
AV1 | No |
[0-9] | b9d | Sí | ... o números
bcd | No |
[[:alpha:]] |  |  | Cualquier carácter alfabético
[[:digit:]] |  |  | Cualquier número
[[:alnum:]] |  |  | Cualquier número o carácter alfabéticos
[[:punct:]] |  |  | Cualquier carácter que no sean letras y números (menos el euro)
[[:space:]] |  |  | Cualquier tipo de espacio en blanco
[[:upper:]] |  |  | Cualquier mayúscula
[[:lower:]] |  |  | Cualquier minúscula
^ab | cab | No | Los caracteres tienen que estar al principio
abc | Sí | No importa que hayan caracteres después
ab$ | abc | No | Los caracteres tienen que estar al final
cab | Sí | No importa que hayan caracteres antes
^ab$ | ab | Sí | Tiene que empezar y acabar por ab ...
abab | No | ... y no puede haber nada antes o después
ab?c | abcde | Sí | El carácter b puede estar entre a y c...
acde | Sí | ... o no estar entre a y c ...
adcde | No | ... pero no puede haber otro carácter
a.c | abc | Sí | El . representa cualquier carácter ...
a c | Sí | ... incluso el espacio el blanco, ...
ac | No | pero no la ausencia del carácter
abdc | No | o varios caracteres.
ab+c | abcde | Sí | El carácter b puede estar una vez...
abbbcde | Sí | ... o varias ...
acde | No | ... pero tiene que estar al menos una vez.
ab*c | abcde | Sí | El carácter b puede estar una vez...
abbbcde | Sí | ... o varias ...
acde | Sí | ... o ninguna.
ab{3}c | abbbc | Sí | Las llaves indican el número exacto de repeticiones del carácter, ...
abbbbc | No | ... no puede haber más ...
abbc | No | ... ni menos.
ab{2,4}c | abc | No | Se pueden definir rangos con límite inferior e inferior
abbc | Sí |
abbbc | Sí |
abbbbc | Sí |
abbbbbc | No |
ab{2,}c | abc | No | Se pueden definir rangos sin límite superior
a(bc){2}d | abcbcd | Sí | Los paréntesis definen agrupaciones de caracteres. En este caso bc tiene que aparecer repetido
a(bc)?d | abcd | Sí | Aquí bc puede estar ...
ad | Sí | ... o no estar, ...
abd | No | ... pero no puede aparecer sólo la b, o sólo la c u otro carácter
^a(b|d)c$ | abc | Sí | Entre la a al principio y la c al final puede estar el carácter b...
adc | Sí | ... o el carácter d, ...
abdc | No | ... pero no los dos, ...
ac | No | ... ni ninguno de ellos.
^(ab)|(dc)$ | abc | Sí | Está la pareja ab al principio ...
adc | Sí | ... o dc ...
abdc | Sí | ... o las dos, ...
ac | No | ... pero no ninguna
^(ab)$|^(dc)$ | abc | No | Está la pareja ab, pero sobra la c ...
adc | No | ... o está la pareja dc, pero sobra la a.
dc | Sí | Está una de las dos

Volver al principio de la página

## Expresiones regulares POSIX extendido

Nota: Dado que las funciones ereg (POSIX extendido) se consideran obsoletas a partir de PHP 5.3.0 (publicado en junio de 2009), se recomienda utilizar únicamente las funciones preg (PCRE).

### Funciones de expresiones regulares POSIX extendido

Las funciones básicas de expresiones regulares POSIX extendido para comparar una cadena con un patrón son ereg($patron, $cadena) y eregi($patron, $cadena). La diferencia entre ellas es que ereg() distingue entre mayúsculas y minúsculas y eregi() no. Estas funciones comprueban si la cadena cumple el patrón y devuelven el valor 1 (verdadero) o 0 (falso). Los argumentos de las funciones pueden ser cadenas o variables que contengan cadenas. Si el patrón es la cadena vacía, las funciones devuelven error.

    <?php
    $cadena1 = "1234567";
    $cadena2 = "abcdefg";
    $patron = "^[[:digit:]]+$";

    if (eregi($patron, $cadena1)) {
        print "<p>La cadena $cadena1 son sólo números.</p>\n";
    } else {
        print "<p>La cadena $cadena1 no son sólo números.</p>\n";
    }

    if (eregi($patron, $cadena2)) {
        print "<p>La cadena $cadena2 son sólo números.</p>\n";
    } else {
        print "<p>La cadena $cadena2 no son sólo números.</p>\n";
    }
    ?>
| La cadena 1234567 son sólo números. La cadena abcdefg no son sólo números.

Faltan las funciones de búsqueda y sustitución

Volver al principio de la página

### Sintaxis de las expresiones regulares POSIX extendido

Los patrones de las expresiones reguladores POSIX extendido son un subconjunto que las expresiones regulres compatibles con Perl, que se comentan en el apartado de expresiones regulres compatibles con Perl.

Esta obra está bajo una licencia de Creative Commons.