perlre.pod

NAME

perlre - Expresiones regulares en Perl

DESCRIPCIÓN

Esta página describe la sintaxis de las expresiones regulares en Perl.

Si no ha utilizado expresiones regulares antes, una introducción rápida está disponible en perlrequick, y un cursillo de introducción mayor está disponible en perlretut.

Para tener una referencia sobre cómo las expresiones regulares se utilizan en operaciones de coincidencia, además de varios ejemplos de lo mismo, vea las discusiones sobre m// s///, qr// y ?? en "Operadores Regexp Entrecomillados" in perlop.

Modificadores

Las operaciones de coincidencia pueden tener varios modificadores. Los modificadores que se relacionan con la interpretación del interior de la expresión regular se enumeran a continuación. Modificadores que alteran la forma en que una expresión regular es utilizada por Perl se detallan en "Operadores Regexp Entrecomillados" in perlop y "Detalles sangrientos del análisis de las construcciones entrecomilladas" in perlop.

m

Trata a la cadena como un conjunto de múltiples líneas. Es decir, cambia el significado de "^" y "$" de coincidir con el inicio y el final de la cadena a coincidir con el inicio y el final de cualquier línea en cualquier lugar dentro de la cadena.

s

Trata a la cadena como una sola línea. Es decir, cambia "." para que coincida con cualquier carácter, incluso el de nueva línea, que normalmente no coincidiría.

Usados juntos, como /ms, permiten que "." coincida con cualquier carácter, mientras que siguen permitiendo que "^" y "$" coincidan, respectivamente, con el después y el antes de los caracteres nueva línea dentro de la cadena.

i

Hace coincidencia de patrones sin importar si son mayúsculas o minúsculas.

Si están activas las reglas de coincidencia local, el mapeo de caja se toma de la configuración local actual para los puntos de código menores que 255, y de las reglas Unicode para los puntos de código superiores. Sin embargo, las coincidencias que podrían cruzar los márgenes de las reglas Unicode/no-Unicode (ordinales 255/256) no tendrán éxito. Vea perllocale.

Hay una serie de caracteres Unicode que coinciden con múltiples caracteres con /i activado. Por ejemplo, LATIN SMALL LIGATURE FI debe coincidir con la secuencia fi. Perl no es capaz, actualmente, de hacer esto cuando los grupos de caracteres están en el patrón y se dividen en agrupaciones, o cuando uno o más de ellos se han cuantificado. Por lo tanto

"\N{LATIN SMALL LIGATURE FI}" =~ /fi/i;          # Coincide
"\N{LATIN SMALL LIGATURE FI}" =~ /[fi][fi]/i;    # ¡No coincide!
"\N{LATIN SMALL LIGATURE FI}" =~ /fi*/i;         # ¡No coincide!

# Lo siguiente no coincide, y no está claro qué contendrá $1 y $2
# ¡Incluso si ya lo ha intentado!
"\N{LATIN SMALL LIGATURE FI}" =~ /(f)(i)/i;      # ¡No coincide!

Perl no coincide con caracteres múltiples en una clase invertida de caracteres entre corchetes, lo cual podría ser muy confuso. Vea "Negación" in perlrecharclass.

Otro error consiste en clases de caracteres que coinciden tanto con una secuencia de caracteres múltiples y con una sub-cadena inicial de esa secuencia. Por ejemplo,

/[s\xDF]/i

debe coincidir tanto con una simple y una doble "s", ya que \xDF (en plataformas ASCII) coincide con "ss". Sin embargo, este error ([perl #89774]) hace que sólo coincida con una "s", incluso si falla la coincidencia final más grande, y tenga éxito la coincidencia con la doble "ss".

Además, el sistema de coincidencias de Perl no se ajusta plenamente a las recomendaciones actuales de Unicode con /i, que piden que la coincidencia se haga en el NFD (Normalization Form Decomposed) del texto. Sin embargo, Unicode se encuentra en el proceso de reconsideraciones y revisando sus recomendaciones.

x

Amplía la legibilidad del patrón, al permitir espacios en blanco y comentarios. Detalles en "/x"

p

Preserva la cadena coincidente, de tal manero que ${^PREMATCH}, ${^MATCH} y ${^POSTMATCH} están disponibles para su uso después de la comprobación.

g y c

Coincidencia global, y almacenar la posición actual después de una coincidencia fallida. A diferencia de i, m, s y x, estos dos indicadores afectan a la forma en que se utiliza la expresión regular en lugar de la propia expresión regular. Vea "Usando expresiones regulares en Perl" in perlretut para una explicación más detallada de los modificadores g y c.

a, d, l y u

Estos modificadores, todos nuevos en 5,14, afectan a la semántica del conjunto de caracteres (Unicode, etc.) son descritos más abajo en "Modificadores del conjunto de caracteres".

Los modificadores de expresiones regulares son normalmente descritos en la documentación como, por ejemplo, "el modificador /x", incluso aunque el delimitador en cuestión podría no ser en realidad una barra diagonal. Estos modificadores /imsxadlup también pueden ser incorporados dentro de la propia expresión regular usando la construcción (?...); vea "Patrones extendidos" más abajo.

/x

/x indica al analizador de expresiones regulares que ignore la mayoría de los espacios en blanco que no estén escapados con barras diagonales inversas o que no estén dentro de una clase de caracteres. Puede usar esto para romper la expresión regular en partes (un poco) más legibles. El carácter # también es considerado un metacarácter que antecede a un comentario, al igual que en el código normal de Perl. Esto también significa que si quiere un espacio en blanco real o caracteres # en el patrón (excepto en una clase de caracteres, donde no les afecta /x), entonces tendrá que escaparlos (usando barras diagonales inversas o \Q...\E) o codificarlas usando octal, hex, o secuencias de escape \N{}. En conjunto, estas características hacen un gran labor para conseguir que las expresiones regulares de Perl sean más legibles. Tenga en cuenta que hay que tener cuidado de no incluir el delimitador de patrón en el comentario: perl no tiene manera de saber que no tiene intención de cerrar el patrón tan pronto. Vea el código en C para eliminar comentarios en perlop. También tenga en cuenta que cualquier cosa dentro de un \Q...\E queda afectado por el /x . Y tenga en cuenta que /x no afecta a la interpretación del espacio en el interior de la construcción de un multicarácter. Por ejemplo, en \x{...}, independientemente del modificador /x, no puede tener espacios. Lo mismo para los cuantificadores como {3} o {5,}. Del mismo modo, (?:...) no puede tener ningún espacio entre ? y :, pero puede tenerlos entre ( y ?. Para una construcción como esta, con cualquier tipo de delimitadores, los espacios permitidos no se verán afectados por /x, y depende de la propia construcción. Por ejemplo, \x{...} no puede tener espacios porque los números hexadecimales no contienen espacios. Pero, las propiedades Unicode pueden tener espacios, por lo que en \p{...} puede haber espacios que sigan las reglas Unicode, para lo cual vea "Propiedades accesibles a través de \p{} y \P{}" in perluniprops.pod.

Modificadores del conjunto de caracteres

/d, /u, /a y /l, disponibles a partir de 5.14, son llamados modificadores del conjunto de caracteres; afectan a la semántica del conjunto de caracteres utilizado por la expresión regular.

Los modificadores /d, /u y /l no serán, probablemente, de gran utilidad para usted, y por lo tanto no necesita preocuparse mucho acerca de ellos. Existen para uso interno de Perl, de modo que las estructuras complejas de datos de expresiones regulares pueden ser serializadas automáticamente y más tarde reconstituidas exactamente, incluyendo todos sus matices. Pero, ya que Perl no puede guardar un secreto, y puede haber casos excepcionales en los que sean útiles, se describen aquí.

El modificador /a, por otro lado, puede ser útil. Su propósito es permitir que el código que trabaje principalmente con datos ASCII no tengan que preocuparse de Unicode.

Brevemente, /l establece el conjunto de caracteres a la indicada por la configuración local que esté en activo en el momento de la ejecución de la coincidencia de patrón.

/u establece el juego de caracteres a Unicode.

/a también establece el conjunto de caracteres a Unicode, PERO añade una serie de restricciones para una coincidencia segura con ASCII.

/d es el antiguo, problemático, pre-5.14 comportamiento del conjunto de caracteres por defecto. Su única misión es forzar el comportamiento anterior.

En un momento determinado, solo uno de estos modificadores está en vigor. Su existencia permite a Perl mantener el comportamiento originalmente compilado de una expresión regular, independientemente de las normas que estén en vigor cuando es efectivamente ejecutada. Y si es interpolada en una más grande, las normas originales siguen siendo aplicables a ella, y solo a ella.

Los modificadores /l y /u se seleccionan automáticamente para las expresiones regulares compiladas dentro del ámbito de diferentes pragmas, y se recomienda que, en general, se utilicen los pragmas en lugar de especificar de forma explícita estos modificadores. Por una parte, los modificadores afectan sólo a la coincidencia de patrones, y no se extienden ni siquiera a las sustituciones, mientras que utilizando los pragmas dan resultados consistentes para todas las operaciones apropiadas dentro de sus ámbitos de aplicación. Por ejemplo,

s/foo/\Ubar/il

coincidirá con "foo" usando las reglas de la configuración regional para una coincidencia independiente de las mayúsculas y minúsculas, pero el /l no afecta a cómo funciona \U. Lo más probable es que desee que los dos usen las reglas de la configuración regional. Para ello, compile la expresión regular dentro del ámbito de use locale. De manera implícita, esto añade /l y aplica las reglas de configuración regional para \U. La lección es usar use locale y no poner explícitamente /l.

De manera similar, sería mejor utilizar use feature 'unicode_strings' en lugar de,

s/foo/\Lbar/iu

para que se apliquen reglas Unicode, igual a como \L también usaría reglas Unicode en un primer caso (pero no necesariamente en el último).

Siguen más detalles sobre cada uno de los modificadores. Lo más probable es que no necesite saber estos detalles para /l, /u y /d, y puede saltar directamente a /a.

/l

significa que hay que usar las reglas regionales en vigor (vea perllocale) en la coincidencia de patrones. Por ejemplo, \w coincidirá con los caracteres "palabra" de esa configuración regional, y la insensibilidad al tamaño de caja "/i" coincidirá de acuerdo a las normas regionales de plegado de caja. La regla regional utilizada será la vigente en el momento de la ejecución de la coincidencia de patrón. Ésta puede no ser la misma que la configuración regional en tiempo de compilación, y pueden diferir de una coincidencia a otra, si hay una llamada a la función setlocale().

Perl sólo soporta reglas regionales de bytes simples. Esto significa que los puntos de código por encima de 255 se consideran como Unicode sin importar qué configuración regional esté en vigor. Según las normas Unicode, hay unos pocos casos que cruzan el límite 255/256 de las coincidencias de mayúsculas y minúsculas. Éstos no se permiten bajo /l. Por ejemplo, 0xFF (en plataformas ASCII) no coincide con el carácter 0x178, LATIN CAPITAL LETTER Y WITH DIAERESIS -sin tener en cuenta el tamaño de caja-, porque 0xFF quizás no sea LATIN SMALL LETTER Y WITH DIAERESIS en la configuración regional actual, y Perl no tiene manera de saber si ese carácter incluso existe en la configuración regional, y mucho menos qué código de carácter es.

Este modificador se puede especificar que sea el predeterminado por use locale, pero vea "¿Qué modificador de conjunto de caracteres está en vigor?".

/u

significa que use las reglas Unicode en la coincidencia de patrones. En las plataformas ASCII, esto significa que los códigos de carácter entre 128 y 255 se toman como si fueran Latin-1 (ISO-8859-1) (que son los mismos que en Unicode). (De otra forma Perl considera sus significados como indefinidos). Así, con este modificador, la plataforma ASCII se convierte de forma efectiva en una plataforma Unicode; y por lo tanto, por ejemplo, \w coincidirá con cualquiera de los más de 100 000 caracteres en Unicode que pueden formar parte de una "palabra".

A diferencia de la mayoría de las configuraciones regionales, que son específicas de una pareja idioma/país, Unicode clasifica todos los caracteres que son letras, en cualquier parte del mundo, como \w. Por ejemplo, tu configuración regional no pensaría que LATIN SMALL LETTER ETH es una letra (a menos que usted hable Islandés), pero Unicode sí. Del mismo modo, todos los caracteres que son dígitos decimales en algún lugar del mundo coincidirán con \d, lo que significa que son cientos, no diez, de posibles coincidencias. Y algunas de esas cifras se parecen a algunos de los 10 dígitos ASCII, pero significan un número diferente, por lo que un ser humano podría pensar en un número con una cantidad diferente de lo que realmente es. Por ejemplo, BENGALI DIGIT FOUR (U+09EA) se parece mucho a una ASCII DIGIT EIGHT (U+0038). Y, \d+, puede coincidir con cadenas de dígitos que son una mezcla de diferentes sistemas de escritura, creando un problema de seguridad. Se puede utilizar "num()" in Unicode::UCD para resolver este problema. O el modificador /a puede ser usado para forzar \d para que coincida con sólo los ASCII 0 al 9.

Además, con este modificador, la coincidencia insensible al tamaño de caja funciona en todo el conjunto de caracteres Unicode. El KELVIN SIGN, por ejemplo, coincide con las letras "k" y "K", y LATIN SMALL LIGATURE FF coincide con la secuencia "ff", que, si no está preparado, puede hacer que se vea como una constante hexadecimal, presentando otro problema potencial de seguridad. Vea http://unicode.org/reports/tr36 para una discusión detallada de los problemas de seguridad en Unicode.

En las plataformas EBCDIC que maneja Perl, el conjunto de caracteres nativo, es equivalente a Latin-1. Así, este modificador sólo cambia el comportamiento cuando el modificador "/i" también es especificado, y resulta que sólo afecta a dos caracteres, dándoles una semántica completa de Unicode: el MICRO SIGN coincidirá con las letras griegas mayúscula y minúscula de MU, de lo contrario, no; y la LATIN CAPITAL LETTER SHARP S coincidirá con cualquiera de SS, Ss, sS, y ss; de lo contrario, no.

Se puede especificar este modificador para que sea el predeterminado por medio de use feature 'unicode_strings', use locale ':not_characters' o use 5.012 (o superior), pero vea "¿Qué modificador de conjunto de caracteres está en vigor?".

/d

Este modificador significa usar las reglas nativas "Predeterminadas" (por defecto) de la plataforma, excepto cuando hay razones para utilizar las reglas Unicode, de la siguiente manera:

1. la cadena destino está codificado en UTF-8; o

2. el patrón está codificado en UTF-8; o

3. el patrón menciona explícitamente un punto de código que está por encima de 255 (por ejemplo \x{100}); o

4. el patrón utiliza un nombre Unicode (\N{...}); o

5. el patrón utiliza una propiedad Unicode (\p{...})

Otra regla mnemotécnica para este modificador es "Depende", porque las reglas utilizadas realmente dependen de varias cosas, y como resultado se puede obtener resultados inesperados. Vea "El "Bug Unicode"" in perlunicode. El "Bug Unicode" se ha convertido en algo más bien infame, que conduce a otro nombre (imprimible) para este modificador, "Dodgy" (poco fiable).

En plataformas ASCII, las reglas nativas son ASCII, y en plataformas EBCDIC (por lo menos las que Perl maneja), son Latin-1.

Aquí hay algunos ejemplos de cómo funciona esto en una plataforma ASCII:

$str =  "\xDF";      # $str no está en formato UTF-8.
$str =~ /^\w/;       # No coincide, porque $str no está en formato UTF-8.
$str .= "\x{0e0b}";  # Ahora, $str está en formato UTF-8.
$str =~ /^\w/;       # ¡Coincide! $str está ahora en formato UTF-8.
chop $str;
$str =~ /^\w/;       # ¡Todavía coincide! $str sigue estando en formato UTF-8.

Este modificador se selecciona de forma automática, de forma predeterminada, cuando ninguno de los otros lo están, por lo que también es conocido como "por Defecto" (predeterminado).

A causa de los comportamientos inesperados asociados con este modificador, es probable que sólo deba utilizarlo para mantener la compatibilidad hacia atrás de comportamientos extraños.

/a (y /aa)

A este modificador se le conoce como el ASCII-restrictivo (o ASCII-seguro). Este modificador, a diferencia de los otros, puede ser duplicado para aumentar su efecto.

Cuando aparece solo una vez, hace que las secuencias de \d, \s, \w y las clases de caracteres Posix coincidan sólo en el rango del ASCII. De este modo, vuelven a sus significados pre-5.6, pre-Unicode. Bajo /a, \d siempre representa exactamente a los dígitos "0" a "9"; \s representa a los cinco caracteres [ \f\n\r\t]; \w representa a los 63 caracteres [A-Za-z0-9_]; y, del mismo modo, todas las clases Posix, como [[:print:]] solo coinciden con el rango apropiado de caracteres ASCII.

Este modificador es útil para personas que usan Unicode a propósito, y para quienes no deseen cargar con sus complejidades y problemas de seguridad.

Con /a, se puede escribir \d con la confianza de que sólo coincidirá con caracteres ASCII, y si fuera necesario que coincida más allá del ASCII, puede usar \p{Digit}, o \p{Word} en lugar de \w. Hay construcciones similares a \p{...} que pueden coincidir, más allá del ASCII, tanto con espacio en blanco (vea "Espacio en blanco" in perlrecharclass), y clases Posix (vea "Clases de caracteres POSIX" in perlrecharclass). Por lo tanto, este modificador no significa que no pueda utilizar Unicode, sino que para obtener coincidencia con Unicode debe utilizar, explícitamente, una construcción (\p{}, \P{}) que indica usar Unicode.

Como era de esperar, este modificador hace que, por ejemplo, \D quiera decir lo mismo que [^0-9]; de hecho, todos los caracteres no ASCII coinciden con \D, \S y \W. \b sigue coincidiendo en el límite entre \w y \W, usando las definiciones /a de ellos (lo mismo para \B).

De lo contrario, /a se comporta como el modificador /u, en que la comparación que no distingue entre mayúsculas y minúsculas utiliza semántica Unicode; por ejemplo, "k" coincidirá con el Unicode \N{KELVIN SIGN} bajo /i, y los puntos de código en el rango de Latin1, por encima de ASCII tendrá reglas Unicode cuando se trata de coincidencias que no distingan entre mayúsculas y minúsculas.

Para prohibir coincidencias ASCII/no-ASCII (como "k" con \N{KELVIN SIGN}), especifique la "a" dos veces, por ejemplo /aai o /aia. (La primera ocurrencia de "a" restringe \d, etc., y la segunda añade restricciones a /i). Sin embargo, tenga en cuenta que los códigos de caracteres fuera del rango ASCII usará las reglas Unicode para la coincidencia /i, por lo que el modificador no restringe realmente las cosas a sólo ASCII; sino que sólo prohíbe la mezcla de los ASCII y los no ASCII.

Resumiendo, este modificador proporciona protección para las aplicaciones que no quieran estar expuestas a todo el Unicode. Especificándolo dos veces ofrece una protección adicional.

Este modificador se puede especificar como que sea el predeterminado por medio de use re '/a' o use re '/aa'. Si lo hace así puede, realmente, tener la oportunidad de utilizar el modificador /u de forma explícita si hay algunas expresiones regulares en el que quiere que se apliquen todas las reglas Unicode (pero incluso aquí, es mejor si todo estuviera bajo la característica "unicode_strings", junto con use re '/aa'). Vea también "¿Qué modificador de conjunto de caracteres está en vigor?".

¿Qué modificador de conjunto de caracteres está en vigor?

Cuáles de estos modificares están activos en un determinado punto de una expresión regular depende de un conjunto muy complejo de interacciones. Estos han sido diseñados de manera que en general, no tiene que preocuparse por ello, pero esta sección da los detalles más sangrientos. Como se ha explicado en "Patrones extendidos", es posible especificar explícitamente los modificadores que se aplican sólo a unas partes de una expresión regular. La parte más interior siempre tiene prioridad sobre cualquier otra externa, y la que se aplica a toda la expresión tiene prioridad sobre cualquiera de los ajustes por defecto que se describen en el resto de esta sección.

El pragma use re '/foo' se puede utilizar para establecer los modificadores por defecto (incluyendo éstos) para las expresiones regulares compiladas dentro de su ámbito. Este pragma tiene precedencia sobre otros pragmas, listados a continuación, que cambian los valores predeterminados.

De lo contrario, use locale establece el modificador por defecto a /l; y use feature 'unicode_strings o use 5.012 (o superior) establece el valor por defecto a /u cuando no estén en el mismo ámbito, tanto si está en efecto use locale o use bytes. (use locale ':not_characters' también establece como predeterminado a /u, anulando cualquier otro use locale). A diferencia de los mecanismos mencionados anteriormente, estos afectan a las operaciones de coincidencia de las expresiones regulares, y así obtener resultados más consistentes con otros operadores, incluyendo el uso de \U, \l, etc, en la parte de la sustitución en los reemplazos.

Si no se puede aplicar ninguna de las situaciones anteriores, por razones de compatibilidad, el modificador /d es el que está activo de manera predeterminada. Ya que esto puede conducir a resultados inesperados, lo mejor es especificar qué conjunto de reglas se deben usar.

Comportamiento del modificador del conjunto de caracteres anterior a Perl 5.14

Antes de 5.14, no existían modificadores explícitos, pero /l estaba implícito para las expresiones regulares compiladas en el ámbito de use locale, y /d era el implícito en caso contrario. Sin embargo, la interpolación de una expresión regular en una expresión regular más grande ignoraría la compilación original en favor de lo que estaba en vigor en el momento de la segunda compilación. Hubo una serie de inconsistencias (errores) con el modificador /d, donde reglas Unicode serían usadas de forma inadecuada, y viceversa. \p{} no implica reglas Unicode, y tampoco todas las apariciones de \N{}, hasta 5.12.

Expresiones Regulares

Metacaracteres

Los patrones usados en el sistema de coincidencias de Perl evolucionaron desde los suministrados por las rutinas regex versión 8. (Las rutinas se derivan (lejanamente) de la reimplementación redistribuible de Henry Spencer de las rutinas V8). Vea "Expresiones regulares versión 8" para más detalles.

En particular, los siguientes metacaracteres mantienen su significados estándar heredados del egrep:

\       Escapa al siguiente metacarácter
^       Coincide con el principio de la línea
.       Coincide con cualquier carácter (excepto el nueva-línea)
$       Coincide con el final de línea (o antes del nueva-línea del final)
|       Alternativas
()      Agrupación
[]      Clase carácter encorchetada

Por defecto, el carácter "^" garantiza que coincidirá solo con el principio de la cadena, el carácter "$" solo con el final (o antes del nueva-línea del final) y Perl hará ciertas optimizaciones asumiendo que la cadena solo contiene una línea. Los caracteres nueva línea incrustados dentro de la cadena no coincidirán con "^" o "$". Puede, sin embargo, desear tratar a la cadena como un búfer de varias líneas, de modo que "^" coincidirá después de cualquier carácter nueva-línea dentro de la cadena (excepto si el nueva-línea es el último carácter en la cadena), y "$" coincidirá delante de cualquier carácter nueva-línea. A costa de una ligera sobrecarga, puede hacer esto usando el modificador /m en el patrón del operador de coincidencia. (Los programas anteriores lo hacían por medio de la configuración $*, pero esta opción se eliminó en perl 5.9).

Para simplificar la sustitución de varias líneas, el carácter "." no coincide con un nueva-línea a menos que utilice el modificador /s, que en efecto dice a Perl que asuma que la cadena es una sola línea -incluso si no lo es-.

Cuantificadores

Se reconocen los siguientes cuantificadores estándares:

*           Coincide con 0 o más veces
+           Coincide con 1 o más veces
?           Coincide 1 o 0 veces
{n}         Coincide exactamente n veces
{n,}        Coincide al menos n veces
{n,m}       Coincide al menos n veces, pero no más de m veces

(Si aparece una llave en cualquier otro contexto y no forma parte de una secuencia escapada como en \x{...}, es tratada como un carácter normal. En particular, el cuantificador de límite inferior no es opcional. Sin embargo, en Perl v5.18 está previsto que emita una advertencia de obsolescencia para todas estos casos, y en Perl v5.20 exigir que el uso literal de una llave sea escapada, por ejemplo, precediendo a ésta con una barra diagonal invertida o incluyéndola entre corchetes, ("\{" o "[{]"). Este cambio permitirá a las futuras extensiones de la sintaxis (como hacer opcional el límite inferior de un cuantificador), y una mejor comprobación de errores de los cuantificadores. Ahora, un error tipográfico en un cuantificador, hace que sea tratado silenciosamente igual que si fueran caracteres literales. Por ejemplo,

/o{4,3}/

se parece a un cuantificador que coincide 0 veces, ya que el 4 es mayor que 3, pero en realidad significa que coincide con la secuencia de seis caracteres "o { 4 , 3 }").

El cuantificador "*" es equivalente a {0,}, el cuantificador "+" a {1,}, y el cuantificador "?" a {0,1}. n y m están limitados a enteros no negativos menores que un límite predefinido cuando perl se compiló. Éste es, normalmente, 32766, en la mayoría de las plataformas. El límite real se puede ver en el mensaje de error generado por un código como este:

$_ **= $_ , / {$_} / for 2 .. 42;

De forma predeterminada, un sub-patrón cuantificado es "avaricioso", es decir, que coincidirá con tantas veces como sea posible (dado un determinado lugar de partida), mientras que aún permita que el resto del patrón coincida. Si desea que coincida con el mínimo número de veces posible, siga el cuantificador con un "?". Tenga en cuanta que los significados no cambian, solo la "avaricia":

*?        Coincide con 0 o más veces, sin avaricia
+?        Coincide con 1 o más veces, sin avaricia
??        Coincide 0 o 1 veces, sin avaricia
{n}?      Coincide exactamente n veces, sin avaricia (redundante)
{n,}?     Coincide al menos n veces, sin avaricia
{n,m}?    Coincide al menos n pero no más de m veces, sin avaricia

De forma predeterminada, cuando un sub-patrón cuantificado no permite que el resto del patrón coincida, Perl dará marcha atrás. Sin embargo, este comportamiento es a veces indeseable. Así, Perl proporciona también el cuantificador "posesivo".

*+     Coincide 0 o más veces y no devuelve nada
++     Coincide 1 o más veces y no devuelve nada
?+     Coincide 0 o 1 veces y no devuelve nada
{n}+   Coincide exactamente n veces y no devuelve nada (redundante)
{n,}+  Coincide al menos n veces y no devuelve nada
{n,m}+ Coincide al menos n pero no más de m veces y no devuelve nada

Por ejemplo,

'aaaa' =~ /a++a/

nunca coincidirá, porque el a++ devorará todas las a en la cadena y no dejará ninguna para el resto del patrón. Esta característica puede ser muy útil para dar pistas a perl sobre dónde no debe dar marcha atrás. Por ejemplo, el problema típico de "coincidir con una cadena doblemente entrecomillada" puede ser más eficientemente realizada cuando se escribe como:

/"(?:[^"\\]++|\\.)*+"/

ya que sabemos que si la doble comilla final no coincide, no ayudará el dar marcha atrás. Vea la subexpresión independiente "(?>patrón)" para obtener más detalles; los cuantificadores posesivos son el edulcorante sintáctico para esta construcción. Por ejemplo, el ejemplo anterior también se podría escribir de la siguiente manera:

/"(?>(?:(?>[^"\\]+)|\\.)*)"/

Secuencias de Escape

Dado que los patrones son procesados como cadenas doblemente entrecomilladas, lo que sigue también funciona:

\t              tab                     (HT, TAB)
\n              nueva línea             (LF, NL)
\r              retorno                 (CR)
\f              avance de página        (FF)
\a              alarma (campana)        (BEL)
\e              escape (como en troff)  (ESC)
\cK             carácter de control     (ejemplo: VT)
\x{}, \x00      carácter cuyo ordinal es el número hex indicado
\N{nombre}      carácter o secuencia de caracteres Unicode
\N{U+263D}      carácter Unicode        (ejemplo: FIRST QUARTER MOON)
\o{}, \000      carácter cuyo ordinal es el número octal indicado
\l              pasar a minúscula el siguiente carácter (como en vi)
\u              pasar a mayúscula el siguiente carácter (como en vi)
\L              pasar a minúscula hasta \E (como en vi)
\U              pasar a mayúscula hasta \E (como en vi)
\Q              escapa (desactiva) los metacaracteres hasta \E
\E              fin de modificación de tamaño de caja o sección entrecomillada, como en vi

Los detalles están en "Comillas y Operadores de comillas" in perlop.

Clase carácter y otros escapados especiales

Ademas, Perl define lo siguiente:

Secuencia  Nota    Descripción
 [...]     [1]  Busca un carácter de acuerdo a las reglas de la clase
                  carácter definida por "...".
                  Ejemplo: [a-z] coincide con "a" o "b" o "c" ... o "z"
 [[:...:]] [2]  Busca un carácter de acuerdo a las reglas de la clase
                  carácter POSIX "..." dentro de la clase carácter
                  más exterior.  Ejemplo: [[:upper:]] coincide con cualquier
                  carácter en mayúscula.
 \w        [3]  Coincide con un carácter "palabra" (alfanumérico más "_", más
                  otros caract. de puntuación de continuación, más marcas
                  Unicode)
 \W      [3]  Coincide con un carácter que no es de "palabra"
 \s      [3]  Coincide con un carácter espacio en blanco
 \S      [3]  Coincide con un carácter que no es un espacio en blanco
 \d      [3]  Coincide con un dígito
 \D      [3]  Coincide con un carácter que no es dígito
 \pP     [3]  Coincide con P, una propiedad nominal.  Use \p{Prop} para los nombres largos
 \PP     [3]  Coincide con una no-P
 \X      [4]  Coincide con una "agrupación de grafemas eXtendida" Unicode
 \C             Coincide con un char (octeto, en lenguaje C) incluso si es
                  parte de un carácter UTF-8 más grande.  Por lo tanto, rompe
                  los caracteres UTF-8 en sus respectivos bytes, por lo
                  que puede terminar con partes incorrectas de UTF-8.  No soportado en
                  búsquedas de coincidencias previas.
 \1        [5]  Retrorreferencia a un grupo específico de captura o búfer.
                  '1' puede ser cualquier entero positivo.
 \g1       [5]  Retrorreferencia a un grupo específico o anterior,
 \g{-1}    [5]  El número puede ser negativo, indicando la posición relativa de
                  un grupo anterior y puede, opcionalmente, estar rodeado por
                  llaves, para un mejor análisis de la exp. reg.
 \g{name}  [5]  Retrorreferencia con nombre
 \k<name>  [5]  Retrorreferencia con nombre
 \K        [6]  Olvidar lo que está a la izquierda de \K, no incluir en $&
 \N        [7]  Cualquier carácter excepto \n (experimental)  No se ve afectado por el
                  modificador /s
 \v        [3]  Espacio en blanco vertical
 \V        [3]  No espacio en blanco vertical
 \h        [3]  Espacio en blanco horizontal
 \H        [3]  No espacio en blanco horizontal
 \R        [4]  Ruptura de línea

[1]

Vea "Clases carácter encorchetadas" in perlrecharclass para más detalles.

[2]

Vea "Clases carácter POSIX" in perlrecharclass para más detalles.

[3]

Vea "Secuencias con contrabarra" in perlrecharclass para más detalles.

[4]

Vea "Miscelánea" in perlrebackslash para más detalles.

[5]

Vea más abajo "Grupos de captura" para más detalles.

[6]

Vea más abajo "Patrones extendidos" para más detalles.

[7]

Tenga en cuenta que \N tiene dos significados. Cuando es de la forma \N{NOMBRE}, coincide con el carácter o secuencia de caracteres cuyo nombre es NOMBRE; y de manera similar cuando es de la forma \N{U+hex}, coincide con el carácter cuyo punto de código Unicode es hex. De lo contrario, equivale a cualquier carácter, excepto \n.

Aserciones

Perl define las siguientes aserciones de ancho cero:

\b  Coincide con un límite de palabra
\B  Coincide con cualquier cosa excepto límite de palabra
\A  Coincide solo con el comienzo de la cadena
\Z  Coincide solo con el final de la cadena, o antes de un nueva línea al final
\z  Coincide solo con el final de la cadena
\G  Coincide solo en pos() (p. ej. en la posición de la última coincidencia
    de la anterior m//g)

Un límite de palabra (\b) es un punto que hay entre dos caracteres que tienen un \w a un lado y un \W al otro lado de él (en cualquier orden), contando con los caracteres imaginarios del principio y final de la cadena coincidentes con un \W. (Dentro de las clases carácter, \b representa el retroceso (backspace) en lugar del límite de palabra, tal como lo hace normalmente en cualquier cadena doblemente entrecomillada). Los \A y \Z son como los "^" y "$", excepto que no coincidirán múltiples veces cuando se use el modificador /m, mientras que "^" y "$" coincidirán en cada límite de línea que contenga la cadena. Para coincidir con el final actual de la cadena, sin ignorar un posible carácter de fin de línea, use \z.

La aserción \G puede ser usada para encadenar coincidencias globales (usando m//g), como se describe en "Operadores Regexp Entrecomillados" in perlop. También es útil cuando se escriben escáneres lex, cuando tiene varios patrones que desea hacer coincidir contra consiguientes subcadenas de su cadena; vea la referencia anterior. La ubicación actual donde \G coincidirá también puede modificarse usando pos() como un ivalor: vea "pos" in perlfunc. Tenga en cuanto que la norma para las coincidencias de tamaño cero (vea "Patrones repetidos coincidiendo con subcadenas de longitud cero") ha sido modificada en cierta medida, en que los contenidos a la izquierda de \G no son tenidos en cuenta cuando se determina la longitud de la coincidencia. Así, lo siguiente no coincidirá nunca:

my $string = 'ABC';
pos($string) = 1;
while ($string =~ /(.\G)/g) {
    print $1;
}

Imprimirá 'A' y entonces termina, pues considera la coincidencia de un ancho cero, y por lo tanto no coincidirá en la misma posición dos veces para la misma cadena.

Cabe señalar que \G mal utilizado puede resultar en un bucle infinito. Tenga cuidado al utilizar patrones que incluyan \G en una alternativa.

Grupos de captura

La construcción de paréntesis ( ... ) crea grupos de captura (también referidos como búferes de captura). Para hacer referencia más tarde a los contenidos actuales de un grupo de captura, dentro del mismo patrón, use \g1 (o \g{1}) para el primero, \g2 (o \g{2}) para el segundo, y así sucesivamente. A esto se le llama una retrorreferencia. No hay límite al número de subcadenas capturadas que puede usar. Los grupos son numerados siendo el paréntesis abierto más a la izquierda el número 1, etc. Si un grupo no se ha encontrado, la retrorreferencia asociada no será inicializada. (Esto puede ocurrir si el grupo es opcional, o en una rama diferente de la alternancia). Puede omitir la "g", y escribir "\1", etc., pero hay algunos problemas con este formato, como se describe más abajo.

También puede referirse a los grupos de captura, de forma relativa, usando un número negativo, por lo que \g-1 y \g{-1} se refieren al grupo de captura inmediatamente anterior, y \g-2 y \g{-2} se refieren al grupo anterior a éste. Por ejemplo:

/
 (Y)            # grupo 1
 (              # grupo 2
    (X)         # grupo 3
    \g{-1}      # contraref. a grupo 3
    \g{-3}      # contraref. a grupo 1
 )
/x

coincidiría igual que con /(Y) ( (X) \g3 \g1 )/x. Esto le permite interpolar expresiones regulares en grandes expresiones regulares y no tener que preocuparse por el cambio en la numeración de los grupos de captura.

Puede prescindir de los números y crear grupos de captura con nombres. La notación es (?<nombre>...) para declararlo y \g{nombre} para referirse a él. (Para ser compatible con las expresiones regulares .Net, \g{nombre} también se puede escribir como \k{nombre}, \k<nombre> o \k'nombre'). nombre no debe comenzar con un número, ni contener guiones. Cuando diferentes grupos dentro del mismo patrón tienen el mismo nombre, cualquier referencia a ese nombre se supone que es al grupo definido que esté más a la izquierda. Los grupos con nombre se numeran de forma absoluta y relativa, por lo que también se puede hacer referencia a ellos con esos números. (De este modo es posible hacer cosas con los grupos de captura con nombres que, de otro modo, requerirían código (??{})).

Los contenidos del grupo de captura están, dinámicamente, ajustados a un ámbito y disposición fuera del patrón hasta el final del bloque que lo contiene o hasta que la siguiente coincidencia con éxito, lo que ocurra primero. (Vea "Sentencias compuestas" in perlsyn). Puede referirse a ellos con un número absoluto (usando "$1" en lugar de "\g1", etc.); o por nombre a través del hash %+, usando "$+{nombre}".

Las llaves son necesarias al referirse a los grupos de captura de llamada, pero son opcionales para los números absolutos o relativos. Las llaves son más seguras al crear una expresión regular mediante la concatenación de cadenas más pequeñas. Por ejemplo, si tiene qr/$a$b/, y $a conteniendo "\g1" y $b conteniendo "37", obtendrá \g137/, que, probablemente, no será lo que pretendía.

Las notaciones \g y \k fueron introducidas en Perl 5.10.0. Antes de esto, no existían los grupos de captura numerados de forma relativa, o mediante un nombre de grupo. Los grupos numerados de forma absoluta eran de la forma \1, \2, etc., y esta notación todavía está aceptada (y probablemente siempre lo será). Pero conduce a algunas ambigüedades si hay más de 9 grupos de captura, como \10 podría referirse al décimo grupo de captura, o al carácter cuyo ordinal en octal es 010 (un retroceso, en ASCII). Perl resuelve esta ambigüedad mediante la interpretación de \10 como una retrorreferencia cuando, al menos, se han abierto, antes, 10 paréntesis de apertura. Asimismo, \11 es una retroreferencia sólo si, antes, y por lo menos, se han abierto 11 paréntesis. Y así sucesivamente. De \1 a \9, son siempre interpretadas como retrorreferencias. Hay varios ejemplos a continuación que ilustran estos peligros. Puede evitar la ambigüedad usando siempre \g{} o \g si se refiere a los grupos de captura; y para las constantes octales siempre con \o{}, o para \077 e inferiores, usando 3 dígitos rellenados con ceros a la izquierda, ya que un cero a la izquierda implica una constante octal.

La notación \dígito también funciona, en ciertas circunstancias, fuera del patrón. Vea "Advertencia de \1 en lugar de $1" abajo para los detalles.

Ejemplos:

s/^([^ ]*) *([^ ]*)/$2 $1/;     # intercambia las dos primeras palabras

/(.)\g1/                        # busca el primer carácter repetido
     and print "'$1' es el primer carácter repetido\n";

/(?<car>.)\k<car>/              # ... de otra forma
     and print "'$+{car}' es el primer carácter repetido\n";

/(?'char'.)\g1/                 # ... mezcla y busca
     and print "'$1' es el primer carácter repetido\n";

if (/Tiempo: (..):(..):(..)/) {   # extrae valores
    $horas = $1;
    $minutos = $2;
    $segundos = $3;
}

/(.)(.)(.)(.)(.)(.)(.)(.)(.)\g10/   # \g10 es una retrorreferencia
/(.)(.)(.)(.)(.)(.)(.)(.)(.)\10/    # \10 es octal
/((.)(.)(.)(.)(.)(.)(.)(.)(.))\10/  # \10 es una retrorreferencia
/((.)(.)(.)(.)(.)(.)(.)(.)(.))\010/ # \010 es octal

$a = '(.)\1';        # Crea problemas cuando es concatenado.
$b = '(.)\g{1}';     # Evita los problemas.
"aa" =~ /${a}/;      # Verdadero
"aa" =~ /${b}/;      # Verdadero
"aa0" =~ /${a}0/;    # ¡Falso!
"aa0" =~ /${b}0/;    # Verdadero
"aa\x08" =~ /${a}0/; # ¡Verdadero!
"aa\x08" =~ /${b}0/; # Falso

Varias variables especiales también se refieren a porciones de la coincidencia anterior. $+ devuelve cualquiera que sea el último paréntesis de captura coincidente. $& devuelve toda la cadena coincidente. (Hace un tiempo, $0 también lo hacía, pero ahora devuelve el nombre del programa). $` devuelve todo lo anterior a la cadena coincidente. $' devuelve todo lo posterior a la cadena coincidente. Y $^N contiene aquello que coincidía con el más reciente grupo de captura (sub coincidencia). $^N puede ser usado en patrones extendidos (ver abajo), por ejemplo para asignar una sub coincidencia a una variable.

Estas variables especiales, como el hash %+ y las variables de coincidencia numeradas ($1, $2, $3, etc.) están dinámicamente contextualizadas hasta el final del bloque actual o hasta la siguiente coincidencia exitosa; lo que ocurra primero. (Vea "Sentencias compuestas" in perlsyn).

NOTA: Coincidencias fallidas en perl no reinicializan las variables de coincidencia, lo que facilita escribir código que haga comprobaciones para una serie específica de casos y recuerde la mejor coincidencia.

ADVERTENCIA: Una vez que Perl considera que necesitas una de $&, $`, o $', en cualquier parte del programa, las usará para todos los patrones de coincidencia. Esto puede ralentizar sustancialmente el programa. Perl utiliza el mismo mecanismo para producir $1, $2, etc, por lo que también paga un precio para cada patrón que contenga paréntesis de captura. (Para evitar este coste mientras quiera usar el comportamiento de agrupación, use en su lugar la expresión regular extendida (?: ... )). Pero si nunca usa $&, $` o $', entonces los patrones sin paréntesis de captura, no serán penalizados. Así que evite $&, $', y $` si puede, pero si no puede (y algunos algoritmos realmente los necesitan), una vez que los use aunque sea una sola vez, úselos a voluntad, ya que ya habrá pagado el precio. A partir de 5.005, $& no es tan costoso como los otros dos.

Como solución a este problema, Perl Perl 5.10.0 introduce ${^PREMATCH}, ${^MATCH} y ${^POSTMATCH}, que son equivalentes a $`, $& y $', excepto que solo se tiene garantizado que estarán definidos después de una coincidencia exitosa, ejecutada con un modificador /p (preserva). El uso de estas variables no incurre en penalización en el rendimiento global, a diferencia de sus equivalentes de caracteres de puntuación, pero sin embargo, tiene que decirle a perl cuándo desea utilizarlos.

Escapando metacaracteres

Metacaracteres escapados en Perl son alfanuméricos, como \b, \w, \n. A diferencia de algunos otros lenguajes de expresiones regulares, no hay símbolos escapados que no sean alfanuméricos. Así que cualquier cosa que se parezca a \\, \(, \), \<, \>, \{, or \} es siempre interpretado como un carácter literal, no un metacarácter. Esto se usó una vez como un modismo común para desactivar o citar los significados especiales de los metacaracteres de expresiones regulares en una cadena que desea utilizar para un patrón. Escape sencillamente todos los caracteres que no formen parte de una palabra:

$patrón =~ s/(\W)/\\$1/g;

(Si está activo use locale, entonces depende de la configuración regional actual). Hoy es más común el uso de la función quotemeta() o de la secuencia de escapado \Q para desactivar todos los significados especiales de los metacaracteres, como por ejemplo:

/$noescapados\Q$escapados\E$noescapados/

Tenga en cuenta que si pone barras diagonales inversas literales (no dentro de las variables interpoladas) entre \Q y \E, una interpolación con doble escapado de barras diagonales inversas puede llevar a resultados confusos. Si necesita usar barras diagonales inversas literales dentro de \Q...\E, consulte "Detalles sangrientos del análisis de las construcciones entrecomilladas" in perlop.

quotemeta() y \Q se describen completamente en "quotemeta" in perlfunc.

Patrones extendidos

Perl también define una coherente sintaxis extendida de características no encontradas en las herramientas estándar, como awk y lex. La sintaxis, para la mayor parte de estos casos, es un par de paréntesis con un signo de interrogación como primer elemento dentro de los paréntesis. El carácter situado detrás del signo de interrogación indica la extensión.

La estabilidad de estas extensiones varía ampliamente. Algunos han sido parte del núcleo del lenguaje durante muchos años. Otros son experimentales y pueden cambiar sin previo aviso o ser retirados por completo. Consulte la documentación de cada característica individual para verificar su estado actual.

Un signo de interrogación fue elegido para esto y para la construcción mínima de coincidencia porque: 1) signos de interrogación son poco frecuentes en expresiones regulares antiguas, y 2) cada vez que veas uno, debe pararse y "cuestionarse" exactamente lo que está pasando. Esa es la psicología...

(?#text)

Un comentario. El texto es ignorado. Si el modificador /x permite formateo con espacio en blanco, un simple # será suficiente. Tenga en cuenta que Perl cierra el comentario tan pronto como vea un ), por lo que no hay manera de poner un ) literal en el comentario.

(?adlupimsx-imsx)

(?^alupimsx)

Uno o más modificadores de coincidencia de patrón incrustados, que han de ser activados (o desactivados, si son precedidos por -) para el resto del patrón o el resto del grupo de patrón más interior (si existe).

Esto es particularmente útil para los patrones dinámicos, como los que se leen desde un archivo de configuración, tomados desde un argumento, o especificados en alguna otra tabla. Considere el caso de que algunos patrones quieren ser sensibles a las mayúsculas y otros no: para el caso de los patrones insensibles sólo necesita incluir (?i) por delante del patrón. Por ejemplo:

$patron = "foobar";
if ( /$patron/i ) { }

# más flexible:

$patron = "(?i)foobar";
if ( /$patron/ ) { }

Estos modificadores son reiniciados al final del grupo que lo alberga. Por ejemplo,

( (?i) bla ) \s+ \g1

coincidirá con bla con cualquier tamaño de caja, algunos espacios, y una exacta (¡incluyendo el tamaño de caja!) repetición de la palabra anterior asumiendo el modificador /x, y no el modificador /i alrededor de este grupo.

Estos modificadores no se transfieren a sub-patrones nominados en el grupo que los envuelve. En otras palabras, un patrón como ((?i)(&NOMBRE)) no cambia la sensibilidad al tamaño de caja del patrón "NOMBRE".

Cualquiera de estos modificadores pueden ser inicializados de forma global, para todas las expresiones regulares compiladas dentro del ámbito de un use re. Vea "modo '/banderas'" in re.

A partir de Perl 5.14, un "^" (acento circunflejo) inmediatamente después de un "?" es una abreviatura equivalente de d-imsx. Las banderas (excepto "d") pueden seguir al acento circunflejo para anular el efecto. Sin embargo, un signo menos no es legal con él.

Note que los modificadores a, d, l, p, y u son especiales, en el sentido en que solo pueden ser activados, no desactivados, y los modificadores a, d, l, y u son mutuamente excluyentes: especificando uno de ellos de-especifica a los otros, y un máximo de uno (o dos a) pueden aparecer en la construcción. Así, por ejemplo, (?-p) sacará una advertencia cuando sea compilada bajo use warnings; (?-d:...) y (?dl:...) son errores fatales.

Tenga en cuenta que el modificador p es especial, en que su presencia en cualquier lugar del patrón tiene un efecto global.

(?:patrón)

(?adluimsx-imsx:patrón)

(?^aluimsx:patrón)

Este es para agrupación, no captura; agrupa subexpresiones como lo hace "()", pero no crea retrorreferencias como sí lo hace "()". Así que

@campos = split(/\b(?:a|b|c)\b/)

es como

@campos = split(/\b(a|b|c)\b/)

pero no escupe campos extra. También, es más barato no capturar caracteres si no son necesarios.

Cualquier letra entre ? y : actúa como modificadores de banderas con (?adluimsx-imsx). Por ejemplo,

/(?s-i:más.*que).*millones/i

es equivalente al más verboso

/(?:(?s-i)más.*que).*millones/i

A partir de Perl 5.14, un "^" (acento circunflejo) inmediatamente después de un "?" es una abreviatura equivalente de d-imsx. Cualquier bandera positiva (excepto "d") pueden seguir al circunflejo, por lo que

(?^x:foo)

es equivalente a

(?x-ims:foo)

El circunflejo le dice a Perl que esta agrupación no hereda las banderas de ningún patrón vecino, pero usa los valores por defecto del sistema (d-imsx), modificado por cualquier otra bandera especificada.

El circunflejo permite la conversión sencilla a cadena de caracteres de las expresiones regulares compiladas. Aparecen así

(?^:patrón)

con cualquier bandera que no esté puesta por defecto apareciendo entre el circunflejo y el carácter de dos puntos. Una prueba que examina esta conversión a cadena de caracteres no tiene por qué tener las banderas por defecto del sistema puesta en el propio código, sólo el circunflejo. Si las nuevas banderas son agregadas a Perl, el significado de la expansión del circunflejo cambiará para incluir el valor predeterminado para estas banderas, por lo que la prueba seguirá funcionando, sin cambios.

Especificar una bandera negativa después del circunflejo es un error, ya que la bandera es redundante.

Mnemotécnico para (?^...): Un nuevo comienzo, ya que el uso normal de un circunflejo es coincidir con el comienzo del patrón.

(?|patrón)

Este es el patrón "reinicio de rama", que tiene la propiedad especial de numerar los grupos de captura desde el mismo punto inicial en cada rama de la alternancia. Está disponible a partir de perl 5.10.0.

Los grupos de captura son numerados de izquierda a derecha, pero dentro de esta construcción la numeración es reiniciada en cada rama.

La numeración dentro de cada rama será la normal, y cualquier grupo después de esta construcción se numerará como si la construcción contuviera una sola rama, que es la que tiene más grupos de captura dentro de si.

Esta construcción será útil cuando desea capturar una sola de una serie de alternativas.

Consideremos el siguiente patrón. Los números de abajo muestran en qué grupo de captura será almacenado.

# antes   -------------reinicio de rama--------- después        
/ ( a )  (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
# 1            2         2  3        2     3     4  

Tenga cuidado al utilizar el patrón de reinicio de rama en combinación con la captura nominal. Las capturas nominadas son implementadas como alias a los grupos numerados que almacenan las capturas, y esto interfiere con la implementación del patrón de reinicio de rama. Si está utilizando capturas nominadas en un patrón de reinicio de rama, lo mejor es utilizar los mismos nombres, en el mismo orden, en cada una de las alternativas:

/(?|  (?<a> x ) (?<b> y )
   |  (?<a> z ) (?<b> w )) /x

El no hacerlo puede dar lugar a sorpresas:

"12" =~ /(?| (?<a> \d+ ) | (?<b> \D+))/x;
say $+ {a};   # Imprime '12'
say $+ {b};   # *También* imprime '12'.

El problema aquí es que tanto el búfer nominado a como el grupo nominado b son alias del grupo perteneciente a $1.

Aserciones cercanas

Las aserciones cercanas (Look-around assertions) son patrones de ancho cero que coinciden con un patrón específico sin incluirlo en $&. Aserciones positivas coinciden cuando los subpatrones coinciden, aserciones negativas coinciden cuando fallan sus subpatrones. Lo antecedente (Look-behind) coincide con texto hasta la actual posición de coincidencia, lo consiguiente (look-ahead) coincide con texto que sigue a la actual posición de coincidencia.

(?=patrón)

Una aserción consiguiente positiva de ancho cero. Por ejemplo, /\w+(?=\t)/ coincide con una palabra seguida por un tabulador, sin incluir el tabulador en $&.

(?!patrón)

Una aserción consiguiente negativa de ancho cero. por ejemplo, /foo(?!bar)/ coincide con cualquier ocurrencia de "foo" que no esté seguido por "bar". Tenga en cuenta, sin embargo, que antecedente y consiguiente NO son la misma cosa. No puede usar esto para las búsquedas antecedentes.

Si está buscando por un "bar" que no esté precedido por un "foo", /(?!foo)bar/ no hará lo que espera. Esto es así porque (?!foo) está diciendo que la siguiente cosa no puede ser "foo", y no lo es, es "bar", por lo que "foobar" sí que coincidirá. Use en su lugar el antecedente (look-behind) (vea más abajo).

(?<=patrón) \K

Una aserción antecedente positiva de ancho cero. Por ejemplo, /(?<=\t)\w+/ coincide con una palabra seguida por un tabulador, sin incluir el tabulador en $&. Sólo funciona para antecedentes de ancho fijo.

Hay una forma especial de esta construcción, llamada \K, que hace que el motor regex "salte" todo lo que haya coincidido anteriormente a la \K y no lo incluya en $&. Esto, efectivamente, ofrece la posibilidad de búsquedas de antecedentes de longitud variable. El uso de \K dentro de otra aserción consiguiente está permitida, pero el comportamiento no está, actualmente, bien definido.

Por diversas razones \K puede ser significativamente más eficiente que la construcción equivalente (?<=...), y esto es especialmente útil en situaciones donde usted quiere, eficientemente, quitar algo que siga a otra cosa, dentro de una cadena. Por ejemplo

s/(foo)bar/$1/g;

puede ser reescrito de forma más eficiente

s/foo\Kbar//g;

(?<!patrón)

Una aserción antecedente negativa de ancho cero. Por ejemplo /(?<!bar)foo/ coincide con cualquier ocurrencia de "foo" que no esté seguido por "bar". Sólo funciona para antecedentes de ancho fijo.

(?'NOMBRE'patrón)

(?<NOMBRE>patrón)

Un grupo de captura con nombre. Idéntico en todos los aspectos respecto a la captura normal con paréntesis () pero con el hecho adicional de que %+ o %- pueden ser usados para referirse por nombre en distintas construcciones de expresiones regulares (como \g{NOMBRE}) y puede ser accedido por nombre después de una coincidencia exitosa, con %+ o %-. Vea perlvar para más detalles sobre los hash %+ y %-.

Si múltiples grupos de captura tienen el mismo nombre, entonces $+{NOMBRE} se referirá al grupo definido más a la izquierda, dentro de la coincidencia.

Las formas (?'NOMBRE'patrón) y (?<NOMBRE>patrón) son equivalentes.

NOTA: Si bien la notación de esta construcción es la misma que la función similar en las expresiones regulares en .NET, el comportamiento no lo es. En Perl los grupos están numerados secuencialmente, independientemente de tener nombres o no. Así, en el patrón

/(x)(?<foo>y)(z)/

$+{foo} será lo mismo que $2, y $3 contendrá 'z' en lugar de lo opuesto que un hacker en regex .NET podría esperar.

Actualmente NOMBRE está limitado solamente a identificadores sencillos. En otras palabras, debe coincidir con /^[_A-Za-z][_A-Za-z0-9]*\z/ o su extensión Unicode (ver utf8), aunque no esté ampliada por la configuración regional (ver perllocale).

NOTA: Con el fin de facilitar las cosas a los programadores con experiencia en Python o motores regex PCRE, el patrón (?P<NOMBRE>patrón) puede ser usado en lugar de (?<NOMBRE>patrón); sin embargo, esta forma no soporta el uso de comillas simples como un delimitador para el nombre.

\k<NOMBRE>

\k'NOMBRE'

Retroreferencia con nombre. Similar a las retrorreferencias numéricas, excepto que el grupo es designado por nombre y no por número. Si varios grupos tienen el mismo nombre entonces se refiere al grupo más a la izquierda de la coincidencia actual.

Es un error referirse a un nombre no definido anteriormente en el patrón por un (?<NOMBRE>).

Ambas formas son equivalentes.

NOTA: Con el fin de facilitar las cosas a los programadores con experiencia en Python o motores regex PCRE, el patrón (?P=NOMBRE) puede ser usado en lugar de \k<NOMBRE>.

(?{ código })

AVISO: Esta característica de expresión regular extendida está considerada experimental, y puede ser modificada sin previo aviso. Código ejecutado que tenga efectos colaterales puede quizás no funcionar de forma idéntica en sucesivas versiones debido a los efectos de futuras optimizaciones en el motor de expresiones regulares.

Esta aserción de ancho cero evalúa cualquier código Perl empotrado en él. Siempre tiene éxito, y el código no es interpolado. En la actualidad, las reglas para determinar el lugar donde código termina son algo enrevesadas.

Esta característica se puede utilizar con la variable especial $^N para capturar los resultados de las coincidencias parciales en variables sin tener que seguir la pista del número de paréntesis anidados. Por ejemplo:

$_ = "El zorro marrón saltó sobre el perezoso perro";
/el (\S+)(?{ $animal = $^N }) (\S+)(?{ $color = $^N })/i;
print "color = $color, animal = $animal\n";

Dentro del bloque (?{...}), $_ se refiere a la cadena contra que la expresión regular se está evaluando. También puede utilizar pos() para saber cuál es la posición actual de coincidencia dentro de esa cadena.

El código está apropiadamente encerrado en un ámbito, en el sentido siguiente: si la aserción es retrotraída (comparar con "Vuelta atrás"), todos los cambios introducidos después de la localización son deshechos, por lo que

$_ = 'a' x 8;
m<
   (?{ $cnt = 0 })                 # Inicializa $cnt.
   (
     a
     (?{
         local $cnt = $cnt + 1;  # Actualiza $cnt,
                                 # independiente de si hay que retrotraer.
     })
   )*
   aaaa
   (?{ $res = $cnt })      # En caso de éxito, copiar a
                                # una variable no-localizada
 >x;

será $res = 4. Tenga en cuanta que después de la coincidencia, $cnt devuelve el valor introducido globalmente, porque los ámbitos que imponen los operadores local son desarmados en orden inverso al que se creó.

Esta aserción puede ser usada con un interruptor (?(condición)patrón-sí|patrón-no). Si no se usa de esta manera, el resultado de la evaluación de código se pone en la variable especial $^R. Esto ocurre de forma inmediata, por lo que $^R puede ser usada desde otras aserciones (?{ código }) dentro de la misma expresión regular.

La asignación a $^R anterior está apropiadamente localizada, por lo que el valor anterior de $^R es restaurado si la aserción es retrotraída; ver "Vuelta atrás".

Por razones de seguridad, esta construcción está prohibida si la expresión regular incluye interpolación de variables en tiempo de ejecución, a menos que el peligroso pragma use re 'eval' esté en uso (vea re), o las variables contengan resultados del operador qr// (vea "qr/CADENA/msixpodual" in perlop).

Esta restricción se debe a la muy extendida y muy cómoda costumbre de usar determinadas cadenas, como patrones, en tiempo de ejecución. Por ejemplo:

$re = <>;
chomp $re;
$cadena =~ /$re/;

Antes de que Perl supiera cómo ejecutar código interpolado dentro de un patrón, esta operación era completamente segura desde un punto de vista de la seguridad, aunque podría levantar una excepción si se pasa un patrón ilegal. Si activa use re 'eval', sin embargo, ya no es seguro, por lo que debería usarlo solo si está utilizando comprobaciones pringosas (taint). Mejor aún, utilice la evaluación cuidadosamente limitada dentro de un compartimento de seguridad. Vea perlsec para obtener más detalles sobre estos dos mecanismos.

AVISO: El uso de variables léxicas (my) en estos bloques está roto. El resultado es impredecible y hará a perl inestable. La solución consiste en el uso de variables globales (our).

AVISO: En perl 5.12.x y anteriores, el motor regex es, actualmente, no re-entrante, por lo que el código interpolado no podrá invocar de forma segura el motor regex, tanto directamente con m// o s///, o indirectamente con funciones, como split. Invocar el motor de expresiones regulares en estos bloques haría a perl inestable.

(??{ código })

AVISO: Esta característica de expresión regular extendida está considerada experimental, y puede ser modificada sin previo aviso. Código ejecutado que tenga efectos colaterales puede quizás no funcionar de forma idéntica en sucesivas versiones debido a los efectos de futuras optimizaciones en el motor de expresiones regulares.

Esta es una subexpresión regular "pospuesta". El código es evaluado en tiempo de ejecución, en el momento en que esta subexpresión puede coincidir. El resultado de la evaluación es considerada como una expresión regular y combinada como si fuera insertada en lugar de esta construcción. Tenga en cuenta que esto significa que los contenidos de los grupos de captura definidos dentro de un patrón evaluado no están disponibles fuera del patrón, y viceversa, no hay manera de que el patrón interno devuelto por un bloque de código se refiera a un grupo de captura definido fuera. (El bloque de código puede utilizar $1, etc., para referirse a grupos de captura del patrón que lo envuelve). Por lo tanto,

('a' x 100)=~/(??{'(.)' x 100})/

habrá coincidencia, pero no actualizará $1.

El código no es interpolado. Como antes, las reglas para determinar el lugar donde código termina son algo enrevesadas.

El siguiente patrón coincide con un grupo de paréntesis:

$re = qr{
            \(
            (?:
               (?> [^()]+ )  # No-paréntesis, sin vuelta atrás
             |
               (??{ $re })   # Grupo con coincidencia de paréntesis
            )*
            \)
         }x;

Vea también (?PARNO) para ver una manera diferente, más eficaz para realizar la misma tarea.

Por razones de seguridad, esta construcción está prohibida si la expresión regular incluye interpolación de variables en tiempo de ejecución, a menos que el peligroso pragma use re 'eval' esté en uso (vea re), o las variables contengan resultados del operador qr// (vea "qr/CADENA/msixpodual" in perlop).

En perl 5.12.x y anteriores, debido a que el motor regex es, actualmente, no re-entrante, el código interpolado no podrá invocar de forma segura el motor regex, tanto directamente con m// o s///, o indirectamente con funciones, como split.

Realizar un proceso recursivo más de 50 veces sin consumir ninguna cadena de entrada resultará en un error fatal. La profundidad máxima está compilada en perl, por lo que su modificación requiere una generación personalizada.

(?PARNO) (?-PARNO) (?+PARNO) (?R) (?0)

Similar a (??{ código }) excepto que no incluye la compilación de ningún código; en vez de eso trata a los contenidos de un grupo de captura como un patrón independiente que debe coincidir en la posición actual. Los grupos de captura que contengan el patrón tendrán el valor determinado por la recursividad más externa.

PARNO es una secuencia de dígitos (no empezando en 0) cuyo valor refleja el número del par de paréntesis del grupo de captura que hay que re-ejecutar. (?R) re-ejecuta hasta el comienzo de todo el patrón. (?0) es una sintaxis alternativa para (?R). Si PARNO es precedido por un signo más o menos, entonces se asume que es relativo, con números negativos indicando grupos de captura anteriores, y con positivos a los posteriores. Así (?-1) se refiere al grupo declarado más recientemente, y (?+1) se refiere al siguiente grupo a ser declarado. Tenga en cuenta que el recuento de la recursión relativa difiere de la de retrorreferencias relativas, en que con recursión, los grupos no cerrados están incluidos.

El siguiente patrón coincide con una función foo() que puede contener paréntesis balanceados como argumento.

$re = qr{ (                    # paréntesis grupo 1 (toda la función)
            foo
            (                  # paréntesis grupo 2 (paréntesis)
              \(
                (              # paréntesis grupo 2 (contenidos de paréntesis)
                (?:
                 (?> [^()]+ )  # No-paréntesis sin retroceso
                |
                 (?3)          # Recursivo para empezar el paréntesis grupo 2
                )*
                )
              \)
            )
          )
        }x;

Si el patrón se utilizó de esta manera

'foo(bar(baz)+baz(bop))'=~/$re/
    and print "\$1 = $1\n",
              "\$2 = $2\n",
              "\$3 = $3\n";

la salida producida debe ser la siguiente:

$1 = foo(bar(baz)+baz(bop))
$2 = (bar(baz)+baz(bop))
$3 = bar(baz)+baz(bop)

Si no se define un correspondiente grupo de captura, entonces es un error fatal. Realizar un proceso recursivo más de 50 veces sin consumir ninguna cadena de entrada resultará en un error fatal. La profundidad máxima está compilada en perl, por lo que su modificación requiere una generación personalizada.

A continuación se muestra cómo el uso de indexación negativa puede hacer que sea más fácil de integrar dentro de los patrones recurrentes de una construcción qr// para su uso posterior:

my $parentesis = qr/(\((?:[^()]++|(?-1))*+\))/;
if (/foo $parentesis \s+ + \s+ bar $parentesis/x) {
   # hacer algo aquí...
}

Note que este patrón no se comporta del mismo modo que la misma construcción equivalente en PCRE o Python. En Perl se puede dar marcha atrás en un grupo recursivo, en PCRE y lenguajes de programación Python el grupo recursivo es tratado de forma atómica. Además, los modificadores son resueltos en tiempo de compilación, por lo que construcciones como (?i:(?1)) o (?:(?i)(?1)) no afectan al modo en el que el sub-patrón será procesado.

(?&NOMBRE)

Procesa de forma recursiva un sub-patrón con nombre. Idéntico a (?PARNO) salvo que el paréntesis a re-ejecutar se determina por su nombre. Si múltiples paréntesis tienen el mismo nombre, entonces re-ejecuta el que esté más a la izquierda.

Es un error referirse a un nombre que no se haya declarado en alguna parte del patrón.

NOTA: Con el fin de facilitar las cosas a los programadores con experiencia en Python o motores regex PCRE, el patrón (?P>NOMBRE) puede ser usado en lugar de (?&NOMBRE).

(?(condición)patrón-sí|patrón-no)

(?(condición)patrón-sí)

Expresión condicional. Busca el patrón-sí si condición devuelve un valor verdadero, sino, busca el patrón patrón-no. Un patrón no presente siempre coincide.

(condición) debe ser: un número entero entre paréntesis (que es válido si coincide con su correspondiente par de paréntesis); una aserción antecedente/consiguiente/evaluación de tamaño cero; un nombre entre ángulos o comillas simples (que es válido si el nombre coincide con un grupo con el mismo nombre), o el símbolo especial (R) (verdadero cuando es evaluado dentro de una recursión o eval). Además, el R puede ser seguido de un número (que será cierto cuando es evaluado cuando se procesa recursivamente dentro del grupo correspondiente), o por &NOMBRE, en cuyo caso sólo será verdadera cuando sea evaluada durante la recursión en el grupo con nombre.

He aquí un resumen de los predicados posibles:

(1) (2) ...

Comprueba si el grupo de captura indicado por el número, ha coincidido con algo.

(<NOMBRE>) ('NOMBRE')

Comprueba si el grupo con el nombre indicado ha coincidido con algo.

(?=...) (?!...) (?<=...) (?<!...)

Comprueba si el patrón coincide (o no coincide, con las variantes '!').

(?{ CÓDIGO })

Trata el valor de retorno del bloque de código como la condición.

(R)

Comprueba si la expresión se ha evaluado en el interior de la recursión.

(R1) (R2) ...

Comprueba si la expresión se ha evaluado mientras se ejecuta directamente en el interior del n-ésimo grupo de captura. Esto comprueba si la regex equivale a

if ((caller(0))[3] eq 'subnombre') { ... }

En otras palabras, no comprueba la pila completa de la recursión.

(R&NOMBRE)

Al igual que (R1), este predicado comprueba si estamos ejecutando directamente dentro del grupo nominado más a la izquierda (esta es la misma lógica usada por (?&NOMBRE) para eliminar la ambigüedad). No comprueba la pila completa, sino sólo el nombre de la recursión activa más interna.

(DEFINE)

En este caso, el patrón-sí no se ejecuta nunca directamente, y no se permite un patrón-no. Similar en espíritu a (?{0}) pero más eficiente. Ver abajo para más detalles.

Por ejemplo:

m{ ( \( )?
   [^()]+
   (?(1) \) )
 }x

coincide con un trozo de no-paréntesis, posiblemente ellos mismos incluidos entre paréntesis.

Una forma especial es el predicado (DEFINE), que nunca ejecuta directamente su patrón-sí, y no permite un patrón-no. Esto permite definir sub-patrones que serán ejecutados sólo mediante el mecanismo de la recursión. De esta manera, puede definir un conjunto de reglas de expresiones regulares que pueden ser agrupadas en el patrón que usted elija.

Se recomienda que para este uso ponga el bloque DEFINE al final del patrón, y que dé nombre a cualquier sub-patrón definido dentro de él.

Además, vale la pena señalar que los patrones definidos de esta manera probablemente no serán tan eficientes, debido a que el optimizador no es muy inteligente sobre el manejo de ellos.

Un ejemplo de cómo esto podría ser utilizado es lo siguiente:

/(?<NOMBRE>(?&NOMBRE_PAT))(?<DIR>(?&DIRECCIÓN_PAT))
 (?(DEFINE)
   (?<NOMBRE_PAT>...)
   (?<DIRECCIÓN_PAT>...)
 )/x

Tenga en cuenta que los grupos de captura encontrados en el interior de la recursión no son accesibles después del regreso de la recursión, por lo que es necesaria una capa extra de grupos de captura. Así $+{NOMBRE_PAT} no será definido a pesar de que $+{NOMBRE} sí lo será.

Por último, tenga en cuenta que los sub-patrones creados dentro de un bloque DEFINE también cuenta en la lista de capturas absolutas y relativas de las capturas, por lo que:

my @capturas = "a" =~ /(.)                  # Primera captura
                       (?(DEFINE)
                           (?<EJEMPLO> 1 )  # Segunda captura
                       )/x;
say scalar @capturas;

Sacará 2, no 1. Esto es especialmente importante si tiene la intención de compilar las definiciones con el operador qr//, y más tarde interpolarlos en otro patrón.

(?>patrón)

Un subexpresión "independiente", aquella que coincide la subcadena con un único patrón que coincidiría si estuviera anclada en la posición indicada, y no coincide con ninguna otra más que esta subcadena. Esta construcción es útil para la optimización de lo que, en caso contrario, serían coincidencias "eternas", porque no va a dar marcha atrás (vea "Vuelta atrás"). También puede ser útil en lugares donde la semántica "agarra todo lo que puedas, y no dar nada a cambio" sea deseable.

Por ejemplo: ^(?>a*)ab nunca coincidirá, ya que (?>a*) (anclada al comienzo de la cadena, como antes) encontrará todos los caracteres a al comienzo de la cadena, sin dejar ninguna otra para ab. Por el contrario, a*ab coincidirá igual que con a+b, ya que la coincidencia del subgrupo a* está influenciada por el texto del grupo siguiente ab (vea "Vuelta atrás"). En particular, a* dentro de a*ab coincidirá con menos caracteres que con solo a*, para permitir que el resto del patrón coincida.

(?>patrón) no desactiva la vuelta atrás una vez que ha coincidido. Todavía es posible dar marcha atrás más allá de la construcción, pero no dentro de ella. Por tanto ((?>a*)|(?>b*))ar aún lo haría con "bar".

Un efecto similar a (?>patrón) se puede conseguir escribiendo (?=(patrón))\g{-1}. Esto busca la misma subcadena como en a+, y el siguiente \g{-1} se come la cadena coincidente; por lo tanto, hace una aserción de longitud cero, como un análogo de (?>...). (La diferencia entre estas dos construcciones es que el segundo utiliza un grupo de captura, aumentando el número de retrorreferencias en el resto de la expresión regular).

Considere este patrón:

m{ \(
      (
        [^()]+          # x+
      |
        \( [^()]* \)
      )+
   \)
 }x

Coincidirá, de manera eficiente, con un grupo no vacío de parejas de paréntesis anidados a dos niveles o menos. Sin embargo, si no existe tal grupo, le tomará casi un tiempo infinito si la cadena es muy larga. Eso es porque hay tantas maneras diferentes de dividir una larga cadena en varias subcadenas. Esto es lo que hace (.+)+, y (.+)+ es similar a un subpatrón del patrón comentado antes. Considere cómo el patrón anterior detecta una no-coincidencia en ((()aaaaaaaaaaaaaaaaaa en unos segundos, pero que cada letra adicional duplica ese tiempo. Este rendimiento exponencial le hará creer que su programa se ha bloqueado. Sin embargo, con un pequeño cambio en este patrón

m{ \(
      (
        (?> [^()]+ )        # cambiar x+ anterior a (?> x+ )
      |
        \( [^()]* \)
      )+
   \)
 }x

que hace que (?>...) coincida exactamente con la cadena anterior (verificar esto por uno mismo puede ser un ejercicio muy productivo), pero termina en la cuarta parte de tiempo cuando se usa en una cadena similar con 1 000 000 de a. Tenga en cuenta, sin embargo, que, cuando esta construcción es seguida por un cuantificador, actualmente lanza un mensaje de advertencia bajo el pragma use warnings o la opción -w, diciendo "matches null string many times in regex" (la cadena nula coincide muchas veces en la exp. reg.)).

En grupos sencillos, como en el patrón (?> [^()]+ ), un efecto comparable puede ser conseguido por medio de una aserción antecedente, como en [^()]+ (?! [^()] ). Esto sólo fue 4 veces más lento en una cadena con un 1 000 000 de a.

La semántica "agarrar todo lo que puedas, y no dar nada a cambio" es deseable en muchas situaciones en las que, a primera vista, un simple ()* parece la solución correcta. Supongamos que analiza un texto con comentarios que están delimitados por # seguido por algunos espacios en blanco (horizontales) opcionales. Contrariamente a lo que parece, #[ \t]* no es la subexpresión correcta para coincidir con el delimitador del comentario, porque puede "dejar aparte" algún espacio en blanco si el resto del patrón lo hace coincidir con él. La respuesta correcta es una de estas:

(?>#[ \t]*)
#[ \t]*(?![ \t])

Por ejemplo, para capturar la parte no vacía de los comentarios, en $1, debería usar uno de estos patrones:

/ (?> \# [ \t]* ) (        .+ ) /x;
/     \# [ \t]*   ( [^ \t] .* ) /x;

El cuál escoger depende de cuál de estas expresiones refleja mejor la especificación anterior, de esos comentarios.

En alguna literatura esta construcción es llamada "coincidencia atómica" o "concordancia posesiva".

Cuantificadores posesivos son equivalentes a poner el elemento a los que se aplica, dentro de una de estas construcciones. Se aplica la siguiente equivalencia:

Forma Cuantificador Forma con paréntesis
------------------- ---------------
PAT*+               (?>PAT*)
PAT++               (?>PAT+)
PAT?+               (?>PAT?)
PAT{min,max}+       (?>PAT{min,max})

Verbos especiales para el control de la vuelta atrás

ADVERTENCIA: Estos patrones son experimentales y sujetos a cambio o eliminación en una futura versión de Perl. Su uso en el código de producción debe anotarse para evitar problemas durante las actualizaciones.

Estos patrones especiales son, generalmente, de la forma (*VERBO:ARG). A menos que se indique lo contrario el argumento ARG es opcional; y en algunos casos, está prohibido.

Cualquier patrón que contenga un verbo especial para la vuelta atrás que permita un argumento, tiene el comportamiento especial de que cuando es ejecutado establece las variables $REGERROR y $REGMARK en el paquete actual. Al hacerlo se aplicarán las siguientes reglas:

En caso de fallo, la variable $REGERROR se establecerá al valor ARG del verbo patrón, si el verbo estaba involucrado en el fallo de la coincidencia. Si la parte ARG del patrón es omitida, entonces $REGERROR se establecerá al nombre del último patrón (*MARK:NOMBRE) ejecutado, o a TRUE si no había ninguno. Además, la variable $REGMARK se establecerá a FALSE.

En una coincidencia exitosa, la variable $REGERROR se establecerá a FALSE, y la variable $REGMARK se establecerá al nombre del último patrón (*MARK:NOMBRE) ejecutado. Vea la explicación del verbo (*MARK:NOMBRE) abajo para obtener más detalles.

NOTE: $REGERROR y $REGMARK no son variables mágicas como $1 y la mayoría de las otras variables relacionadas con las expresiones regulares. No son locales en el ámbito en donde se encuentren, ni de solo lectura, sino que son variables de paquete volátiles, similares a $AUTOLOAD. Use local para fijar cambios en ellas en un determinado ámbito, si fuera necesario.

Si un patrón no contiene un verbo especial de vuelta atrás que permita un argumento, entonces $REGERROR y $REGMARK no son modificados de ninguna manera.

Verbos que toman un argumento

(*PRUNE) (*PRUNE:NOMBRE)

Este patrón de ancho cero poda el árbol de vuelta atrás en el punto actual de cuando dio vuelta atrás a causa de un fallo. Considere el patrón A (*PRUNE) B, donde A y B son patrones complejos. Hasta que el verbo (*PRUNE) se alcance, A puede volver atrás tanto como sea necesario para que se produzca la coincidencia. Una vez que se alcanza, la coincidencia continúa en B, que también puede hacer una vuelta atrás cuando sea necesario; sin embargo, si no hubiera coincidencia con B, entonces ya no se llevará a cabo la vuelta atrás, y el patrón fallará de forma absoluta en la actual posición de inicio.

El siguiente ejemplo cuenta todas las posibles cadenas coincidentes con un patrón (sin que se produzca una coincidencia con ninguna de ellas, por efecto del (*FAIL)).

'aaab' =~ /a+b?(?{print "$&\n"; $contador++})(*FAIL)/;
print "Contador=$contador\n";

que produce:

aaab
aaa
aa
a
aab
aa
a
ab
a
Contador=9

Si añadimos un (*PRUNE) antes de la cuenta, como lo siguiente

'aaab' =~ /a+b?(*PRUNE)(?{print "$&\n"; $contador++})(*FAIL)/;
print "Contador=$contador\n";

evitamos la vuelta atrás y hacemos el recuento de la cadena más larga coincidente en cada punto inicial de la coincidencia, como se ve:

aaab
aab
ab
Contador=3

Se pueden usar cualquier número de aserciones (*PRUNE) en un patrón.

Vea también (?>patrón) y los cuantificadores posesivos para ver otras formas de control de la vuelta atrás. En algunos casos, el uso de (*PRUNE) puede ser reemplazado con un (?>patrón) sin ninguna diferencia funcional; sin embargo, (*PRUNE) puede ser usado para manejar casos que no pueden ser expresados usando un único (?>patrón).

(*SKIP) (*SKIP:NAME)

Este patrón de ancho cero es similar a (*PRUNE), con la excepción de que en caso de fallo también significa que cualquier texto que haya sido encontrado antes del patrón (*SKIP) que se está ejecutando, no puede formar parte de ninguna búsqueda de este patrón. Esto significa que, efectivamente, el motor de expresiones regulares "salta" hacia adelante a esta posición en caso de fallo y trata de coincidir de nuevo, (suponiendo que haya espacio suficiente para que coincida).

El nombre del patrón (*SKIP:NOMBRE) tiene un significado especial. Si se ha encontrado un (*MARK:NOMBRE) durante la búsqueda, entonces es la posición que es utilizada como el "punto de salto". Si no se encontró ningún (*MARK), entonces el operador (*SKIP) no tiene ningún efecto. Cuando es usado sin nombre, el "punto de salto" es donde estaba el punto de coincidencia cuando se ejecutaba el patrón (*SKIP).

Compare lo siguiente con los ejemplos de (*PRUNE); nota que la cadena es el doble de larga:

'aaabaaab' =~ /a+b?(*SKIP)(?{print "$&\n"; $contador++})(*FAIL)/;
print "Contador=$contador\n";

sale

aaab
aaab
Contador=2

Una vez que el 'aaab', en el inicio de la cadena, ha sido encontrado, y el (*SKIP) ejecutado, el siguiente punto de partida será el lugar donde estaba el cursor cuando fue ejecutado (*SKIP).

(*MARK:NOMBRE) (*:NOMBRE) (*MARK:NOMBRE) (*:NOMBRE)

Este patrón de ancho cero puede ser utilizado para marcar el punto alcanzado en una cadena cuando una parte del patrón ha sido encontrado con éxito. A esta marca se le puede dar un nombre. Un patrón (*SKIP) consiguiente saltará entonces a este punto, si hace una vuelta atrás a causa de un fallo. Está permitido cualquier número de patrones (*MARK), y la parte del NOMBRE puede ser duplicada.

Además de interactuar con el patrón (*SKIP), (*MARK:NOMBRE) puede ser usado para "marcar" una rama de del patrón, para que después de la búsqueda, el programa puede determinar qué ramas del patrón participaron en la coincidencia.

Cuando una coincidencia tiene éxito, la variable $REGMARK se establecerá al nombre de (*MARK:NOMBRE) más recientemente ejecutado que participó en la coincidencia.

Esto puede ser usado para determinar qué rama de un patrón coincidió sin necesidad de utilizar un grupo de captura separado para cada rama, que, a su vez, puede resultar en una mejora del rendimiento, ya que Perl no puede optimizar /(?:(x)|(y)|(z))/ tan eficientemente como algo parecido a /(?:x(*MARK:x)|y(*MARK:y)|z(*MARK:z))/.

Cuando una coincidencia ha fallado, y a menos que otro verbo haya estado involucrado en el fallo de la coincidencia y ha dado su propio nombre para ser usado, la variable $REGERROR será ajustada al nombre de (*MARK:NOMBRE) más recientemente ejecutado.

Vea "(*SKIP)" para obtener más detalles.

Como método abreviado (*MARK:NOMBRE) se puede escribir como (*:NOMBRE).

(*THEN) (*THEN:NOMBRE)

Este es similar al operador :: "grupo de corte" de Perl 6. Al igual que (*PRUNE), este verbo siempre coincide, y cuando se hace vuelta atrás a causa de un fallo, hace que el motor de expresiones regulares intente la alternativa siguiente en el grupo más interno del grupo que lo alberga (de captura o de otro tipo) que tenga alternativas. Las dos ramas de (?(condición)patrón-sí|patrón-no) no cuenta como una alternativa, así como a (*THEN).

Su nombre proviene de la observación de que esta operación combinada con el operador de alternancia (|) se puede utilizar para crear lo que es, esencialmente, un bloque basado en un patrón if/then/else:

( COND (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ )

Tenga en cuenta que si este operador es usado, y NO dentro de una alternancia, entonces actúa exactamente igual que el operador (*PRUNE).

/ A (*PRUNE) B /

es lo mismo que

/ A (*THEN) B /

pero

/ ( A (*THEN) B | C (*THEN) D ) /

no es lo mismo que

/ ( A (*PRUNE) B | C (*PRUNE) D ) /

porque después de buscar por la A, pero fallando con la B, el verbo (*THEN) dará una vuelta atrás y lo intentará con C; pero el verbo (*PRUNE) simplemente fallará.

Verbos sin argumento

(*COMMIT)

Este es "patrón de acometida" <commit> o ::: de Perl 6. Es un patrón de ancho cero similar a (*SKIP), excepto que cuando ocurre la vuelta atrás a causa de un fallo hace que la coincidencia falle completamente. No habrá nuevos intentos para encontrar una coincidencia válida avanzando el puntero de arranque. Por ejemplo,

'aaabaaab' =~ /a+b?(*COMMIT)(?{print "$&\n"; $contador++})(*FAIL)/;
print "Contador=$contador\n";

sale

aaab
Contador=1

En otras palabras, una vez que encontramos (*COMMIT), y si el patrón no coincide, el motor de expresiones regulares no tratará de encontrar nada más en el resto de la cadena.

(*FAIL) (*F)

Este patrón no coincide con nada y fallará siempre. Se puede utilizar para forzar al motor a que haga una vuelta atrás. Es equivalente a (?!), pero más fácil de leer. De hecho, (?!) internamente está optimizado para ser (*FAIL).

Es probable que sea útil cuando sólo se combine con (?{}) o (??{}).

(*ACCEPT)

ADVERTENCIA: Esta característica es muy experimental. No se recomienda para código en producción.

Este patrón no coincide con nada y provoca el final de una coincidencia con éxito en el lugar en que el patrón (*ACCEPT) se encontraba, sin importar si pudiera haber más coincidencias en la cadena. Cuando, dentro de un patrón anidado, tales como una recursión, o en un sub-patrón generado de forma dinámica a través de (??{}), sólo el patrón más interno es terminado inmediatamente.

Si el (*ACCEPT) se encuentra dentro de grupos de captura entonces los grupos son marcados para terminar en el lugar en que se encontró el (*ACCEPT). Por ejemplo:

'AB' =~ /(A (A|B(*ACCEPT)|C) D)(E)/x;

coincidirá, y $1 será AB y $2 será B; $3 no será ajustado. Si coincide otra rama en el paréntesis más interior, como en el caso de la cadena 'ACDE', entonces la D y E también tendrían que coincidir.

Vuelta atrás

NOTA: en esta sección se presenta una aproximación abstracta del comportamiento de las expresiones regulares. Para un análisis más riguroso (y complicado punto de vista) de las normas involucradas en la selección de una coincidencia entre las alternativas posibles, vea "Combinando piezas RE".

Una característica fundamental de las expresiones regulares incluye la noción llamada backtracking (vuelta atrás), que se utiliza actualmente (cuando es necesario) por todos los cuantificadores de expresiones regulares no posesivos, es decir, *, *?, +, +?, {n,m}, and {n,m}?. La vuelta atrás es a menudo optimizada internamente, pero estos principios generales siguen siendo válidos.

Para que una expresión regular coincida, debe coincidir la expresión entera, no sólo parte de ella. Así que, si al principio de un patrón conteniendo un cuantificador logra de alguna manera que las últimas partes del patrón fallen, el motor retrocede y vuelve a recalcular la parte inicial -es por eso por lo que se llama vuelta atrás.

Aquí hay un ejemplo de vuelta atrás: Digamos que quiere encontrar la palabra siguiente a "come" en la cadena "En el Comedor Principal el niño come espinacas.":

$_ = "En el Comedor Principal el niño come espinacas.";
if ( /\b(come)\s+(\w+)/i ) {
    print "$2 sigue a $1.\n";
}

Cuando la coincidencia se ejecuta, la primera parte de la expresión regular (\b(come)) encuentra una posible coincidencia al principio de la cadena, y carga $1 con "Come". Sin embargo, tan pronto como el motor de coincidencias ve que no hay espacios en blanco después de "Come" que había guardado en $1, se da cuenta de su error y comienza de nuevo un carácter después de donde había intentado coincidir. Esta vez hace todo el camino hasta la siguiente ocurrencia de "come". La expresión regular completa coincide en este momento, y consigue el resultado esperado de "espinacas sigue a come".

A veces una coincidencia mínima puede ayudar un montón. Imagínese que quisiera buscar todo lo que hay entre "mesa" y "come". En un principio, escribirá algo como esto:

$_ = "En la mesa, al mediodía, se come, y en el comedor se cena.";
if ( /mesa(.*)come/ ) {
    print "obtiene <$1>\n";
}

del que, inesperadamente, sale:

obtiene <, al mediodía, se come, y en el >

Esto se debe a que .* era avaricioso, por lo que obtiene todo lo que hay entre el primer "mesa" y el último "come". Aquí es más eficaz utilizar una coincidencia mínima para asegurarse de que obtiene el texto entre un "mesa" y el primer "come" después de él.

if ( /mesa(.*?)come/ ) { print "obtiene <$1>\n" }
  obtiene <, al mediodía, se >

Aquí hay otro ejemplo: Digamos que quisiera buscar la coincidencia con un número al final de una cadena, y también que desea mantener la parte anterior a esa coincidencia. Así que escribe esto:

$_ = "Tengo 2 números: 53147";
if ( /(.*)(\d*)/ ) {                                # ¡Incorrecto!
    print "El comienzo es <$1>, número es <$2>.\n";
}

Eso no funciona de ninguna manera, porque .* era codicioso y engulló toda la cadena. Como \d* puede coincidir con una cadena vacía, la expresión regular completa coincide con éxito.

El comienzo es <Tengo 2 números: 53147>, número es <>.

Aquí hay algunas variantes más, la mayoría de los cuales tampoco funcionan:

$_ = "Tengo 2 números: 53147";
@patrones = qw{
    (.*)(\d*)
    (.*)(\d+)
    (.*?)(\d*)
    (.*?)(\d+)
    (.*)(\d+)$
    (.*?)(\d+)$
    (.*)\b(\d+)$
    (.*\D)(\d+)$
};

for $patron (@patrones) {
    printf "%-12s ", $patron;
    if ( /$patron/ ) {
        print "<$1> <$2>\n";
    } else {
        print "FALLO\n";
    }
}

Esto imprimirá:

(.*)(\d*)    <Tengo 2 números: 53147> <>
(.*)(\d+)    <Tegno 2 números: 5314> <7>
(.*?)(\d*)   <> <>
(.*?)(\d+)   <Tengo > <2>
(.*)(\d+)$   <Tengo 2 números: 5314> <7>
(.*)(\d+)$   <Tengo 2 números: 5314> <7>
(.*)\b(\d+)$ <Tengo 2 números: > <53147>
(.*\D)(\d+)$ <Tengo 2 números: > <53147>

Como puede ver, puede ser un poco complicado. Es importante darse cuenta de que una expresión regular no es más que un conjunto de aserciones que da una definición de lo que consideramos un éxito. Puede ser 0, 1, u otras formas diferentes en que la definición podría tener éxito contra una cierta cadena de caracteres. Y si hay múltiples maneras en las que podría tener éxito, necesita entender la marcha atrás para saber qué variedad de éxitos va a lograr.

Cuando se utiliza con aserciones consecuentes y negaciones, todo esto puede ser incluso aún más complicado. Imagínese que le gustaría encontrar una secuencia de no-dígitos que no esté seguido por "123". Puede tratar de escribirlo como

$_ = "ABC123";
if ( /^\D*(?!123)/ ) {                # ¡Incorrecto!
    print "Yep, no hay 123 en $_\n";
}

Pero eso no va a coincidir, al menos, no de la forma en que lo está esperando. Afirma que no hay un 123 en la cadena. He aquí una idea más clara de por qué coincide con el patrón, al contrario de lo esperado:

$x = 'ABC123';
$y = 'ABC445';

print "1: tenemos $1\n" if $x =~ /^(ABC)(?!123)/;
print "2: tenemos $1\n" if $y =~ /^(ABC)(?!123)/;

print "3: tenemos $1\n" if $x =~ /^(\D*)(?!123)/;
print "4: tenemos $1\n" if $y =~ /^(\D*)(?!123)/;

Esto imprime

2: tenemos ABC
3: tenemos AB
2: tenemos ABC

Estará esperando a que el test 3 fallara, ya que parece una versión más general del test 1. La diferencia importante entre ellos es que el test 3 contiene un cuantificador (\D*) y por lo tanto puede utilizar la marcha atrás, mientras que el test 1, no. Lo que pasa es que usted ha preguntado "¿Es verdad que al principio de $x, después de 0 o más no-dígitos, tiene algo que no es 123?" Si el reconocedor de patrones hubiese dejado que se expandiera \D* a "ABC", habría causado que todo el patrón fallara.

El motor de búsqueda inicialmente coincidirá \D* con "ABC". Entonces tratará de hacer coincidir (?!123) con "123", por lo que falla. Pero debido a que se ha utilizado un cuantificador (\D*) en la expresión regular, el motor de búsqueda puede dar marcha atrás y volver a intentar la coincidencia de manera diferente con la esperanza de hacer coincidir la expresión regular completa.

El patrón, de verdad, quiere tener éxito, por lo que utiliza el modelo estándar de marcha-atrás-e-inténtalo y permite que \D* se expanda esta vez a solo "AB". Ahora hay realmente algo después de "AB" que no es "123". Se trata de "C123", suficiente.

Podemos lidiar con este problema utilizando una afirmación y una negación. Vamos a decir que la primera parte en $1 debe ser seguida tanto por un dígito como por algo que no es "123". Recuerde que las aserciones consecuentes son expresiones de ancho cero: ellas solo miran, pero no utilizan ninguna parte de la cadena de caracteres en su coincidencia. Así que volviéndolo a escribir de esta manera produce lo que se espera, es decir, el caso 5 fallará, pero el caso 6 tendrá éxito:

print "5: tenemos $1\n" if $x =~ /^(\D*)(?=\d)(?!123)/;
print "6: tenemos $1\n" if $y =~ /^(\D*)(?=\d)(?!123)/;

6: tenemos ABC

En otras palabras, las dos aserciones de ancho cero, una junto a la otra, trabajan como si fueran unidas por un Y, tal y como lo haría usando cualquier aserción integrada: /^$/ coincide sólo si está al comienzo de la línea Y al final de la línea, al mismo tiempo. La verdad más profunda que subyace es que la yuxtaposición de las expresiones regulares siempre significa Y, excepto cuando se escribe un explícito O, mediante la barra vertical. /ab/ significa coincidir con "a" Y (entonces) coincidir con "b", aunque el intento de las coincidencias se realicen en diferentes posiciones, porque "a" no es una aserción de ancho cero, sino una aserción de ancho uno.

ADVERTENCIA: Especialmente complicadas expresiones regulares pueden tomar un tiempo exponencial en resolverse debido a la inmensa cantidad de formas posibles que puede utilizar para tratar de dar marcha atrás para lograr una coincidencia. Por ejemplo, sin optimizaciones internas realizadas por el motor de expresiones regulares, esto tomará un tiempo dolorosamente largo:

'aaaaaaaaaaaa' =~ /((a{0,5}){0,5})*[c]/

Y si ha utilizado algún * en los grupos internos en lugar de limitarlos a 0 a 5 coincidencias, entonces se ejecutará para siempre o hasta que se quede sin espacio de pila. Por otra parte, estas optimizaciones internas no siempre son aplicables. Por ejemplo, si pone {0,5} en lugar de * en el grupo externo, no se aplica ninguna optimización, y la coincidencia tarda mucho tiempo en terminar.

Una poderosa herramienta para la optimización de estas bestias es lo que se conoce como un "grupo independiente", que no hace marcha atrás (vea "(?>patrón)"). Tenga en cuenta también que las aserciones de longitud cero antecedentes/consecuentes no darán marcha atrás para retrasar la coincidencia, ya que ellas están en un contexto "lógico": sólo cuando coinciden son considerados relevantes. Para ver un ejemplo de los efectos secundarios de las aserciones antecedentes que pueden influir en la siguiente coincidencia, vea "(?>patrón)".

Expresiones regulares versión 8

En caso de que no esté familiarizado con la versión 8 "normal" de las rutinas regex, aquí están las reglas de coincidencia de patrones no descritas anteriormente.

Cualquier carácter individual coincide consigo mismo, a menos que sea un metacarácter con un significado especial descrito aquí o anteriormente. Puede hacer que los caracteres que normalmente funcionan como metacaracteres sean interpretados literalmente mediante un prefijado con un "\" (p.e., "\." coincide con un ".", no con cualquier carácter; "\\" coincide con un "\"). Este mecanismo de escape también es necesario para el carácter utilizado como delimitador de patrones.

Una serie de caracteres coincide con la serie de caracteres en la cadena objetivo, por lo que el patrón blurfl coincidiría con "blurfl" en la cadena objetivo.

Puede especificar una clase de caracteres, encerrando una lista de caracteres en [], que coincidirá con cualquier carácter de la lista. Si el primer carácter después del "[" es "^", la clase coincide con cualquier carácter que no esté en la lista. Dentro de una lista, el carácter "-" indica un intervalo, de modo que a-z representa todos los caracteres entre "a" y "z", ambos inclusive. Si desea que sean los propios "-" o "]" como miembros de una clase, póngalos al principio de la lista (posiblemente después de un "^"), o escápelos con una barra diagonal inversa. "-" es también tomado literalmente cuando se encuentra al final de la lista, justo antes del "]" final. (Los siguientes ejemplos especifican la misma clase de tres caracteres: [-az], [az-] y C>[a\-z]>. Todos son diferentes de [a-z], que especifica una clase que contiene veintiséis caracteres, incluso en los juegos de caracteres basados en EBCDIC). Además, si intenta utilizar las clases de caracteres \w, \W, \s, \S, \d, o \D como valores finales de un rango, el "-" es tomado de forma literal.

Tenga en cuenta también que la idea de rango es poco transportable entre conjuntos de caracteres; e incluso dentro de los mismos conjuntos de caracteres pueden causar resultados que probablemente no espera. Un buen principio es el de usar rangos que sólo comiencen y terminen, de forma alfabética, con un mismo tamaño de caja ([a-e], [A-E]), o dígitos ([0-9]). Cualquier otro caso no es seguro. En caso de duda, explicite los conjuntos de caracteres completamente.

Los caracteres pueden ser especificados utilizando una sintaxis metacarácter al igual que la utilizada en C: "\n" coincide con un nueva línea, "\t" un tabulador, "\r" un retorno de carro, "\f" un avance de página, etc. En términos más generales, \nnn, donde nnn es una cadena de tres dígitos octales, coincide con el carácter cuyo código de valor del conjunto de caracteres es nnn. Del mismo modo, \xnn, donde nn son dígitos hexadecimales, coincide con el carácter cuyo ordinal es nn. La expresión \cx coincide con el carácter control-x. Por último, el metacarácter "." coincide con cualquier carácter excepto "\n" (a menos que utilice /s).

Puede especificar una serie de alternativas para un patrón usando "|" para separarlos, por lo que fee|fie|foe coincide con cualquier "fee", "fie", o "foe" en la cadena objetivo (al igual que f(e|i|o)e). La primera alternativa incluye todo, desde el último patrón delimitador ("(", "(?:", etc o el comienzo del patrón) hasta el primer "|", y la última alternativa contiene todo, desde el último "|" hasta el siguiente delimitador de cierre del patrón. Es por eso que es una práctica común incluir las alternativas entre paréntesis: para minimizar la confusión acerca de dónde empiezan y terminan.

Las alternativas son procesadas de izquierda a derecha, de modo que la primera alternativa encontrada que coincida con toda la expresión, es la que es elegida. Esto significa que las alternativas no son necesariamente codiciosas. Por ejemplo: cuando se compara foo|foot contra "barefoot", sólo la parte "foo" coincidirá, ya que es la primera alternativa intentada, y coincide de forma exitosa con la cadena objetivo. (Esto puede no parecer importante, pero es importante cuando se está capturando texto usando paréntesis).

También recuerde que "|" es interpretado como un literal cuando está entre corchetes, por lo que si usted escribe [fee|fie|foe] realmente está solo buscando [feio|].

Dentro de un patrón, puede designar subpatrones para su posterior consulta encerrándolos entre paréntesis, y puede referirse al subpatrón n-ésimo más adelante, en el patrón utilizando el metacarácter \n o \gn. Los subpatrones son numerados basados en el orden, de izquierda a derecha, de su paréntesis de apertura. Una retrorreferencia coincide con lo que en realidad coincidía con el subpatrón en la cadena examinada, no con las reglas de ese subpatrón. Por lo tanto, (0|0x)\d*\s\g1\d* coincidirá con "0x1234 0x4321", pero no con "0x1234 01234", debido a que el subpatrón primero coincidió con "0x", incluso aunque la regla 0|0x podría coincidir con el 0 a la izquierda en el segundo número.

Advertencia de \1 en lugar de $1

Algunas personas están demasiado acostumbradas a escribir cosas como:

$patrón  =~ s/(\W)/\\\1/g;

Se trata de vicios adquiridos (por \1 a \9) para el lado derecho de una sustitución para evitar escandalizar a los adictos del sed, pero es un hábito sucio. Eso es porque en el Pensamiento Perliano, el lado derecho de un s/// es una cadena entrecomillada doble. \1 en una cadena normal entrecomillada doble es un control-A. El significado Unix habitual de \1 es chapuceado dentro de s/// Sin embargo, si usted entra en el hábito de hacer eso, se mete en problemas si, a continuación, añade un modificador /e.

s/(\d+)/ \1 + 1 /eg;            # provoca una advertencia bajo -w

O si trata de hacer

s/(\d+)/\1000/;

No puede eliminar la ambigüedad diciendo \{1}000, mientras que lo puede arreglar con ${1}000. La operación de interpolación no se debe confundir con la operación de coincidencia con una retrorreferencia. Significan dos cosas diferentes en el lado izquierdo del s///.

Patrones repetidos coincidiendo con subcadenas de longitud cero

ADVERTENCIA: sigue material (y prosa) difícil. En esta sección necesita una nueva revisión.

Las expresiones regulares proporcionan un lenguaje de programación conciso y poderoso. Al igual que con la mayoría de otras herramientas poderosas, este poder viene junto con la capacidad para causar estragos.

Un abuso común de este poder se deriva de la capacidad de hacer bucles infinitos mediante expresiones regulares, con algo tan inocuo como:

'foo' =~ m{ ( o? )* }x;

El o? coincide con el inicio de 'foo', y como la posición en la cadena no se ha movido por la coincidencia, o? coincidirá una y otra vez a causa del cuantificador *. Otra forma común de crear un ciclo similar es con el modificador de bucle //g:

@coincidencias = ( 'foo' =~ m{ o? }xg );

o bien

print "coincidencia: <$&>\n" while 'foo' =~ m{ o? }xg;

o el bucle implícito de split().

Sin embargo, la experiencia ha demostrado que muchas de las tareas de programación se pueden simplificar considerablemente mediante el uso de subexpresiones repetidas que coincidan con subcadenas de longitud cero. He aquí un ejemplo sencillo:

@chars = split //, $cadena;           # // no es mágico en split
($muchoespacio = $cadena) =~ s/()/ /g;# los paréntesis evitan la magia de s// /

Así, Perl permite tales construcciones, forzando la ruptura del bucle infinito. Las reglas para esto son diferentes para los bucles de bajo nivel ofrecidos por los cuantificadores codiciosos *+{}, y para los de más alto nivel como el modificador /g o el operador split().

Los bucles de bajo nivel son interrumpidos (es decir, el bucle es roto) cuando Perl detecta que una repetida expresión coincide con una subcadena de longitud cero. Por lo tanto

m{ (?: NO_CERO_LONGITUD | CERO_LONGITUD )* }x;

es equivalente a

m{ (?: NO_CERO_LONGITUD )* (?: CERO_LONGITUD )? }x;

Por ejemplo, este programa

#!perl -l
"aaaaab" =~ /
  (?:
     a                 # no cero
     |                 # o
    (?{print "hola"})  # imprime hola cuando esta
                       #    rama es probada
    (?=(b))            # aserción de ancho cero
  )*  # cualquier número de veces
 /x;
print $&;
print $1;

imprime

hola
aaaaa
b

Tenga en cuenta que "hola" sólo se imprime una vez, ya que cuando Perl ve la sexta iteración del (?:)* más exterior coincide con una cadena de longitud cero, detiene a *.

Los bucles de alto nivel preservan un estado adicional entre las iteraciones: cuándo la última coincidencia fue de longitud cero. Para romper el bucle, la siguiente coincidencia después de una coincidencia de longitud cero se prohíbe que tenga una longitud cero. Esta prohibición se relaciona con dar la marcha atrás (vea "Vuelta atrás"), por lo que la segunda mejor coincidencia es elegida si la mejor coincidencia es de longitud cero.

Por ejemplo:

$_ = 'bar';
s/\w??/<$&>/g;

resulta en <><b><><a><><r><>. En cada posición de la cadena, la mejor opción dada por el modificador no codicioso ?? es la coincidencia de longitud cero, y la segunda mejor coincidencia es la que se corresponde con \w. Así, las coincidencias de longitud cero se alternan con una coincidencia de un carácter de longitud.

Del mismo modo, para los repetidos m/()/g la segunda mejor coincidencia es la coincidencia en la posición de una muesca más allá en la cadena.

El estado adicional de ser encontrado con longitud cero es asociado con la cadena coincidente, y es restablecido con cada asignación de pos(). Coincidencias de longitud cero al final de la coincidencia anterior son ignoradas durante split.

Combinando piezas RE

Cada una de las piezas elementales de las expresiones regulares que se ha descrito anteriormente (por ejemplo, ab o \Z) podría coincidir como mucho con una subcadena en la posición indicada de la cadena de entrada. Sin embargo, en una típica expresión regular, estas piezas elementales se combinan en patrones más complicados con los operadores de combinación ST, S|T, S*, etc (en estos ejemplos S y T son subexpresiones regulares).

Estas combinaciones pueden incluir alternativas, dando lugar a un problema de elección: ¿si tenemos una expresión regular a|ab contra "abc", coincidirá con la subcadena "a" o con la "ab"? Una forma de describir qué subcadena coincidente realmente, es con el concepto de dar marcha atrás (vea "Vuelta atrás"). Sin embargo, esta descripción es de demasiado bajo nivel y te hace pensar en términos de una particular implementación.

Otra descripción comienza con las nociones de "mejor"/"peor". Todas las subcadenas que pueden ser coincidentes con la expresión regular dada se pueden clasificar desde la "mejor" coincidencia hasta la "peor" coincidencia, y es la "mejor" coincidencia la que es elegida. Esto sustituye la pregunta "¿qué es elegida?" por la cuestión "¿que coincidencia es mejor, y cuál es peor?".

Una vez más, de las piezas elementales no hay cuestión de este tipo, ya que la mayoría coincide en una posición determinada. Esta sección describe el concepto de mejor/peor para los operadores de combinación. En la siguiente descripción S y T son subexpresiones regulares.

ST

Consideremos dos posibles coincidencias, AB y A'B', A y A' son subcadenas que pueden coincidir con S; B y B' son subcadenas que pueden coincidir con T.

Si A es una mejor coincidencia para S que A', AB es una mejor coincidencia que A'B'.

Si A y A' coinciden: AB es una mejor coincidencia que AB' si B es un mejor coincidencia para T que B'.

S|T

Cuando S puede coincidir, es una mejor coincidencia que cuando sólo puede coincidir T.

Ordenación de dos coincidencias para S es lo mismo que para S. Similar para las dos coincidencias de T.

S{CONTADOR_REPETICIÓN}

Coincide con SSS...S (repetida tantas veces como sea necesario).

S{min,max}

Coincide con S{max}|S{max-1}|...|S{min+1}|S{min}.

S{min,max}?

Coincide con S{min}|S{min+1}|...|S{max-1}|S{max}.

S?, S*, S+

Lo mismo que S{0,1}, S{0,BIG_NUMBER}, S{1,BIG_NUMBER}, respectivamente.

S??, S*?, S+?

Lo mismo que S{0,1}?, S{0,BIG_NUMBER}?, S{1,BIG_NUMBER}? respectivamente.

(?>S)

Coincide con la mejor coincidencia de S y sólo esa.

(?=S), (?<=S)

Sólo es considerada la mejor coincidencia para S. (Esto es importante sólo si S tiene paréntesis de captura, y las retrorreferencias son utilizadas en otra parte de la expresión regular).

(?!S), (?<!S)

Para este operador de agrupación no hay necesidad de describir el orden, ya que sólo es importante si S puede coincidir.

(??{ EXPR }), (?PARNO)

El orden es el mismo que para la expresión regular que sea el resultado de EXPR, o el patrón capturado en el grupo de captura PARNO.

(?(condición)patrón-sí|patrón-no)

Recordemos que realmente ya están determinadas las coincidencias de patrón-sí o de patrón-no. El orden de las coincidencias es el mismo que para la subexpresión seleccionada.

Las recetas anteriores describen el orden de las coincidencias en una determinada posición. Una regla más que se necesita para entender cómo se determina una coincidencia por parte de la expresión regular completa: una coincidencia en una posición anterior es siempre mejor que una coincidencia en una posición más tardía.

Creando motores RE personalizados

A partir de Perl 5.10.0, uno puede crear sus propios motores de expresiones regulares. Esto no es para los débiles de corazón, ya que tienen que conectar a nivel de C. Vea perlreapi para más detalles.

Como alternativa, las constantes sobrecargadas (vea overload) proporcionan una manera sencilla de extender la funcionalidad del motor de RE, mediante la sustitución de un patrón por otro.

Supongamos que se desea habilitar una nueva secuencia de escape RE \Y| que coincide en el límite entre los espacios en blanco y los caracteres no son blancos. Note que (?=\S)(?<!\S)|(?!\S)(?<=\S) coincide exactamente con esas posiciones, así que lo que queremos es usar \Y| en lugar de una versión más complicada. Podemos crear un módulo customre para hacer esto:

package customre;
use overload;

sub import {
  shift;
  die "No se permiten argumentos para customre::import" if @_;
  overload::constant 'qr' => \&convertir;
}

sub invalido { die "/$_[0]/: escape inválido '\\$_[1]'"}

# También hay que tener cuidado de no escapar la legítima
# secuencia \\Y|, y de ahí viene la presencia de '\\' en las reglas de conversión.
my %reglas = ( '\\' => '\\\\',
              'Y|' => qr/(?=\S)(?<!\S)|(?!\S)(?<=\S)/ );
sub convertir {
  my $re = shift;
  $re =~ s{
            \\ ( \\ | Y . )
          }
          { $reglas{$1} or invalido($re,$1) }sgex;
  return $re;
}

Ahora use customre permite usar el nuevo escape en expresiones regulares constantes, es decir, aquellas que no tienen ninguna interpolación de variables en tiempo de ejecución. Como se documenta en overload, esta conversión funcionará solo en las partes literales de las expresiones regulares. Para \Y|$re\Y| la parte variable de esta expresión regular es necesario convertirla de forma explícita (pero sólo si el significado especial de \Y| debe estar habilitado en el interior de $re):

use customre;
$re = <>;
chomp $re;
$re = customre::convertir $re;
/\Y|$re\Y|/;

Soporte PCRE/Python

A partir de Perl 5.10.0, Perl soporta varias extensiones específicas Python/PCRE en la sintaxis de expresiones regulares. Mientras que se anima a los programadores de Perl a usar la sintaxis específica de Perl, lo siguiente también es aceptado:

(?P<NOMBR>patrón)

Define un grupo de captura con nombre. Equivalente a (?<NOMBRE>patrón).

(?P=NOMBRE)

Retrorreferencia a un grupo de captura con nombre. Equivalente a \g{NOMBRE}.

(?P>NOMBRE)

Llamada de una subrutina con un grupo de captura con nombre. Equivalente a (?&NOMBRE).

ERRORES

Muchas construcciones de expresiones regulares no funcionan en plataformas EBCDIC.

Hay una serie de cuestiones con respecto a las coincidencias con las mayúsculas y minúsculas en las reglas Unicode. Vea i bajo "Modificadores", más arriba.

Este documento varía de "difícil de entender" a "completa y totalmente opaco". La prosa errante llena de jerga es difícil de entender, en varios lugares.

Este documento necesita una reescritura que separe el contenido de manual del contenido de referencia.

VEA TAMBIÉN

perlrequick.

perlretut.

Ver "Operadores Regexp entrecomillados" in perlop.

"Gory details of parsing quoted constructs" in perlop.

perlfaq6.

"pos" in perlfunc.

perllocale.

perlebcdic.

Mastering Regular Expressions de Jeffrey Friedl, publicado por O'Reilly y Asociados.

POD ERRORS

Hey! The above document had some coding errors, which are explained below:

Around line 6:

Non-ASCII character seen before =encoding in 'DESCRIPCIÓN'. Assuming UTF-8