RegExp Perl Python Java Etc

Machine Translated by Google
Expresión regular
Referencia de bolsillo
SEGUNDA EDICION
Expresión regular
Referencia de bolsillo
Tony Stubblebine
Pekín • Cambridge • Farnham • Colonia • París • Sebastopol • Taipéi • Tokio

Referencia de bolsillo de expresiones regulares, segunda

edición de Tony Stubblebine
Copyright © 2007, 2003 Tony Stubblebine. Reservados todos los derechos. Partes de este libro
se basan en Mastering Regular Expressions, de Jeffrey EF Friedl, Copyright © 2006, 2002, 1997
O'Reilly Media, Inc.
Impreso en Canadá.
Publicado por O'Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
Los libros de O'Reilly se pueden comprar con fines educativos, comerciales o de

promoción de ventas. Las ediciones en línea también están disponibles para la
mayoría de los títulos (safari.oreilly.com). Para obtener más información, comuníquese
con nuestro departamento de ventas corporativo/institucional: (800) 9989938 o corporate@oreilly.com.
Montaje: Andy Oram Indexador: Johnna VanHoose Dinse

Editor de producción: Sumita Mukherji Diseño de portada: Karen Montgomery
Correctora: Genevieve d'Entremont Diseñador de interiores: David Futato
Historial de impresión:
agosto de 2003: Primera edición.

julio de 2007: Segunda edicion.
Nutshell Handbook, el logotipo de Nutshell Handbook y el logotipo de O'Reilly son marcas

comerciales registradas de O'Reilly Media, Inc. Las designaciones de la serie Pocket Reference ,
Regular Expression Pocket Reference, la imagen de búhos y la imagen comercial relacionada
son marcas comerciales de O' Reilly Media, Inc.
Muchas de las designaciones utilizadas por los fabricantes y vendedores para distinguir sus
productos se reclaman como marcas comerciales. Donde esas designaciones aparecen en este
libro, y O'Reilly Media, Inc. tenía conocimiento de un reclamo de marca registrada, las
designaciones se han impreso en mayúsculas o iniciales en mayúsculas.
Java™ es una marca comercial de Sun Microsystems, Inc. Microsoft Internet Explorer y .NET son
marcas comerciales registradas de Microsoft Corporation. SpiderMan es una marca registrada
de Marvel Enterprises, Inc.
Si bien se han tomado todas las precauciones en la preparación de este libro, el editor y el autor
no asumen ninguna responsabilidad por errores u omisiones, o por daños que resulten del uso de
la información aquí contenida.
ISBN10: 0596514271
ISBN13: 9780596514273
[T]
Contenido
Sobre este libro 1
Introducción a expresiones regulares y coincidencia de patrones 3
Metacaracteres Regex, modos y construcciones 5
Soporte Unicode 13
Libro de recetas de expresiones regulares 13
Recetas 14
Perl 5.8 16
Metacaracteres admitidos 17
Operadores de expresiones regulares 21
Ejemplos de 23
compatibilidad 24
con Unicode Otros recursos 25
Java (java.util.regex) 26
Metacaracteres admitidos 26
Expresiones regulares Clases e interfaces Ejemplos 30
de compatibilidad 35
con Unicode 36
Otros recursos 38
v
.NET y C# 38
Metacaracteres compatibles 38
Clases e interfaces de expresiones regulares 42
Soporte Unicode 47
Ejemplos 47
Otros recursos 49
PHP 50
Funciones de coincidencia de patrones 54
Ejemplos 56
Otros recursos 58
Pitón 58
con objetos y funciones del módulo 61
Soporte Unicode 64
Ejemplos sesenta y cinco
Otros recursos 66
RUBÍ 66
Interfaz orientada a objetos 70
Soporte Unicode 75
Ejemplos 75
JavaScript 77
Objetos y métodos de coincidencia de patrones 79
Ejemplos 82
Otros recursos 83
vi | Contenido
PCRE 83
API PCRE 89
Soporte Unicode 92
Ejemplos 92
Otros recursos 96
Servidor Web Apache 96
Regla de reescritura 99
Directivas coincidentes 102
Ejemplos 102
vi Redactor 103
La coincidencia de patrones 106
Ejemplos 108
Otros recursos 108
Herramientas de concha 109
Otros recursos 114
Índice 115
Contenidos | viii
Bolsillo de expresión regular

Referencia
Las expresiones regulares son un lenguaje utilizado para analizar y manipular

texto. A menudo se utilizan para realizar operaciones complejas de búsqueda y
reemplazo y para validar que los datos de texto estén bien formados.
Hoy en día, las expresiones regulares se incluyen en la mayoría de los

lenguajes de programación, así como en muchos lenguajes de secuencias de
comandos, editores, aplicaciones, bases de datos y herramientas de línea de comandos.
Este libro tiene como objetivo brindar acceso rápido a la sintaxis y las
operaciones de coincidencia de patrones de los más populares de estos
lenguajes para que pueda aplicar su conocimiento de expresiones regulares en
cualquier entorno.
La segunda edición de este libro agrega secciones sobre el servidor web Ruby
y Apache, expresiones regulares comunes y también actualiza los lenguajes
existentes.
Sobre este libro

Este libro comienza con una introducción general a las expresiones regulares.
La primera sección describe y define las construcciones utilizadas en las
expresiones regulares y establece los principios comunes de coincidencia de
patrones. Las secciones restantes del libro están dedicadas a la sintaxis,
características y uso de expresiones regulares en varias implementaciones.
Las implementaciones cubiertas en este libro son Perl, Java™, .NET y C#,
Ruby, Python, PCRE, PHP, servidor web Apache, editor vi , JavaScript y
herramientas de shell.
1
Las convenciones usadas en este libro
En este libro se utilizan las siguientes convenciones tipográficas:
Itálico
Se utiliza para enfatizar, términos nuevos, nombres de programas y
URL
Ancho constante
Se utiliza para opciones, valores, fragmentos de código y cualquier

texto que deba escribirse literalmente
Cursiva de ancho constante
Se utiliza para texto que debe reemplazarse con valores proporcionados por
el usuario
Negrita de ancho constante
Se utiliza en ejemplos de comandos u otro texto que el usuario debe

escribir literalmente.
Agradecimientos Mastering
Regular Expressions (O'Reilly) de Jeffrey EF Friedl es el trabajo definitivo

sobre expresiones regulares. Mientras escribía, confié mucho en su libro y
en sus consejos. Para su comodidad, este libro proporciona referencias
de página a Mastering Regular Expressions, Third Edition (MRE) para una
discusión más amplia de la sintaxis y los conceptos de las expresiones
regulares.
Nat Torkington y Linda Mui fueron excelentes editores que me guiaron a

través de lo que resultó ser una primera edición complicada. Esta edición
contó con la ayuda de las excelentes habilidades editoriales de Andy Oram.
Sarah Burcham merece un agradecimiento especial por darme la
oportunidad de escribir este libro y por sus contribuciones a la sección
"Herramientas de Shell". Más gracias por los aportes y las revisiones
técnicas de Jeffrey Friedl, Philip Hazel, Steve Friedl, Ola Bini, Ian Darwin,
Zak Greant, Ron Hitchens, AM Kuchling, Tim Allwine, Schuyler Erle, David
Lents, Rabble, Rich Bowan, Eric Eisenhart, y Brad Merril.
2 | Referencia de bolsillo de expresiones regulares

Introducción a expresiones regulares y patrones

Pareo
Una expresión regular es una cadena que contiene una combinación de
caracteres normales y metacaracteres especiales o secuencias metase.
Los caracteres normales coinciden entre sí.
Los metacaracteres y las metasecuencias son caracteres o secuencias
de caracteres que representan ideas como cantidad, ubicaciones o tipos
de caracteres. La lista en "Metacaracteres, modos y construcciones
Regex" muestra los metacaracteres y las metasecuencias más comunes
en el mundo de las expresiones regulares.
Las secciones posteriores enumeran la disponibilidad y la sintaxis de
metacaracteres admitidos para implementaciones particulares de
expresiones regulares.
La coincidencia de patrones consiste en encontrar una sección de texto

que se describe (coincide) con una expresión regular. El código subyacente
que busca el texto es el motor de expresiones regulares.
Puede predecir los resultados de la mayoría de los partidos teniendo en
cuenta dos reglas:
1. Gana el partido más temprano (más a la izquierda)
Las expresiones regulares se aplican a la entrada comenzando en el

primer carácter y avanzando hacia el último. Tan pronto como el
motor de expresiones regulares encuentra una coincidencia, regresa.
(Ver MRE 148–149.)
2. Los cuantificadores estándar son

codiciosos Los cuantificadores especifican cuántas veces se puede
repetir algo. Los cuantificadores estándar intentan coincidir tantas
veces como sea posible. Se conforman con menos del máximo sólo
si es necesario para el éxito del partido. El proceso de renunciar a
personajes y probar coincidencias menos codiciosas se llama
retroceso. (Ver MRE 151–153.)
Los motores de expresiones regulares tienen diferencias según su tipo.

Hay dos clases de motores: autómatas finitos deterministas (DFA) y
autómatas finitos no deterministas.
Introducción a expresiones regulares y coincidencia de patrones | 3

(NFA). Los DFA son más rápidos, pero carecen de muchas de las
funciones de un NFA, como la captura, la búsqueda y los cuantificadores
no egoístas. En el mundo NFA, hay dos tipos: tradicional y POSIX.
Los motores
DFA Los DFA comparan cada carácter de la cadena de entrada con
la expresión regular y realizan un seguimiento de todas las
coincidencias en curso. Dado que cada carácter se examina como
máximo una vez, el motor DFA es el más rápido. Una regla adicional
para recordar con los DFA es que la metasecuencia de alternancia
es codiciosa. Cuando coincide más de una opción en una alternancia
(foo|foobar) , se selecciona la más larga. Por lo tanto, la regla No. 1
se puede modificar para que diga "gana la coincidencia más larga a
la izquierda". (Ver MRE 155–156.)
Motores NFA tradicionales

Los motores NFA tradicionales comparan cada elemento de la
expresión regular con la cadena de entrada, realizando un
seguimiento de las posiciones en las que eligió entre dos opciones
en la expresión regular. Si una opción falla, el motor retrocede a la
posición guardada más recientemente. Para los cuantificadores
estándar, el motor elige la opción codiciosa de hacer coincidir más
texto; sin embargo, si esa opción lleva al fracaso de la partida, el
motor vuelve a una posición guardada e intenta un camino menos
codicioso. El motor NFA tradicional usa alternancia ordenada, donde
cada opción en la alternancia se prueba secuencialmente. Se puede
ignorar una coincidencia más larga si una opción anterior conduce a
una coincidencia exitosa. Por lo tanto, aquí la regla n. ° 1 se puede
modificar para que diga "la primera coincidencia más a la izquierda
después de que los cuantificadores codiciosos hayan tenido su relleno gana". (V
Motores POSIX NFA

Los motores POSIX NFA funcionan de manera similar a los NFA
tradicionales con una excepción: un motor POSIX siempre elige la
coincidencia más larga de las más a la izquierda. Por ejemplo, la
alternancia gato|categoría coincidiría con la palabra completa
“categoría” siempre que fuera posible, incluso si la primera alternativa
(“gato”) coincidiera y apareciera antes en la alternancia.
(Ver MRE 153–154.)

Metacaracteres, modos y construcciones de expresiones regulares
Los metacaracteres y las metasecuencias que se muestran aquí

representan la mayoría de los tipos disponibles de construcciones de
expresiones regulares y su sintaxis más común. Sin embargo, la sintaxis
y la disponibilidad varían según la implementación.
Representaciones de caracteres
Muchas implementaciones proporcionan atajos para representar

caracteres que pueden ser difíciles de ingresar. (Ver MRE 115–118.)
Taquigrafías de caracteres
La mayoría de las implementaciones tienen abreviaturas específicas
para los caracteres de alerta, retroceso, escape, salto de página, nueva
línea, retorno de carro, tabulación horizontal y tabulación vertical . Por
ejemplo, \n suele ser una abreviatura del carácter de nueva línea, que
suele ser LF (012 octal), pero a veces puede ser CR (015 octal), según
el sistema operativo. De manera confusa, muchas implementaciones
usan \b para indicar tanto el retroceso como el límite de la palabra
(posición entre un carácter de "palabra" y un carácter que no es una
palabra).
Para estas implementaciones, \b significa retroceso en una clase de
carácter (un conjunto de posibles caracteres para hacer coincidir en
la cadena) y límite de palabras en otros lugares.
Escape octal: \num

Representa un carácter correspondiente a un número octal de dos o
tres dígitos. Por ejemplo, \015\012 coincide con una secuencia ASCII
CR/LF.
Escapes hexadecimales y Unicode: \xnum, \x{num}, \unum, \Unum

Representan caracteres correspondientes a números hexadecimales.
Los números hexadecimales de cuatro dígitos y mayores pueden
representar el rango de caracteres Unicode. Por ejemplo, \x0D\x0A
coincide con una secuencia ASCII CR/LF.
Caracteres de control: \cchar

Corresponde a caracteres de control ASCII codificados con valores
inferiores a 32. Para estar seguro, utilice siempre un carácter en
mayúsculas; algunas implementaciones no manejan minúsculas.

representaciones. Por ejemplo, \cH coincide con ControlH, un carácter de

retroceso ASCII.
Clases de caracteres y construcciones similares a clases
Las clases de caracteres se utilizan para especificar un conjunto de caracteres.

Una clase de caracteres coincide con un solo carácter en la cadena de entrada que
se encuentra dentro del conjunto de caracteres definido. (Ver MRE 118–128.)
Clases normales: [...] y [^...]

Las clases de caracteres, [...] y las clases de caracteres negados, [^...], le
permiten enumerar los caracteres con los que desea o no hacer coincidir.
Una clase de carácter siempre coincide con un carácter. El (guión) indica un
rango de caracteres.
Por ejemplo, [az] coincide con cualquier letra ASCII minúscula.
Para incluir el guión en la lista de caracteres, inclúyalo primero o escápelo.
Casi cualquier caracter: punto (.)

Por lo general, coincide con cualquier carácter excepto una nueva línea. Sin
embargo, el modo de coincidencia generalmente se puede cambiar para que el
punto también coincida con las líneas nuevas. Dentro de una clase de carácter, el
punto coincide solo con un punto.
Abreviaturas de clase: \w, \d, \s, \W, \D,

\S Abreviaturas comúnmente proporcionadas para clases de
caracteres de palabra, dígitos y caracteres de espacio. Un
carácter de palabra suele ser todos los caracteres
alfanuméricos ASCII más el guión bajo. Sin embargo, la lista
de alfanuméricos puede incluir locale adicional o alfanuméricos
Unicode, según la implementación. Una abreviatura en
minúsculas (p. ej., \s) coincide con un carácter de la clase;
mayúsculas (p. ej., \S) coincide con un carácter que no
pertenece a la clase. Por ejemplo, \d coincide con un carácter
de un solo dígito y suele ser equivalente a [09].
clase de carácter POSIX: [:alnum:]

POSIX define varias clases de caracteres que solo se pueden usar dentro de
las clases de caracteres de expresiones regulares (consulte la Tabla 1).

Tomemos, por ejemplo, [:inferior:]. Cuando se escribe como [[:lower:]], es
equivalente a [az] en la configuración regional ASCII.

Tabla 1. Clases de caracteres POSIX
Clase Significado
Alnum Letras y dígitos.
Letras.
Alfa
Blanco Solo espacio o tabulador.
Controlar Personajes de control.
Dígito Dígitos decimales.
Grafico Caracteres de impresión, sin espacio.
Más bajo Letras minusculas.
Imprimir Impresión de caracteres, incluido el espacio.
punto Impresión de caracteres, excepto letras y dígitos.
Espacio Espacio en blanco.
Superior Letras mayúsculas.
Xdígito dígitos hexadecimales.
Propiedades Unicode, scripts y bloques: \p{prop}, \P{prop}

El estándar Unicode define clases de caracteres que tienen una propiedad
particular, pertenecen a un script o existen dentro de un bloque. Las
propiedades son las características que definen al carácter, como ser una
letra o un número (ver Tabla 2).
Los guiones son sistemas de escritura, como el hebreo, el latín o el han.
Los bloques son rangos de caracteres en el mapa de caracteres Unicode.
Algunas implementaciones requieren que las propiedades Unicode tengan
el prefijo Is o In. Por ejemplo, \p{Ll} coincide con letras minúsculas en
cualquier idioma compatible con Unicode, como a o α.
Combinación de secuencia de caracteres Unicode: \X

Coincide con un carácter base Unicode seguido de cualquier número de
caracteres combinados Unicode. Esta es una abreviatura de \P{M}\p{M}.
Por ejemplo, \X coincide con è; así como los dos caracteres e'.

Tabla 2. Propiedades Unicode estándar
Propiedad Significado
\p{L} Letras.
\p{ll} Letras minusculas.
\p{Lm} Letras modificadoras.
\OLP} Cartas, otros. Estos no tienen caso, y no se consideran modificadores.
\p{Lt} Letras de mayúsculas y minúsculas.
\p{Lu} Letras mayúsculas.
\ordenador personal} Códigos de control y caracteres que no están en otras categorías.
\p{CC} Caracteres de control ASCII y Latin1.
\p{Cf} Caracteres de formato no visibles.
\p{Cn} Puntos de código no asignados.
\p{Co} Uso privado, como logotipos de empresas.
\p{Cs} sustitutos
\pm} Marcas destinadas a combinarse con caracteres básicos, como los acentos.
\p{Mc} Modificación de personajes que ocupan su propio espacio. Los ejemplos incluyen
"signos vocálicos".
\p{Yo} Marcas que encierran otros caracteres, como círculos, cuadrados y rombos.
\p{Mn} Caracteres que modifican otros caracteres, como acentos y diéresis.
\p{N} Caracteres numéricos.
\p{Nd} Dígitos decimales en varias escrituras.
\p{NL} Letras que representan números, como los números romanos.
\p{No} Superíndices, símbolos o caracteres que no son dígitos que representan

números.
\páginas} Puntuación.
\p{PC} Conexión de puntuación, como un guión bajo.
\p{Pd} Guiones y guiones.
\p{Pe} Puntuación de cierre que complementa a \p{Ps}.
\p{Pi} Puntuación inicial, como comillas de apertura.

Tabla 2. Propiedades Unicode estándar (continuación)
Propiedad Significado
\p{Pf} Puntuación final, como comillas de cierre.
\p{Po} Otros signos de puntuación.
\p{Pd} Puntuación de apertura, como paréntesis de apertura.
\PD} Símbolos.
\p{Sc} Divisa.
\p{Sk} Combinación de caracteres representados como caracteres individuales.
\p{Sm} Símbolos matemáticos.
\p{Entonces} Otros símbolos.
\p{Z} Separación de personajes sin representación visual.
\p{Zl} Separadores de línea.
\p{Zp} Separadores de párrafo.
\p{Zs} Caracteres espaciales.
Anclajes y aserciones de ancho cero
Los anclajes y las "afirmaciones de ancho cero" coinciden con las posiciones en
la cadena de entrada. (Ver MRE 128–134.)
Inicio de línea/cadena: ^, \A
Coincide con el principio del texto que se busca. En modo multilínea, ^
coincide después de cualquier salto de línea. Algunas implementaciones
admiten \A, que coincide solo al principio del texto.
Fin de línea/cadena: $, \Z, \z $

coincide con el final de una cadena. En el modo multilínea, $ coincide antes
de cualquier salto de línea. Cuando se admite, \Z coincide con el final de la
cadena o el punto anterior a una nueva línea que termina con una cadena,
independientemente del modo de coincidencia. Algunas implementaciones
también proporcionan \z, que coincide solo con el final de la cadena,
independientemente de las líneas nuevas.

Comienzo de la coincidencia:
\G En la coincidencia iterativa, \G coincide con la posición donde terminó la coincidencia
anterior. A menudo, este lugar se restablece al comienzo de una cadena en una coincidencia
fallida.
Límite de palabra: \b, \B, \<, \>

Los metacaracteres de límite de palabra coinciden con una ubicación donde un carácter de
palabra está junto a un carácter que no es de palabra. \b a menudo especifica una ubicación
de límite de palabra, y \B a menudo especifica una ubicación que no es de límite de palabra.
Algunas implementaciones proporcionan metasecuencias separadas para los límites de inicio
y fin de palabra, a menudo \< y \>.
Previsión: (?=...), (?!...)

Mirar atrás: (?<=...), (?<!...)
Las construcciones de búsqueda coinciden con una ubicación en el texto donde el subpatrón
coincidiría (búsqueda anticipada), no coincidiría (búsqueda negativa), habría terminado de
coincidir (búsqueda atrás) o no habría terminado de coincidir (búsqueda negativa atrás). Por
ejemplo, foo(?=bar) coincide con foo en foobar, pero no con comida. Las implementaciones a
menudo limitan las construcciones de búsqueda posterior a subpatrones con una longitud
predeterminada.
Comentarios y modificadores de modo
Los modificadores de modo cambian la forma en que el motor de expresiones regulares interpreta
una expresión regular. (Ver MRE 110–113, 135–136.)
Modo multilínea: m Cambia
el comportamiento de ^ y $ para que coincidan con las nuevas líneas dentro de la cadena de
entrada.
Modo de una sola línea: s
Cambia el comportamiento de . (punto) para hacer coincidir todos los caracteres, incluidas las
líneas nuevas, dentro de la cadena de entrada.
Modo insensible a mayúsculas y minúsculas: i
Trate las letras que difieren solo en mayúsculas y minúsculas como idénticas.

Modo de espacio libre: x

Permite espacios en blanco y comentarios dentro de una expresión
regular. El motor de expresiones regulares ignora los espacios en
blanco y los comentarios (que comienzan con # y se extienden hasta el
final de la línea).
Modificadores de modo: (?i), (?i), (?mod:...)

Por lo general, los modificadores de modo se pueden establecer dentro
de una expresión regular con (?mod) para activar los modos para el
resto de la subexpresión actual; (?mod) para desactivar los modos
para el resto de la subexpresión actual; y (?mod:...) para activar o
desactivar los modos entre los dos puntos y los paréntesis de cierre.
Por ejemplo, usar (?i:perl) coincide con usar perl, usar Perl, usar PeRl,
etc.
Comentarios: (?#...) y # En el
modo de espacio libre, # indica que el resto de la línea es un comentario.
Cuando se admita, el intervalo de comentarios (?#...) se puede incrustar
en cualquier lugar de una expresión regular, independientemente del
modo. Por ejemplo, .{0,80}(?#El límite del campo es de 80 caracteres)
le permite tomar notas sobre por qué escribió .{0,80}.
Intervalo de texto literal: \Q...\E

Escapa los metacaracteres entre \Q y \E. Por ejemplo, \Q(.*)\E es lo
mismo que $\.\*$.
Agrupación, captura, condicionales y control Esta sección
cubre la sintaxis para agrupar subpatrones, capturar subcoincidencias,

subcoincidencias condicionales y cuantificar el número de veces que un
subpatrón coincide. (Ver MRE 137–142.)
Paréntesis de captura y agrupación: (...) y \1, \2, etc.

Los paréntesis cumplen dos funciones: agrupar y capturar. El texto que
coincide con el subpatrón entre paréntesis se captura para su uso
posterior. Los paréntesis de captura se numeran contando sus
paréntesis de apertura desde la izquierda.
Si hay referencias anteriores disponibles, se puede hacer referencia a
la subcoincidencia más adelante en la misma coincidencia con \1, \2, etc.

el texto capturado está disponible después de una coincidencia mediante

métodos específicos de implementación. Por ejemplo, \b(\w+)\b \s+\1\b
coincide con palabras duplicadas, como the.
Paréntesis de solo agrupación: (?:...)

Agrupa una subexpresión, posiblemente por alternancia o cuantificadores,
pero no captura la subcoincidencia. Esto es útil para la eficiencia y la
reutilización. Por ejemplo, (?:foobar) coincide con foobar, pero no guarda
la coincidencia en un grupo de captura.
Captura con nombre: (?<nombre>...)

Realiza capturas y agrupaciones, con el texto capturado posteriormente
referenciado por su nombre. Por ejemplo, Asunto:(?<asunto>.*) captura
el texto que sigue a Asunto: para capturar un grupo al que se puede
hacer referencia mediante el nombre asunto.
Agrupación atómica: (?>...)

El texto coincidente dentro del grupo nunca se retrocede, incluso si esto
conduce a una falla de coincidencia. Por ejemplo, (?>[ab]*)\w\w coincide
con aabbcc, pero no con aabbaa.
Alternancia: ...|...
Permite probar varias subexpresiones. La baja precedencia de la
alternancia a veces hace que las subexpresiones sean más largas de lo
previsto, así que use paréntesis para agrupar específicamente lo que
desea alternar. Por lo tanto, \b(foo|bar)\b coincide con las palabras foo o
bar.
Condicional: (?(si)entonces |si no)

El if depende de la implementación, pero generalmente es una referencia
a una subexpresión capturada o una búsqueda.
Las partes then y else son patrones de expresión regular. Si la parte if
es verdadera, entonces se aplica. De lo contrario, se aplica else . Por
ejemplo, (<)?foo(?(1)>|bar) coincide con <foo> así como con foobar.
Cuantificadores codiciosos: *, +, ?, {num,num }

Los cuantificadores codiciosos determinan cuántas veces se puede
aplicar una construcción. Intentan emparejar tantas veces como sea
posible, pero darán marcha atrás y abandonarán los partidos si es
necesario para el éxito del partido en general. Por ejemplo, (ab)+ coincide
con todo ababababab.

Cuantificadores perezosos: *?, +?, ??, {num,num }?
Los cuantificadores perezosos controlan cuántas veces se puede aplicar

una construcción. Sin embargo, a diferencia de los cuantificadores
codiciosos, intentan coincidir el menor número de veces posible. Por
ejemplo, (un)+? coincide sólo con una de plátano.
Cuantificadores posesivos: *+, ++, ?+, {num,num }+ Los

cuantificadores posesivos son como los cuantificadores codiciosos, excepto
que "bloquean" su coincidencia, impidiendo el seguimiento posterior posterior
para dividir la subcoincidencia. Por ejemplo, (ab)++ab no coincidirá con
ababababab.
Compatibilidad con
Unicode El conjunto de caracteres Unicode otorga números únicos a los

caracteres en todos los idiomas del mundo. Debido a la gran cantidad de
caracteres posibles, Unicode requiere más de un byte para representar un
carácter. Algunas implementaciones de expresiones regulares no
comprenderán los caracteres Unicode porque esperan caracteres ASCII de 1
byte. La compatibilidad básica con los caracteres Unicode comienza con la
capacidad de hacer coincidir una cadena literal de caracteres Unicode. El
soporte avanzado incluye clases de caracteres y otras construcciones que
incorporan caracteres de todos los idiomas compatibles con Unicode. Por
ejemplo, \w podría coincidir con è; así como e.
Libro de recetas de expresiones regulares
Esta sección contiene versiones simples de patrones de expresiones regulares

comunes. Es posible que deba ajustarlos para satisfacer sus necesidades.
Cada expresión se presenta aquí con las cadenas objetivo con las que
coincide y las cadenas objetivo con las que no coincide, para que pueda
tener una idea de los ajustes que puede necesitar hacer para
sus propios casos de uso.
Están escritos en estilo Perl:
/patrón/modo
s/patrón/reemplazo/modo
Libro de recetas de expresiones regulares | 13

Recetas
Eliminación de espacios en blanco iniciales y finales
s/^\s+// s/
\s+$//
Coincidencias:" foo bar ", "foo "
No coincidencias: "foo bar"
Números del 0 al 999999
/^\d{1,6}$/
Partidos: 42, 678234
No coincidencias: 10,000
Código hexadecimal HTML válido
/^#([afAF09]){3}(([afAF09]){3})?$/
Coincidencias: #fff, #1a1, #996633
No coincidencias: #ff, FFFFFF
Número de Seguro Social EE.UU
/^\d{3}\d{2}\d{4}$/
Partidos: 078051120
No coincidencias: 078051120, 12341212
código postal de EE. UU.
/^\d{5}(\d{4})?$/
Partidos: 949413232, 10024
No partidos: 949413232
moneda estadounidense
/^\$\(d{1,3}(\,\d{3})*|\d+)(\.\d{2})?$/
Partidos: $20, $15,000.01
No coincidencias: $1.001, $.99

Fecha del partido: MM/DD/AAAA HH:MM:SS
/^\d\d\/\d\d\/\d\d\d\d \d\d:\d\d:\d\d$/
Partidos: 30/04/1978 20:45:38
No coincidencias: 30/4/1978 20:45:38, 30/4/78
Nombre de ruta principal
/^.*\//
Coincidencias: /usr/local/bin/apachectl No
coincidencias: C:\\System\foo.exe
(Ver MRE 190–192.)
Dirección IP cuádruple punteada
/^(\d|[01]?\d\d|2[04]\d|25[05])\.(\d|[01]?\d\d|2[0 4] \d|25[05])\. (\d|

[01]?\d\d|
2[04]\d|25[05])\.(\d|[01]?\d\d|2[04] \d|25[05])$/
Partidos: 127.0.0.1, 224.22.5.110
No coincidencias: 127.1
(Ver MRE 187–189.)
Dirección MAC
/^([09afAF]{2}:){5}[09afAF]{2}$/
Partidos: 01:23:45:67:89:ab
No coincidencias: 01:23:45, 0123456789ab
Correo electrónico
/^[09azAZ]([.\w]*[09azAZ_+])*@([09azAZ][\w]* [0 9azAZ]
\.)+[azAZ]{2,9}$/
Coincidencias: tony@example.com, tony@ie.com, tony@mail.

ejemplo.museo
No coincidencias: .@example.com, tony@i.com, tony@example.a
(Ver MRE 70.)
Libro de recetas de expresiones regulares | 15

URL HTTP
/(https?):\/\/([09azAZ][\w]*[09azAZ]\.)+ [azAZ]
{2,9 }) (:\d{1,4})?
([\w\/#~:.?+=&%@~]*)/
Coincidencias: https://example.com, http://foo.com:8080/bar.html No
coincidencias: ftp://foo.com, ftp://foo.com/
Perl 5.8
Perl proporciona un amplio conjunto de operadores de expresiones
regulares, construcciones y características, y se agregan más en cada
nueva versión. Perl utiliza un motor de coincidencia NFA tradicional. Para
obtener una explicación de las reglas detrás de un motor NFA, consulte
"Introducción a expresiones regulares y coincidencia de patrones".
Esta referencia cubre la versión 5.8 de Perl. Se introducirán varias
características nuevas en Perl 5.10; estos se tratan en la Tabla 8. Las
funciones Unicode se introdujeron en 5.6, pero no se estabilizaron hasta
5.8. La mayoría de las demás funciones funcionan en las versiones 5.004
y posteriores.
Metacaracteres admitidos Perl es
compatible con los metacaracteres y las metasecuencias enumerados en

la Tabla 3 a la Tabla 7. Para obtener más información sobre las definiciones
ampliadas de cada metacarácter, consulte “Metacaracteres, modos y
construcciones Regex”.
Tabla 3. Representaciones de caracteres de Perl
Secuencia Significado
\a Alerta (campana).
\b Retroceso; admitido solo en la clase de caracteres (fuera de la

clase de caracteres coincide con un límite de palabra).
\mi Esc carácter, x1B.
\norte Nueva línea; x0A en Unix y Windows, x0D en Mac OS 9.
\r Retorno de carro; x0D en Unix y Windows, x0A en Mac OS 9.

Tabla 3. Representaciones de caracteres de Perl (continuación)
\F Avance de formulario, x0C.
\t Pestaña horizontal, x09.
\ octal Carácter especificado por un código octal de dos o tres dígitos.
\xhex Carácter especificado por un código hexadecimal de uno o dos dígitos.
\x{hexadecimal} Carácter especificado por cualquier código hexadecimal.
\cchar Carácter de control con nombre.
\N{nombre} Un carácter con nombre especificado en el estándar Unicode o incluido en
PATH_TO_PERLLIB/unicode/Names.txt; requiere uso

charnames ':full'.
Tabla 4. Clases de caracteres de Perl y construcciones similares a clases
Clase Significado
[...] Un solo carácter enumerado o contenido en un rango enumerado.
[^...] Un solo carácter que no aparece en la lista y que no está contenido dentro de un rango
de la lista.
[:clase:] Clase de caracteres de estilo POSIX válida solo dentro de una clase de caracteres
regex.
. Cualquier carácter excepto nueva línea (a menos que el modo de una sola línea, /s).
\C un byte; sin embargo, esto puede corromper un carácter Unicode

arroyo.
\X Carácter base, seguido de cualquier número de caracteres combinados Unicode.
\w Carácter de palabra, \p{IsWord}.
\W Carácter sin palabra, \P{IsWord}.
\d Carácter de dígito, \p{IsDigit}.
\D Carácter sin dígitos, \P{IsDigit}.
\s Carácter de espacio en blanco, \p{IsSpace}.
\S Carácter sin espacio en blanco, \P{IsSpace}.
\p{accesorio} Carácter contenido por una propiedad, secuencia de comandos o bloque Unicode determinado.
\P{accesorio} Carácter no incluido en una propiedad, secuencia de comandos o bloque de Unicode

determinado.
Perl 5.8 | 17
Tabla 5. Anclajes de Perl y pruebas de ancho cero
^ Comienzo de la cadena o, en el modo de coincidencia multilínea (/m), la posición después
de cualquier salto de línea.
\A Inicio de la cadena de búsqueda, en todos los modos de coincidencia.
Fin de la cadena de búsqueda o el punto anterior a una nueva línea que finaliza la cadena o,
ps
en el modo de coincidencia multilínea (/m), la posición anterior a cualquier nueva

línea.
\Z Fin de cadena, o el punto anterior a una nueva línea que finaliza una cadena, en cualquier
modo de coincidencia.
\z Fin de la cadena, en cualquier modo de coincidencia.
\GRAMO Comienzo de la búsqueda actual.
\b Límite de palabras.
\B Nopalabralímite.
Previsión positiva.
(?=...)
(?!...) Previsión negativa.
(?<=...) Mirada positiva hacia atrás; solo de longitud fija.
(?<!...) Mirada negativa hacia atrás; solo de longitud fija.
Tabla 6. Comentarios de Perl y modificadores de modo
modificador Significado
/i Coincidencia que no distingue entre mayúsculas y minúsculas.
/metro ^ y $ coinciden junto a \n incrustado.
/s El punto (.) coincide con la nueva línea.
/X Ignore los espacios en blanco y permita comentarios (#) en el patrón.
/o Compile el patrón solo una vez.
(?modo) Active los modos enumerados (uno o más de xsmi) para el resto de la subexpresión.
(?modo) Desactive los modos enumerados (uno o más de xsmi) para el resto de la subexpresión.
(?modo:...) Active los modos enumerados (uno o más de xsmi) entre paréntesis.
(?modo:...) Desactive los modos enumerados (uno o más de xsmi) entre paréntesis.

Tabla 6. Comentarios de Perl y modificadores de modo (continuación)
(?#...) Trate la subcadena como un comentario.
#... Trata el resto de la línea como un comentario en modo /x .
\u Forzar el siguiente carácter a mayúsculas.
\l Forzar el siguiente carácter a minúsculas.
\U Forzar todos los siguientes caracteres a mayúsculas.
\L Forzar todos los siguientes caracteres a minúsculas.
\Q Cita todos los siguientes metacaracteres de expresiones regulares.
\MI Finaliza un lapso que comienza con \U, \L o \Q.
Tabla 7. Agrupación, captura, condicional y control de Perl
(...) Agrupe el subpatrón y capture la subcoincidencia en \1,\2, . . . y $1, $2,....
\norte Contiene texto que coincide con el grupo de captura n.
(?:...) Agrupa el subpatrón, pero no captura la subcoincidencia.
(?>...) Agrupación atómica.
...|... Pruebe subpatrones en alternancia.
* Coincide 0 o más veces.
+ Coincidir 1 o más veces.
? Partido 1 o 0 veces.
{norte} Coincidir exactamente n veces.
{n,} Coincide al menos n veces.
{x,y} Coincidir al menos x veces, pero no más de y veces.
*? Haga coincidir 0 o más veces, pero la menor cantidad de veces posible.
+? Combina 1 o más veces, pero la menor cantidad de veces posible.
?? Coincidir 0 o 1 veces, pero la menor cantidad de veces posible.
{norte,}? Haga coincidir al menos n veces, pero la menor cantidad de veces posible.
{x, y}? Haga coincidir al menos x veces, y no más de y veces, pero la menor cantidad de veces
posible.
Perl 5.8 | 19
Tabla 7. Agrupación, captura, condicional y control de Perl (continuación)
(?(COND)...| ...) Coincide con el patrón ifthenelse, donde COND es un número entero que se
refiere a una referencia inversa o una aserción de búsqueda.
(?(COND)...) Empareja con el patrón sientonces.
(?{CÓDIGO}) Ejecutar código Perl incrustado.
(??{CÓDIGO}) Haga coincidir la expresión regular del código Perl incrustado.
Tabla 8. Nuevas funciones en Perl 5.10
(?<nombre>...)o Grupo de captura con nombre.

(?'nombre'...)
\k<nombre> o Referencia inversa al grupo de captura nombrado.

\k'nombre'
%+ Hash referencia a la captura más a la izquierda de un nombre dado, $+{foo}.
% Referencia hash a una matriz de todas las capturas de un nombre dado, ${foo}
[0].
\g{n} o \gn \g{n} Referencia posterior a la enésima captura.
o \gn Retrorreferencia relativa a la enésima captura anterior.
(?norte) Recurre al enésimo búfer de captura.
(?&NOMBRE) Recurre al búfer de captura nombrado.
(?R) Llame recursivamente a la expresión completa.
(?(DEFINE)...) Defina una subexpresión en la que se pueda recurrir.
(*FALLAR) Falle la subcoincidencia y obligue al motor a retroceder.
(*ACEPTAR) Obligue al motor a aceptar la coincidencia, incluso si hay más patrones para verificar.
(*CIRUELA PASA) Hacer que el partido falle desde la posición inicial actual.
(*MARCA:nombre) Marca y nombra la posición actual en la cadena. El puesto está disponible en

$REGMARK.
(*Omita el nombre) Rechazar todas las coincidencias hasta el punto en que se ejecutó la MARCA
nombrada.
(*ENTONCES) Cuando retroceda, salte a la siguiente alternancia.

Tabla 8. Nuevas funciones en Perl 5.10 (continuación)
(* COMPROMISO) / Cuando se retrocede, hace que la coincidencia falle por completo.
p Modificador de modo que habilita las variables ${^PREMATCH}, ${MATCH} y $

{^POSTMATCH} .
\K Excluya el texto coincidente previamente de la coincidencia final.
Operadores de expresiones regulares
Perl proporciona los operadores integrados de expresiones regulares

qr//, m// y s///, así como la función de división . Cada operador acepta
una cadena de patrón de expresión regular que se ejecuta a través
de la interpolación de cadenas y variables y luego se compila.
Las expresiones regulares a menudo se delimitan con la barra

diagonal, pero puede elegir cualquier carácter que no sea
alfanumérico ni espacios en blanco. Aquí hay unos ejemplos:
¡metro!...! m{...} s[...][...]
qr#...#s|...|...| s<...>/.../
Una coincidencia delimitada por barras (/.../) no requiere una m inicial:
/.../ #igual que m/.../
El uso de comillas simples como delimitador suprime la

interpolación de variables y las construcciones \N{nombre}, \u,
\l, \U, \L, \Q y \E. Normalmente, estos se interpolan antes de
pasar al motor de expresiones regulares.
qr// (Comillas Regex)
qr/PATRÓN/ismxo
Cita y compila PATTERN como una expresión regular. El valor devuelto se puede utilizar en una sustitución o
coincidencia de patrón posterior. Esto ahorra tiempo si la expresión regular se va a interpolar repetidamente. Los
modos de coincidencia (o la falta de ellos), /ismxo, están bloqueados.
Perl 5.8 | 21
m// (coincidencia)
m/PATRÓN/imsxocg
Haga coincidir el PATRÓN con la cadena de entrada. En el contexto de la lista,

devuelve una lista de subcadenas que coinciden con paréntesis de captura, o bien
(1) para una coincidencia correcta o ( ) para una coincidencia fallida. En contexto
escalar, devuelve 1 para éxito o "" para error. /imsxo son modificadores de modo
opcionales. /cg son modificadores de coincidencia opcionales. /g en contexto escalar
hace que la coincidencia comience desde el final de la coincidencia anterior. En el
contexto de la lista, una coincidencia /g devuelve todas las coincidencias o todas las
subcadenas capturadas de todas las coincidencias. Una coincidencia fallida de /g
restablecerá el inicio de la coincidencia al principio de la cadena, a menos que la
coincidencia esté en modo combinado /cg .
s/// (Sustitución)
s/PATRÓN/REEMPLAZO/egimosx
Haga coincidir PATRÓN en la cadena de entrada y reemplace el texto de coincidencia

con REEMPLAZO, devolviendo el número de éxitos. /imosx son modificadores de
modo opcionales. /g sustituye todas las apariciones de PATTERN.
Cada /e provoca una evaluación de REEMPLAZO como código Perl.
dividir
split /PATRÓN/, EXPR, LIMIT

split /PATRÓN/, EXPR
split /PATRÓN/
split
Devuelve una lista de subcadenas que rodean las coincidencias de PATRÓN en EXPR.
Si se incluye LIMIT , la lista contiene subcadenas que rodean las primeras
coincidencias de LIMIT . El argumento del patrón es un operador de coincidencia,
así que use m si desea delimitadores alternativos (p. ej., dividir m{PATRÓN}). La
coincidencia permite los mismos modificadores que m{}. La Tabla 9 enumera las
variables posteriores al partido.

Tabla 9. Variables posteriores al partido de Perl
Variable Significado
$1, $2, ... Subcoincidencias capturadas.
@ $[0]: desplazamiento del inicio del partido.
$[n]: desplazamiento del inicio de $n.
@+ $+[0]: compensación del final del partido.
$+[n]: desplazamiento del final de $n.
$+ Última coincidencia entre paréntesis.
ps Texto antes del partido. Hace que todas las expresiones regulares sean más lentas.
Igual que substr($entrada, 0, $[0]).
ps Texto del partido. Hace que todas las expresiones regulares sean más lentas. Igual que
substr($entrada, $[0], $+[0] $[0]).
$` Texto después del partido. Hace que todas las expresiones regulares sean más lentas.
Igual que substr($entrada, $+[0]).
$^N Texto de los paréntesis de captura cerrados más recientemente.
ps Si es verdadero, se asume /m para todas las coincidencias sin /s.
$^R El valor de resultado de la construcción de código ejecutada más recientemente

dentro de una coincidencia de patrón.
Compatibilidad con
Unicode Perl proporciona compatibilidad integrada con Unicode 3.2, incluida

la compatibilidad total con las metasecuencias \w, \d, \s y \b .
Las siguientes construcciones respetan la configuración regional actual si se

define use locale : modo insensible a mayúsculas y minúsculas (i) , \L, \l, \U,
\u, \w y \W.
Perl admite las propiedades Unicode estándar (consulte la Tabla 3), así
como las propiedades compuestas específicas de Perl (consulte la Tabla 10).
Los scripts y las propiedades pueden tener un prefijo Is , pero no lo
requieren. Los bloques requieren un prefijo In solo si el nombre del bloque
entra en conflicto con el nombre de un script.
Perl 5.8 | 23
Tabla 10. Propiedades Unicode compuestas de Perl
Propiedad Equivalente
esASCII [\x00\x7f]
esAlnum [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}] [\p{Ll}\p{Lu}\p{Lt}
esalfa \p{Lo}] \ p{C} \p{Nd} [^\p{C}\p{Espacio}]

EsControlar \p{Ll}
esDigit
esGraph
Es bajo
esimprimir \P{C}
espuntual \p{P}
esespacio [\t\n\f\r\p{Z}] [\p{Lu}
essuperior \p{Lt}] [_\p{Ll}\p{Lu}

esPalabra \ p{Lt}\p{Lo}\p{Nd}] [09afAF]
esXDigit
Ejemplos
Ejemplo 1. Coincidencia simple
# Encuentra a SpiderMan, Spiderman, SPIDERMAN, etc. my

$dailybugle = "¡SpiderMan amenaza la ciudad!"; if ($dailybugle
=~ m/spider[ ]?man/i) { hacer_algo( ); }
Ejemplo 2. Partido, grupo de captura y qr
# Coincidencia de fechas formateadas como DD/MM/AAAA, DDMMAA,... my

$fecha = "30/12/1969"; my $regex =
qr!^(\d\d)[/](\d\d)[/](\d\d(?:\d\d)?)$!; if ($fecha =~ $regex) { print "Día= ", $1, "
Mes=", $2, Año= ", $3;
"

Ejemplo 3. Sustitución simple
# Convertir a para cumplir con XHTML

my $text = "¡Hola mundo! ";
$texto =~ s# # #ig;
Ejemplo 4. Sustitución más difícil
# urlify convierte URLs en enlaces

HTML $text = "Consulte el sitio web, http://www.oreilly.com/catalog/
regexppr.";
$texto
=~ s{ \b # comenzar en el límite de la palabra ( # capturar a

$1 (https?|telnet|gopher|file|wais|ftp) :
# recurso y dos puntos

[\w/#~:.?+=&%@!\] +? # uno o más #
caracteres
válidos # pero tome lo
menos # posible
) (? # mirar hacia el futuro
= [.:?\] * # para una posible puntuación (?: [^\w/#~:.?

+=&%@!\] # carácter no válido # o final de cadena
| ps
) }{<a href="$1">$1</a>}igox;
Otros recursos
• Programación Perl, por Larry Wall et al. (O'Reilly), es la referencia estándar
de Perl.
• Mastering Regular Expressions, Third Edition, de Jeffrey EF Friedl (O'Reilly),

cubre los detalles de las expresiones regulares de Perl en las páginas
283–364.
• perlre es la documentación de perldoc proporcionada con la mayoría de las

distribuciones de Perl.
Perl 5.8 | 25
Java (java.util.regex)
Java 1.4 introdujo expresiones regulares con Java de Sun. paquete util.regex .
Aunque hay paquetes de la competencia disponibles para versiones
anteriores de Java, el de Sun es ahora el estándar. El paquete de Sun utiliza
un motor de coincidencia NFA tradicional.
Para obtener una explicación de las reglas detrás de un motor NFA tradicional,
consulte "Introducción a expresiones regulares y coincidencia de patrones".
Esta sección cubre las expresiones regulares en Java 1.5 y 1.6.
Metacaracteres admitidos java.util.regex
admite los metacaracteres y secuencias de metase enumerados en la Tabla

11 a la Tabla 15. Para obtener definiciones ampliadas de cada metacarácter,
consulte “Metacaracteres, modos y construcciones Regex”.
Tabla 11. Representaciones de caracteres de Java
\a Alerta (campana).
\b Retroceso, \x08, solo se admite en la clase de caracteres.
\mi Esc carácter, \x1B.
\norte Nueva línea, \x0A.
\r Retorno de carro, \x0D.
\F Avance de formulario, \x0C.
\t Pestaña horizontal, \x09.
\0octal Carácter especificado por un código octal de uno, dos o tres dígitos.
\xhex Carácter especificado por un código hexadecimal de dos dígitos.
\uhex Carácter Unicode especificado por un código hexadecimal de cuatro

dígitos.

Tabla 12. Clases de caracteres Java y construcciones similares a clases
Clase Significado
[^...] Un solo carácter que no está en la lista y que no está contenido dentro de
un rango de la lista.
. Cualquier carácter, excepto un terminador de línea (a menos que esté en modo

DOTALL ).
\w Carácter de palabra, [azAZ09_].
\W Carácter sin palabra, [âzAZ09_].
\d Dígito, [09].
\D Sin dígitos, [^09].
\s Carácter de espacio en blanco, [ \t\n\f\r\x0B].
\S Carácter sin espacio en blanco, [^ \t\n\f\r\x0B].
\p{accesorio} Carácter contenido por una clase de carácter POSIX dada, una
propiedad Unicode o un bloque Unicode.
\P{accesorio} Carácter no incluido en la clase de carácter POSIX, la propiedad

Unicode o el bloque Unicode determinados.
Tabla 13. Anclajes de Java y otras pruebas de ancho cero
^
Comienzo de cadena, o el punto después de cualquier salto de línea
si está en modo MULTILINE .
\A Comienzo de la cadena, en cualquier modo de coincidencia.
ps Fin de cadena, o el punto antes de cualquier salto de línea si

está en modo MULTILINE .
\Z Fin de cadena, pero antes de cualquier terminador de línea final, en cualquier

Java (java.util.regex) | 27
Tabla 13. Anclajes de Java y otras pruebas de ancho cero (continuación)
(?=...) Previsión positiva.
(?<=...) Mirada positiva hacia atrás.
(?<!...) Mirada negativa hacia atrás.
Tabla 14. Comentarios de Java y modificadores de modo
Modificador/secuencia Carácter de modo Significado
Patrón.UNIX_LINES d Trata a \n como el único

terminador de línea.
Patrón.DOTALL s El punto (.) coincide con cualquier

carácter, incluido un terminador de línea.
Patrón.MULTILINE metro
^ y $coincidencia junto a los terminadores
de línea incrustados.
Patrón.COMENTARIOS X Ignore los espacios en blanco y permita

comentarios incrustados que comiencen
con #.
Patrón.CASE_ i Coincidencia que no distingue entre mayúsculas y minúsculas
INSENSITIVO para caracteres ASCII.
Patrón.UNICODE_CASE tu Coincidencia que no distingue entre mayúsculas y
minúsculas para caracteres Unicode.
Patrón.CANON_EQ El modo de "equivalencia canónica" de

Unicode, donde los caracteres, o las
secuencias de un carácter base y la

combinación de caracteres con
representaciones visuales idénticas, se
tratan como iguales.
(?modo) Active los modos enumerados (uno o más de

idmsux) para el resto de la subexpresión.
(?modo) Desactive los modos enumerados (uno o

más de idmsux) para el resto de la
subexpresión.
(?modo:...) Active los modos enumerados (uno o más de
idmsux) entre paréntesis.

Tabla 14. Comentarios de Java y modificadores de modo (continuación)
(?modo:...) Desactive los modos enumerados (uno o más
de idmsux) entre paréntesis.
#... Trata el resto de la línea como un comentario
en modo /x .
Tabla 15. Agrupación, captura, condicional y control de Java
(...) Agrupe el subpatrón y capture la subcoincidencia en \1,\2,... y $1, $2,....
\norte Contiene texto que coincide con el grupo de captura n.
$n En una cadena de reemplazo, contiene texto que coincide con el grupo

de captura n.
(?:...) (? Agrupa el subpatrón, pero no captura la subcoincidencia.
>...) Agrupación atómica.
{x, y}? Haga coincidir al menos x veces, no más de y veces y la menor cantidad de
veces posible.
*+ Haga coincidir 0 o más veces, y nunca retroceda.
++ Haga coincidir 1 o más veces, y nunca retroceda.
Tabla 15. Agrupación, captura, condicional y control de Java (continuación)
?+ Haga coincidir 0 o 1 veces, y nunca retroceda.
{n}+ Haga coincidir al menos n veces, y nunca retroceda.
{n,}+ Haga coincidir al menos n veces, y nunca retroceda.
{x,y}+ Haga coincidir al menos x veces, no más de y veces, y nunca

retroceda.
Clases e interfaces de expresiones regulares Las funciones
de expresiones regulares están contenidas en dos clases principales,

java.util.regex.Pattern y java.util.regex.Matcher; una excepción,
java.util.regex.PatternSyntaxException; y una interfaz, CharSequence.
Además, la clase String implementa la interfaz CharSequence para
proporcionar métodos básicos de coincidencia de patrones. Los objetos
de patrón son expresiones regulares compiladas que se pueden aplicar a
cualquier CharSequence. Un Matcher es un objeto con estado que busca
una o más ocurrencias de un Patrón aplicado en una cadena (o cualquier
objeto que implemente CharSequence).
Barras invertidas en expresiones regulares Los literales de cadena deben

escaparse. Entonces, \n (nueva línea) se convierte en \\n cuando se usa en
un literal de cadena Java que se usará como una expresión regular.
java.lang.String
Descripción
Métodos para la coincidencia de patrones.
Métodos
coincidencias booleanas (String regex)
Devuelve verdadero si la expresión regular coincide con toda la cadena.
Cadena [ ] división (cadena expresión regular)

Devuelve una matriz de las subcadenas que rodean las coincidencias de expresiones regulares.

Cadena [] división (cadena expresión regular, límite int )

Devuelve una matriz de las subcadenas que rodean las primeras coincidencias de límite 1
de expresiones regulares.
String replaceFirst (String regex, String replace)

Reemplace la subcadena que coincide con la expresión regular con reemplazo.
Cadena replaceAll (cadena expresión regular, reemplazo de cadena )

Reemplace todas las subcadenas que coincidan con expresiones regulares con reemplazo.
java.util.regex.Patrón
Descripción
Modela un patrón de expresión regular.
Métodos
Compilación de patrón estático (String regex)
Construya un objeto Patrón a partir de expresiones
regulares. Compilación de patrón estático (String regex, int flags)

Construya un nuevo objeto de patrón a partir de expresiones regulares, y las constantes
del modificador de modo OR se marcan.
banderas int()
Devuelve los modificadores de modo del patrón .
Matcher matcher ( entrada CharSequence)

Construya un objeto Matcher que haga coincidir este patrón con la entrada. coincidencias
booleanas estáticas
(String regex, entrada CharSequence )

Devuelve verdadero si la expresión regular coincide con la entrada de cadena completa .
Patrón de cuerdas( )
Devuelve la expresión regular utilizada para crear este Patrón. Cita de cadena
estática ( texto de cadena)
Escapa el texto para que los operadores de expresiones regulares coincidan

literalmente.
Cadena [ ] dividida ( entrada CharSequence)
Devuelve una matriz de las subcadenas que rodean las coincidencias de este patrón en la
entrada.
String[ ] split ( entrada CharSequence, límite int )

Devuelve una matriz de las subcadenas que rodean las primeras coincidencias de límite
de este patrón en expresiones regulares.
java.util.regex.Matcher
Descripción
Modela un comparador de patrones de expresión regular con estado y resultados de

coincidencia de patrones.
Métodos
Matcher appendReplacement (StringBuffer sb, reemplazo de cadena )

Agregue la subcadena anterior a la coincidencia y el reemplazo a sb.
StringBuffer appendTail(StringBuffer sb)

Agregue una subcadena después del final de la coincidencia a sb.
pretender( )
Índice del primer carácter después del final del partido.
extremo int ( grupo int)

Índice del primer carácter después del texto capturado por grupo. búsqueda booleana()
Encuentra la siguiente coincidencia en la cadena de
entrada. búsqueda booleana ( inicio int)

Encuentra la siguiente coincidencia después del inicio de la posición del personaje.
grupo de cadenas( )
Texto coincidente con este patrón.
Grupo de cadenas ( grupo int)

Texto capturado por el grupo de captura de grupo. int
grupoCuenta( )
Número de grupos de captura en Pattern. booleano tiene
límites de anclaje ()
Devuelve true si este Matcher usa límites de anclaje para que los operadores de
anclaje coincidan en los límites de la región, no solo al principio y al final de la
cadena de destino. booleano tiene límites
transparentes ()
True si este Matcher usa límites transparentes para que los operadores de
búsqueda puedan ver fuera de los límites de búsqueda actuales. El valor
predeterminado es falso.
booleano hitEnd()
True si la última coincidencia intenta inspeccionar más allá del final de la entrada.
En los escáneres, esto es una indicación de que más entrada puede haber
resultado en una coincidencia más larga.

booleano mirando( )
True si el patrón coincide con el principio de la entrada. coincidencias booleanas
()
Devuelve verdadero si Patrón coincide con la cadena de entrada completa.
patrón patrón ( )
Objeto de patrón de retorno utilizado por este Matcher.
Reemplazo de cita de cadena estática (cadena de cadena)

Caracteres especiales de escape evaluados durante los reemplazos.
Región del comparador ( inicio int, final int )

Devuelve este comparador y ejecuta futuras coincidencias en la región entre los
caracteres de inicio y los caracteres finales desde el principio de la cadena. int
regionStart( )
Devuelve el desplazamiento inicial de la región de búsqueda. El valor predeterminado
es cero. int regionEnd( )

Devuelve el desplazamiento final de la región de búsqueda. El valor predeterminado es la
longitud de la cadena de destino.
Cadena replaceAll ( reemplazo de cadena)

Reemplace cada fósforo con un reemplazo.
Cadena replaceFirst ( reemplazo de cadena)

Reemplace el primer partido con el reemplazo.
booleano requireEnd()
Devuelve verdadero si el éxito de la última coincidencia se basó en el final de la entrada. En
los escáneres, esto es una indicación de que más entradas pueden haber causado una
coincidencia fallida.
Restablecimiento del emparejador ( )
Restablezca este comparador para que la siguiente coincidencia comience al principio de la

cadena de entrada.
Restablecimiento de Matcher ( entrada CharSequence)
Reinicie este comparador con una nueva entrada.
inicio int()
Índice del primer carácter coincidente.
inicio int ( grupo int)

Índice del primer carácter coincidente en el grupo de subcadenas capturado.
MatchResult toMatchResult( )
Devuelve un objeto MatchResult para la coincidencia más reciente.
Cadena a Cadena()
Devuelve una representación de cadena del comparador para la depuración.
Comparador useAnchorBounds(booleano b)
Si es verdadero, configure Matcher para usar límites de anclaje para que los
operadores de anclaje coincidan al principio y al final de los límites de búsqueda
actuales, en lugar del principio y el final de la cadena de búsqueda. El valor
predeterminado es verdadero.
Matcher usePattern (Patrón p)

Reemplace el patrón de Matcher , pero mantenga el resto del partido
estado.
Comparador useTransparentBounds(booleano b)
Si es verdadero, configure Matcher para usar límites transparentes para que los
operadores de búsqueda puedan ver fuera de los límites de búsqueda actuales.
El valor predeterminado es falso.
java.util.regex.PatternSyntaxException
Descripción
Lanzado para indicar un error de sintaxis en un patrón de expresión regular.
Métodos
PatternSyntaxException(String desc, String regex, int index)
Construya una instancia de esta clase.
Cadena getDescripción( )
Devuelve la descripción del error.
int obtenerIndice( )
Índice de error de retorno.
Cadena getMessage( )
Devuelve un mensaje de error de varias líneas que contiene la descripción
del error, el índice, el patrón de expresión regular y la indicación de la posición
del error dentro del patrón.
Cadena obtenerPatrón()
Devuelve el patrón de expresión regular que generó la excepción.
java.lang.CharSequence
Descripción
Define una interfaz para acceso de solo lectura, de modo que se puedan
aplicar patrones de expresiones regulares a una secuencia de caracteres.

Métodos
char charAt( índice int)
Devuelve el carácter en el índice de posición basado en cero .
longitud int()
Devuelve el número de caracteres en la secuencia.
CharSequence subsecuencia ( inicio int, final int )
Devuelve una subsecuencia, incluido el índice inicial y excluyendo el
índice final .
Cadena a Cadena()
Devuelve una representación de cadena de la secuencia.
Soporte Unicode
Este paquete admite Unicode 4.0, aunque \w, \W, \d, \D, \s
y \S solo admiten ASCII. Puede usar las propiedades de
código Uni equivalentes \p{L}, \P{L}, \p{Nd}, \P{Nd} , \p{Z} y \P{Z}.
Las secuencias de límites de palabras, \b y \B, entienden Unicode.
Para conocer las propiedades y los bloques de Unicode admitidos, consulte la Tabla 2.
Este paquete admite solo los nombres de propiedad breves, como \p{Lu},
y no \p{Lowercase_Letter}. Los nombres de bloque requieren el prefijo In
y admiten solo la forma del nombre sin espacios ni guiones bajos, por
ejemplo, \p{InGreekExtended}, no \p{In_ Greek_Extended} o \p{In Greek
Extended}.
Ejemplos
importar java.util.regex.*;
// Encuentra SpiderMan, Spiderman, SPIDERMAN, etc.

public class StringRegexTest { public
static void main(String[] args) throws Exception { String dailyBugle =
"¡SpiderMan amenaza la ciudad!";
//regex debe coincidir con toda la cadena
Ejemplo 5. Coincidencia simple (continuación)
String regex = "(?i).*spider[ ]?man.*";
if (dailyBugle.matches(regex))
{ System.out.println("Coincidencia: " + dailyBugle); } } }
Ejemplo 6. Grupo de emparejamiento y captura
// Coincidencia de fechas formateadas como MM/DD/AAAA, MM

DDAA,... import java.util.regex.*;
MatchTest de clase pública

{ public static void main(String[] args) throws Exception { String date =
"30/12/1969"; Patrón p =
Patrón.compile("^(\\d\\d)[/](\\d\\d)[/](\\d\\d(?:\\d\ \d) ps
Matcher m = p.matcher(fecha);
if (m.find( )) { String
mes = m.grupo(1); Cadena dia
= m.grupo(2); Cadena año =
m.group(3);
System.out.printf("Encontrado %s%s%s\n", año, mes, día); } } }
// Ejemplo . Sustitución simple // Convertir

 a para conformidad con XHTML import
java.util.regex.*;
prueba de sustitución simple de clase pública {

public static void main(String[] args) { String text =
"Hola mundo. ";

Ejemplo 7. Sustitución simple (continuación)
Patrón p = Patrón.compile(" ", Patrón.CASE_INSENSITIVE);

Matcher m =
p.matcher(texto);
Resultado de cadena = m.replaceAll(" ");

System.out.println(resultado); } }
// urlify convierte URLs en enlaces HTML import

java.util.regex.*;
public class Urlify { public

static void main (String[ ] args) throws Exception { String text = "Consulte el sitio
web, http://www.oreilly.com/ catalog/regexppr."; Cadena expresión regular =
"\\b # comienza en la palabra\n"

"
+ # límite\n" + "( #
capturar a $1\n" + "(https?|telnet|gopher|archivo|wais|ftp): \n"
"
+ # recurso y dos puntos\n"
+ "[\\w/\\#~:.?+=&%@!\\] +? # uno o más válidos\n"
"
+ # caracteres\n" #
"
+ pero tome la menor cantidad\n"
"
+ # posible\n"
+ ")\n" + "(?
= + "[.:?\ # anticipación\n"
\] * # para posibles punc\n" + "(?: [^\\w/\\#~:.?+=& %@!\\] # carácter no
válido\n" + "| $ ) # o final de cadena\n" + ")";
Patrón p = Patrón.compile(regex,
Patrón.CASE_INSENSITIVE + Patrón.COMENTARIOS);
Matcher m = p.matcher(texto); String
result = m.replaceAll("<a href=\"$1\">$1</a>"); System.out.println(resultado); }
Otros recursos
• Mastering Regular Expressions, Third Edition, de Jeffrey EF Friedl (O'Reilly),
cubre los detalles de las expresiones regulares de Java en las páginas 365–
403.
• Documentación en línea de Sun en http://java.sun.com/javase/6/docs/api/java/

util/regex/packagesummary.html .
.NET y C#
.NET Framework de Microsoft proporciona un conjunto consistente y poderoso
de clases de expresiones regulares para todas las implementaciones de .NET.
Las siguientes secciones enumeran la sintaxis de expresiones regulares de .NET,
las clases principales de .NET y ejemplos de C#.
.NET de Microsoft utiliza un motor de coincidencia NFA tradicional. Para obtener
una explicación de las reglas detrás de este motor, consulte "Introducción a
expresiones regulares y coincidencia de patrones".
Metacaracteres compatibles
.NET es compatible con los metacaracteres y las metasecuencias enumerados
en la Tabla 16 a la Tabla 21. Para obtener definiciones ampliadas de cada
metacarácter, consulte "Metacaracteres, modos y construcciones Regex".
Tabla 16. Representaciones de caracteres .NET
\a Alerta (campana), \x07.

Tabla 16. Representaciones de caracteres .NET (continuación)
\v Pestaña vertical, \x0B.
\0octal Carácter especificado por un código octal de dos dígitos.
\uhex Carácter especificado por un código hexadecimal de cuatro dígitos.
Tabla 17. Clases de caracteres .NET y construcciones similares a clases
Clase Significado
[...] Un solo carácter enumerado o contenido dentro de un rango

enumerado.
[^...] Un solo carácter que no aparece en la lista y que no está contenido dentro de
. Cualquier carácter, excepto un terminador de línea (a menos que esté en

modo de línea única, s).
\w Carácter de palabra, [\p{Ll}\p{Lu}\p{Lt}\p{Lo} \p{Nd}\p{Pc}] o [azA

Z_09 ] en modo ECMAScript .
\W Carácter sin palabra, [\p{Ll}\p{Lu}\p{Lt} \p{Lo}\p{Nd}\p{Pc}], o

[âzA Z_09 ] en modo ECMAScript .
\d Dígito, \p{Nd} o [09] en modo ECMAScript .
\D Sin dígitos, \P{Nd} o [^09] en el modo ECMAScript .
\s Carácter de espacio en blanco, [ \f\n\r\t\v\x85\p{Z}] o [ \f\n\r\t\v] en modo

ECMAScript .
\S Carácter sin espacio en blanco, [^ \f\n\r\t\v\x85 \p{Z}] o [^ \f\n\r\t\v]

en modo ECMAScript .
\p{accesorio} Carácter contenido en un bloque o propiedad Unicode determinado.
\P{accesorio} Carácter no incluido en el bloque o la propiedad Unicode dados.
.NET y C# | 39
Tabla 18. Anclajes .NET y otras pruebas de ancho cero
^
Comienzo de cadena, o el punto después de cualquier salto de línea
si está en modo MULTILINE .
\A Comienzo de la cadena, en todos los modos de coincidencia.
ps Fin de cadena, o el punto antes de cualquier salto de línea si está

en modo MULTILINE .
\Z Fin de cadena, pero antes de cualquier terminador de línea final, en todos los
modos de coincidencia.
\z Fin de cadena, en todos los modos de partido.
\b Límite entre un carácter \w y un carácter \W .
\GRAMO Fin del partido anterior.
Tabla 19. Modificadores de modo y comentarios de .NET
Linea sola s El punto (.) coincide con cualquier carácter,

incluido un terminador de línea.
multilínea metro ^ y $ coinciden junto a los

terminadores de línea incrustados.
IgnorarPatrónEspacio en X Ignore los espacios en blanco y permita
blanco comentarios incrustados que comiencen

con #.
Ignorar caso i Coincidencia que no distingue entre mayúsculas y
minúsculas basada en caracteres de la referencia cultural actual.
CulturaInvariante i Coincidencia insensible a la cultura.
Captura explícita norte

Permita grupos de captura con nombre,
pero trate los paréntesis como
grupos que no capturan.

Tabla 19. Modificadores de modo y comentarios de .NET (continuación)
compilado Compilación de expresiones regulares.
De derecha a izquierda Busque de derecha a izquierda, comenzando
a la izquierda de la posición inicial.

Esto tiene una semántica
indefinida e impredecible.
ECMAScript Habilita el cumplimiento de

ECMAScript cuando se usa con
IgnoreCase o Multiline.
(?imnsximnsx) Active o desactive las banderas de coincidencia
para el resto del patrón.
(?imnsximnsx:...) Active o desactive los indicadores de
coincidencia para el resto de la subexpresión.
#... Trata el resto de la línea como un
comentario en modo /x .
Tabla 20. Agrupación, captura, condicional y control de .NET
(...) Agrupamiento. Las subcoincidencias llenan \1,\2, . . . y $1, $2,....
\norte En una expresión regular, haga coincidir lo que coincidió con la enésima
subcoincidencia anterior.
$n En una cadena de reemplazo, contiene la enésima subcoincidencia

anterior.
(?<nombre>...) Captura la subcadena coincidente en grupo, nombre.
(?:...) (? Paréntesis de solo agrupación, sin captura.
>...) ...|... Agrupación atómica.
Alternancia; coincidir con uno u otro.
*
Coincide 0 o más veces.
.NET y C# | 41
Tabla 20. Agrupación, captura, condicional y control de .NET (continuación)
{x, y}? Haga coincidir al menos x veces, y no más de y veces, pero la menor cantidad
de veces posible.
Tabla 21. Secuencias de reemplazo de .NET
${nombre} Texto coincidente de un grupo de captura con nombre.
ps Texto antes del partido.
ps Texto del partido.
$` Texto después del partido.
ps Copia de la cadena de entrada original.
Clases e interfaces de expresiones regulares .NET

define su compatibilidad con expresiones regulares en el sistema.
Módulo Text.RegularExpressions . El constructor RegExp( )
maneja la creación de expresiones regulares y el resto de los
métodos RegExp manejan la coincidencia de patrones. Las
clases Grupos y Partidos contienen información sobre cada partido.

La sintaxis de cadena sin procesar de C#, @"", permite definir patrones de

expresiones regulares sin tener que escapar de las barras invertidas incrustadas.
expresión regular
Esta clase maneja la creación de expresiones regulares y la coincidencia de

patrones. Varios métodos estáticos permiten la coincidencia de patrones sin
crear un objeto RegExp .
Métodos
Regex público ( patrón de cadena)
Regex público ( patrón de cadena, opciones RegexOptions )
Devuelve un objeto de expresión regular basado en un patrón y con los
modificadores de modo opcionales, opciones. public
static void CompileToAssembly(RegexCompilationInfo[ ] regexinfos,

System.Reflection.AssemblyName nombre de ensamblado) public static
void CompileToAssembly(RegexCompilationInfo[ ] regexinfos,
System.Reflection.AssemblyName nombre de ensamblado) public static
void CompileToAssembly(RegexCompilationInfo[ ] regexinfos, System.
Reflection.AssemblyName nombre de ensamblado ,
System.Reflection.Emit.CustomAttributeBuilder[ ] atributos) public static void
CompileToAssembly(RegexCompilationInfo[ ] regexinfos,
System.Reflection.AssemblyName nombre de ensamblado,
System.Reflection.Emit.CustomAttributeBuilder[ ] atributos, string resourceFile)
Compile uno o más objetos Regex en un ensamblaje. La matriz regexinfos

describe las expresiones regulares que se deben incluir.
El nombre de archivo del ensamblaje es nombre del ensamblaje. Los
atributos de matriz definen atributos para el ensamblaje. resourceFile es el
nombre de un archivo de recursos Win32 para incluir en el
ensamblado. Escape de cadena estática pública (string str)
Devuelve una cadena con todos los metacaracteres de expresiones regulares,
caracteres de almohadilla (#) y espacios en blanco escapados.
.NET y C# | 43
IsMatch bool estático público ( entrada de cadena, patrón de cadena )

IsMatch bool estático público ( entrada de cadena, patrón de cadena , opciones
RegexOptions ) IsMatch
bool público ( entrada de cadena) IsMatch
bool público ( entrada de cadena, int startat)
Devuelve el éxito de una única coincidencia con la entrada de la cadena de
entrada. Las versiones estáticas de este método requieren el patrón de
expresión regular. El parámetro de opciones permite modificadores de modo
opcionales (OR juntos). El parámetro startat define una posición inicial en la
entrada para comenzar a hacer coincidir. Coincidencia de coincidencia pública
estática
( entrada de cadena, patrón de cadena ) Coincidencia de coincidencia
pública estática ( entrada de cadena, patrón de cadena , opciones RegExpOptions )
Coincidencia de coincidencia
pública ( entrada de cadena) Coincidencia
de coincidencia pública ( entrada de cadena, int startat)
Coincidencia de coincidencia pública ( entrada de cadena, int startat, int longitud)
Realiza una sola coincidencia con la entrada de la cadena de entrada y
devuelve información sobre la coincidencia en un objeto Match . Las versiones
estáticas de este método requieren el patrón de expresión regular. El
parámetro de opciones permite modificadores de modo opcionales (OR
juntos). Los parámetros startat y length definen una posición inicial y el
número de caracteres después de la posición inicial para realizar la
coincidencia, respectivamente. Coincidencias de colección de coincidencias
públicas estáticas ( entrada de cadena, patrón de cadena ) Coincidencias de
colección
de coincidencias públicas estáticas ( entrada de cadena, patrón de cadena ,
opciones RegExpOptions ) Coincidencias
de colección de coincidencias públicas (entrada de
cadena) Coincidencias de colección de coincidencias públicas ( entrada de cadena, int startat)
Encuentre todas las coincidencias en la entrada de la cadena de
entrada y devuelva información sobre las coincidencias en un objeto
MatchCollection . Las versiones estáticas de este método requieren
el patrón de expresión regular. El parámetro de opciones permite
modificadores de modo opcionales (OR juntos). El parámetro startat
define una posición inicial en la entrada para realizar el partido.

cadena estática pública Reemplazar ( entrada de cadena, patrón, evaluador

de MatchEvaluator ) cadena
estática pública Reemplazar ( entrada de cadena, patrón, evaluador de
MatchEvaluator , opciones RegexOptions ) cadena
estática pública Reemplazar ( entrada de cadena, patrón, reemplazo de
cadena )
cadena estática pública Reemplazar ( entrada de cadena, patrón, reemplazo
de cadena , opciones de RegexOptions )
cadena pública Reemplazar ( entrada de cadena, evaluador de
MatchEvaluator ) cadena pública Reemplazar ( entrada de cadena, evaluador
de
MatchEvaluator , int count) cadena pública Reemplazar ( entrada de cadena,
evaluador de
MatchEvaluator , conteo int , startat int ) cadena pública
Reemplazar ( entrada de cadena, reemplazo de cadena ) cadena pública
Reemplazar ( entrada de cadena, reemplazo de cadena , conteo de int )
cadena pública Reemplazar ( entrada de cadena, reemplazo de cadena , conteo de int , in
Devuelve una cadena en la que cada coincidencia en la entrada se reemplaza con la
evaluación de la cadena de reemplazo o una llamada a un objeto MatchEvaluator . El
reemplazo de cadena puede contener referencias inversas al texto capturado con la
sintaxis $n o ${name} .
El parámetro de opciones permite modificadores de modo opcionales (OR juntos). El

parámetro de conteo limita el número de reemplazos. El parámetro startat define una
posición inicial en la entrada para iniciar el reemplazo.
cadena estática pública[ ] Split( entrada de cadena, patrón de cadena )

cadena estática pública[ ] Split( entrada de cadena, patrón de cadena ,
opciones RegexOptions )
cadena estática pública[ ] Split( entrada de cadena)
cadena estática pública[ ] Split(entrada de cadena , int count)
public static string[ ] Split(string input, int count, int startat)
Devuelve una matriz de cadenas rotas alrededor de las coincidencias del patrón de
expresiones regulares. Si se especifica, no se devuelven más que cadenas de recuento .
Puede especificar una posición inicial en la entrada con startat.
.NET y C# | 45
Fósforo
Propiedades
public bool Success Indica
si la coincidencia fue exitosa.
cadena pública Valor Texto

de la coincidencia.
public int Longitud

Número de caracteres en el texto coincidente.
public int Index Índice

de caracteres basado en cero del inicio del partido.
Grupos públicos de GroupCollection

Un objeto GroupCollection , donde Groups[0].value contiene el texto de la coincidencia
completa, y cada elemento Groups adicional contiene el texto que coincide con un grupo
de captura.
Métodos
Partido público Partido siguiente( )

Devuelve un objeto Match para la siguiente coincidencia de la expresión regular en la
cadena de
entrada. Resultado de cadena virtual pública ( resultado de cadena)

Devuelve el resultado con secuencias de reemplazo especiales reemplazadas por
valores de la coincidencia anterior.
coincidencia estática pública sincronizada (coincidencia interna)

Devuelve un objeto Match idéntico al interno, excepto que también es seguro para el uso
de subprocesos múltiples.
Grupo
Propiedades
public bool Éxito Verdadero

si el grupo participó en el partido. cadena pública Valor
Texto capturado por este

grupo.

public int Longitud

Número de caracteres capturados por este grupo.
public int Index
Índice de caracteres basado en cero del inicio del texto capturado
por este grupo.
Compatibilidad con
Unicode .NET proporciona compatibilidad integrada con Unicode 3.1,

incluida la compatibilidad total con las secuencias \w, \d y \s . El rango de
caracteres coincidentes se puede limitar a caracteres ASCII activando el
modo ECMAScript . La coincidencia que no distingue entre mayúsculas y
minúsculas se limita a los caracteres del idioma actual definido en Thread.
CurrentCulture, a menos que se establezca la opción CultureInvariant .
.NET admite las propiedades y bloques estándar de Unicode (consulte la

Tabla 2). Solo se admite la forma abreviada de los nombres de propiedad.
Los nombres de bloque requieren el prefijo Is y deben usar la forma de
nombre simple, sin espacios ni guiones bajos.
Ejemplos
//Buscar SpiderMan, Spiderman, SPIDERMAN, etc.

namespace Regex_PocketRef
{
usando System.Text.RegularExpressions;
class SimpleMatchTest
{ static void Main( )
{ string dailybugle = "¡SpiderMan amenaza la ciudad!";
string regex = "spider[ ]?man";
.NET y C# | 47
si (Regex.IsMatch(dailybugle, regex, RegexOptions.

IgnoreCase)) { //
hacer algo}
}}
Ejemplo 10. Partido y grupo de captura
//Hacer coincidir las fechas con el formato MM/DD/YYYY, MMDDYY,...

prueba de coincidencia de clase
vacío estático Principal( )

{
fecha de cadena = "30/12/1969";
Regex r =
new Regex( @"^(\d\d)[/](\d\d)[/](\d\d(?:\d\d)?)$" );
Partido m = r.Partido(fecha);
if (m.Éxito) { string
mes = m.Grupos[1].Valor; cadena día =
m.Grupos[2].Valor; cadena año =
m.Grupos[3].Valor; } } }
//Convertir a para el cumplimiento de XHTML usando

System.Text.RegularExpressions;
clase PruebaSustituciónSimple {
static void Main( ) { texto
de cadena = "Hola mundo. "; cadena expresión

regular = " ";

Ejemplo 11. Sustitución simple (continuación)
reemplazo de cadena = " ";
resultado de cadena
= Regex.Replace (texto, expresión regular, reemplazo, RegexOptions.
Ignorar caso); } }

//urlify: convierta las URL en enlaces HTML
URL de clase pública {
static Main ( )
{ string text = "Consulte el sitio web, http://www.oreilly.com/catalog/regexppr.";

string regex = @"\b #
comienza en el
límite de la palabra ( # captura a $1 (https?|telnet|gopher|file|wais|ftp) :
# recurso y dos puntos #

[\w/#~:.?+=&%@!\] +? uno o más # caracteres
válidos # pero
tome lo menos # posible
) (?= # mirar hacia el futuro
[.:?\] * # para posible #

puntuación #
(?: [^\w/#~:.?+=&%@!\] | $ ) )"; carácter inválido # o final
de cadena
Regex r = nueva expresión regular (regex, RegexOptions.IgnoreCase

| RegexOptions.IgnorePatternWhitespace); string
result = r.Replace(text, "<a href=\"$1\">$1</a>"); } }
.NET y C# | 49
Otros recursos
• Programación C#, de Jesse Liberty (O'Reilly), brinda una introducción

completa a C#, .NET y expresiones regulares. • Mastering Regular
Expressions, Third Edition, de Jeffrey EF Friedl (O'Reilly), cubre los
detalles de las expresiones regulares de .NET en las páginas 399–
432.
• Documentación en línea de Microsoft en http://msdn.microsoft. com/
library/default.asp?url=/library/enus/cpgenref/html/
cpconregularexpressionslanguageelements.asp.
PHP
Esta referencia cubre el soporte de expresiones regulares estilo Perl de
PHP 4.4.3 y 5.1.4 contenido dentro de las rutinas preg . Ambos se
basan en la biblioteca PCRE 6.6. Las rutinas preg utilizan un motor de
emparejamiento NFA tradicional. Para obtener una explicación de las
reglas detrás de un motor NFA, consulte "Introducción a expresiones
regulares y coincidencia de patrones".
Metacaracteres admitidos PHP

admite los metacaracteres y metasecuencias enumerados en la
Tabla 22 a la Tabla 26. Para obtener definiciones ampliadas de
cada metacarácter, consulte “Metacaracteres, modos y
construcciones Regex”.
Tabla 22. Representaciones de caracteres de PHP

Tabla 22. Representaciones de caracteres de PHP (continuación)
\ octal Carácter especificado por un código octal de tres dígitos.
Tabla 23. Clases de caracteres de PHP y construcciones similares a clases
Clase Significado
[...] Un solo carácter enumerado o contenido dentro de un rango enumerado.
[^...] Un solo carácter no listado y no contenido dentro de un rango listado.
[:clase:] Clase de caracteres de estilo POSIX (válida solo dentro de una clase de caracteres
regex).
. Cualquier carácter excepto nueva línea (a menos que el modo de una sola línea, /s).
\C Un byte (esto podría dañar un flujo de caracteres Unicode, sin embargo).
\w Carácter de palabra, [azAz09_].
\W Carácter sin palabra, [âzAz09_].
\d Carácter de dígito, [09].
\D Carácter sin dígitos, [^09].
\s Carácter de espacio en blanco, [\n\r\f\t ].
\S Carácter sin espacios en blanco, [^\n\r\f\t ].
Tabla 24. Anclajes de PHP y pruebas de ancho cero
^
Comienzo de cadena, o el punto después de cualquier nueva línea si está en modo de
coincidencia multilínea, /m.
ps Fin de la cadena de búsqueda, o el punto antes de una línea nueva que finaliza la
cadena, o antes de cualquier línea nueva si está en el modo de coincidencia de varias líneas, /m.
PHP | 51
Tabla 24. Anclajes de PHP y pruebas de ancho cero (continuación)
\Z Fin de cadena, o el punto anterior a una nueva línea que finaliza una cadena, en cualquier
\b Límite de palabra; posición entre un carácter de palabra (\w) y un carácter que no es

de palabra (\W), el comienzo de la cadena o el final de la cadena.
Mirada positiva hacia atrás.

(?<=...)
Tabla 25. Comentarios de PHP y modificadores de modo
Modos Significado
i Coincidencia que no distingue entre mayúsculas y minúsculas.
metro ^ y $ coinciden junto a \n incrustado.
s El punto (.) coincide con la nueva línea.
X Ignore los espacios en blanco y permita comentarios (#) en el patrón.
tu Invierte la codicia de todos los cuantificadores: * se vuelve perezoso, y *? avaro.
A Forzar la coincidencia para que comience al principio de la cadena de asunto.
D Forzar $ para que coincida con el final de la cadena en lugar de antes de la
cadena que termina la nueva línea. Anulado por el modo multilínea.
tu Trate las expresiones regulares y las cadenas de asunto como cadenas de
caracteres UTF8 multibyte.
(?modo) Active los modos enumerados (uno o más de imsxU) para el resto de la subexpresión.
(?modo) Desactive los modos enumerados (uno o más de imsxU) para el resto de la
subexpresión.
(?modo:...) Active el modo (xsmi) entre paréntesis.
(?modo:...) Desactiva el modo (xsmi) entre paréntesis.

Tabla 25. Comentarios de PHP y modificadores de modo (continuación)
Modos Significado
#... El resto de la línea se trata como un comentario en modo x .
\Q Cita todos los siguientes metacaracteres de expresiones regulares.
\MI Finaliza un lapso que comenzó con \Q.
Tabla 26. Agrupación, captura, condicional y control de PHP
(...) Agrupe el subpatrón y capture la subcoincidencia en \1, \2,....
(?P<nombre>...) Subpatrón de grupo y subcoincidencia de captura en un grupo de captura
con nombre, nombre.
Contiene los resultados de la enésima subcoincidencia anterior de un grupo

\norte
de captura entre paréntesis o un grupo de captura con nombre.
(? Agrupación atómica.
Pruebe subpatrones en alternancia.

>...) ...|...
Coincide al menos n veces.

{norte,}
Haga coincidir al menos n veces, pero la menor cantidad de veces posible.
{norte,}? {x, y}? Haga coincidir al menos x veces, no más de y veces y la menor cantidad
de veces posible.
PHP | 53
Tabla 26. Agrupación, captura, condicional y control de PHP (continuación)

retroceda.
(?(condición)...|...) Coincide con el patrón ifthenelse. La condición puede ser el número de un grupo de
captura, o una construcción de búsqueda anticipada o posterior.
(?(condición)...) Empareja con el patrón sientonces. La condición puede ser el

número de un grupo de captura, o una construcción de
búsqueda anticipada o posterior.
Funciones de coincidencia de patrones
PHP proporciona varias funciones independientes para la

coincidencia de patrones. Al crear cadenas de expresiones regulares,
debe escapar de las barras invertidas incrustadas; de lo contrario, la
barra invertida se interpreta en la cadena antes de enviarse al motor
matriz preg_grep ( patrón de cadena, entrada de matriz )

Devuelve una matriz que contiene todos los elementos de entrada que coinciden
con el patrón.
int preg_match_all ( patrón de cadena, asunto de cadena , coincidencias

de matriz [, banderas int ])
Busque todas las coincidencias de patrón contra sujeto y devuelva el número
de coincidencias. Las subcadenas coincidentes se colocan en la matriz de
coincidencias . El primer elemento de las coincidencias es una matriz que
contiene el texto de cada coincidencia completa.
Cada elemento adicional n de coincidencias es una matriz que contiene la n
ésima coincidencia del grupo de captura para cada coincidencia completa.
Entonces, por ejemplo, las coincidencias [7] [3] contienen las coincidencias de
texto del séptimo grupo de captura en la cuarta coincidencia del patrón en el
asunto.

El orden predeterminado de las coincidencias se puede establecer

explícitamente con el indicador PREG_SET_ORDER .
PREG_SET_ORDER establece un orden más intuitivo, donde cada
elemento de coincidencias es una matriz correspondiente a una
coincidencia. El elemento 0 de cada matriz es la coincidencia completa
y cada elemento adicional corresponde a un grupo de captura. El
indicador adicional PREG_ OFFSET_CAPTURE hace que cada elemento
de la matriz que contiene una cadena se reemplace con una matriz de
dos elementos que contiene la misma cadena y la posición del carácter inicial en el a
int preg_match ( patrón de cadena, asunto de cadena [, coincidencias

de matriz [, banderas int ]])
Devuelve 1 si el patrón coincide con el asunto; de lo contrario, devuelva
0. Si se proporciona la matriz de coincidencias , la subcadena coincidente
se coloca en las coincidencias [0] y las coincidencias del grupo de
captura se colocan en los elementos posteriores. Un indicador permitido,
PREG_OFFSET_CAPTURE, hace que los elementos de las coincidencias
se reemplacen con una matriz de dos elementos que contiene la cadena
coincidente y la posición del carácter inicial de la coincidencia.
cadena preg_quote (cadena str [, delimitador de cadena])

Devuelve una cadena con todos los metacaracteres de expresión regular
escapados. Proporcione el parámetro delimitador si está utilizando
delimitadores opcionales con su expresión regular y necesita que el
delimitador escape en str.
preg_replace_callback mixto ( patrón mixto , devolución de llamada ,

asunto mixto [, límite int ])
Devuelve el texto del asunto con cada aparición de patrón reemplazada
con los resultados de la devolución de llamada. La devolución de llamada
debe tomar un parámetro, una matriz que contenga el texto coincidente
y cualquier coincidencia de los grupos de captura. Si se proporciona
límite , la función no realiza más que reemplazos de límite .
Si el patrón es una matriz, cada elemento se reemplaza con una

devolución de llamada. Si el tema es una matriz, la función itera sobre
cada elemento.
PHP | 55
preg_replace mixto ( patrón mixto , reemplazo mixto , sujeto mixto [, límite

int ])
Devuelve el texto del asunto con cada aparición de patrón
reemplazada por reemplazo. Si se proporciona límite , la
función no realiza más que reemplazos de límite . La cadena
de reemplazo puede hacer referencia a la coincidencia o
capturar coincidencias de grupo con $n (preferido) o \n
(obsoleto). Si el patrón tiene el modificador /e , el reemplazo
se analiza para la sustitución de referencia y luego se ejecuta como códig
Si patrón es una matriz, cada elemento se reemplaza con
reemplazo o, si reemplazo es una matriz, el elemento
correspondiente en reemplazo. Si el tema es una matriz, la
función itera sobre cada elemento.
matriz preg_split ( patrón de cadena, asunto de cadena [, límite int [,

banderas int]])
Devuelve una matriz de cadenas rotas alrededor del patrón. Si se
especifica límite , preg_split( ) no devuelve más que límite de
subcadenas. Un límite de 1 es lo mismo que "sin límite", lo que le
permite establecer banderas. Las banderas disponibles son:
PREG_SPLIT_NO_EMPTY, devolver solo piezas no vacías;
PREG_SPLIT_DELIM_CAPTURE, devuelve subcoincidencias
capturadas después de cada subcadena dividida; y
PREG_SPLIT_OFFSET_CAPTURE, devuelven una matriz de dos
matrices de elementos donde el primer elemento es la coincidencia y el segundo ele
Ejemplos
//Busca a SpiderMan, Spiderman, SPIDERMAN, etc.

$dailybugle = "¡SpiderMan amenaza la ciudad!";
$regex = "/araña[ ]?hombre/i";
if (preg_match($regex, $dailybugle)) { //hacer

algo
}

//Coincidencia de fechas formateadas como DD/MM/AAAA, DD

MMAA,... $fecha =
"30/12/1969"; $p = "!^(\\d\\d)[/](\\d\\d)[/](\\d\\d(?:\\d\\d)?)$ !";
if (preg_match($p,$date,$matches) { $mes
= $matches[1]; $day =
$matches[2]; $year =
$matches[3];
}
//Convertir a para conformidad con XHTML

$texto = "Hola mundo. ";
$patrón = "{ }i";
echo preg_replace($patrón, " ", $texto);
//urlify convertir URLs en enlaces HTML

$text = "Consulte el sitio web, http://www.oreilly.com/catalog/regexppr.";
$expresión
regular =
"{ \\b # comienza en la
"
. palabra\n" #
límite\n" . "( # capturar a $1\n". "(https?|telnet|gopher|archivo|
wais|ftp): \n"
"
. # recurso y dos puntos\n"
. "[\\w/\\#~:.?+=&%@!\\]+? # uno o más válidos\n"
"
. # caracteres\n" #
"
. pero toma tan poco como\n"
"
. # posible\n"
. ")\n" .
"(?= # anticipación\n". "[.:?\\]* # para posibles puntos\n".
"(?:[^\\w/\\#~:.?+=&%@ !\\] # carácter no válido\n" . "|$) # o final
de cadena\n" . ") }x";
echo preg_replace($regex, "<a href=\"$1\">$1</a>", $texto);
PHP | 57
Otros recursos
• Documentación en línea de PHP en http://www.php.net/pcre. •
Mastering Regular Expressions, Third Edition, de Jeffrey EF Friedl
(O'Reilly), cubre los detalles de las expresiones regulares de PHP en
las páginas 439–481.
Pitón
Python proporciona una rica sintaxis de expresiones regulares similar a
Perl en el módulo re . El módulo re utiliza un motor de coincidencia NFA
tradicional. Para obtener una explicación de las reglas detrás de un motor
NFA, consulte "Introducción a expresiones regulares y coincidencia de patrones".
Este capítulo cubrirá la versión de re incluida con Python 2.3.5, aunque el

módulo ha estado disponible en forma similar desde Python 1.5.
Metacaracteres compatibles
El módulo re es compatible con los metacaracteres y las metasecuencias
que se enumeran en la Tabla 27 a la Tabla 31. Para obtener definiciones
ampliadas de cada metacarácter, consulte "Metacaracteres, modos y
construcciones Regex".
Tabla 27. Representaciones de caracteres de Python
\ octal Carácter especificado por hasta tres dígitos octales.

Tabla 27. Representaciones de caracteres de Python (continuación)
\xhh Carácter especificado por un código hexadecimal de dos dígitos.
\uhhhh Carácter especificado por un código hexadecimal de cuatro dígitos.
\Uhhhhhhhh Carácter especificado por un código hexadecimal de ocho dígitos.
Tabla 28. Clases de caracteres de Python y construcciones similares a clases
Clase Significado
[...] Cualquier carácter enumerado o contenido dentro de un rango enumerado.
[^...] Cualquier carácter que no esté en la lista y que no esté contenido

dentro de un rango de la lista.
. Cualquier carácter, excepto una nueva línea (a menos que esté en modo DOTALL ).
\w Carácter de palabra, [azAz09_] (a menos que esté en modo LOCALE

o UNICODE ).
\W Carácter sin palabra, [âzAz09_] (a menos que esté en modo LOCALE o

UNICODE ).
\s Carácter de espacio en blanco, [ \t\n\r\f\v].
\S Carácter sin espacios en blanco, [ \t\n\r\f\v].
Tabla 29. Anclajes de Python y pruebas de ancho cero
^ Comienzo de cadena, o el punto después de cualquier salto de línea si

está en modo de coincidencia MULTILÍNEA .
Fin de la cadena de búsqueda, o el punto antes de una línea nueva que finaliza
ps
la cadena, o antes de cualquier línea nueva en el modo de coincidencia

MULTILÍNEA .
\Z Fin de cadena, o el punto anterior a una nueva línea que finaliza una
cadena, en cualquier modo de coincidencia.
Pitón | 59
Tabla 29. Anclajes de Python y pruebas de ancho cero (continuación)
Tabla 30. Comentarios de Python y modificadores de modo
Yo o IGNORAR CASO i Coincidencia que no distingue entre mayúsculas y minúsculas.
L o LOCAL L Hacer que \w, \W, \b y \B utilicen la

definición de alfanumérico de la
configuración regional actual.
^ y $coincidencia junto a \n incrustado.

M o MULTILINEA o (?m) m
S o DOTALL o (?s) s El punto (.) coincide con la nueva línea.
U o UNICODE o (?u) tu Causa \w, \W, \b y \B para usar

la definición Unicode
de alfanumérico.
X o VERBOSO o (?x) X Ignore los espacios en blanco y permita

comentarios (#) en el patrón.
iLmsux) para toda la expresión regular.
#... Trate el resto de la línea como un comentario

en modo VERBOSE .
Tabla 31. Agrupación, captura, condicional y control de Python
(...) Agrupe el subpatrón y capture la subcoincidencia en \1,\2,....
(?P<nombre> ...) Subpatrón de grupo y subcoincidencia de captura en un grupo de captura

con nombre, nombre.

Tabla 31. Agrupación, captura, condicional y control de Python (continuación)
Hacer coincidir el texto con el grupo de captura nombrado anteriormente,

(?P=nombre)
nombre.
Contiene los resultados de la enésima subcoincidencia anterior.

\norte
{norte}
Coincidir exactamente n veces.
?? Coincide 0 o 1 vez, pero la menor cantidad de veces posible.
{x, y}? Haga coincidir al menos x veces, no más de y veces y la menor cantidad de
veces posible.
Objetos y funciones del módulo re El módulo re
define toda la funcionalidad de expresiones regulares.

La coincidencia de patrones se realiza directamente a través de las funciones
del módulo, o los patrones se compilan en objetos de expresión regular que
se pueden usar para la coincidencia de patrones repetidos. La información
sobre la coincidencia, incluidos los grupos capturados, se recupera a través
de los objetos de coincidencia.
La sintaxis de cadena sin procesar de Python, r'' o r"", le permite especificar

patrones de expresiones regulares sin tener que escapar de las barras
invertidas incrustadas. El patrón de cadena sin procesar, r'\n', es equivalente
al patrón de cadena regular, \\n. Python también proporciona cadenas sin
procesar con comillas triples para expresiones regulares de varias líneas:
r'''text''' y r"""text""".
Pitón | 61
Funciones del módulo
El módulo re define las siguientes funciones y una excepción. compilar (patrón [,
banderas])
Devuelve un objeto de expresión regular con los modificadores de modo
opcionales,
indicadores. coincidencia (patrón, cadena [, banderas])
Busque el patrón en la posición inicial de la cadena y devuelva un objeto de
coincidencia o Ninguno si no hay coincidencia.
buscar (patrón, cadena [, banderas])

Busque el patrón en la cadena y devuelva un objeto de coincidencia o Ninguno si
no hay coincidencia.
split(patrón, cadena [, maxsplit=0])

Divida la cadena en el patrón y limite el número de divisiones a maxsplit. También
se devuelven las subcoincidencias de los paréntesis de captura.
sub(patrón, repl, cadena [, cuenta=0])

Devuelve una cadena con todas o hasta contar las ocurrencias del patrón en la
cadena reemplazadas con repl. repl puede ser una cadena o una función que
toma un argumento de objeto de coincidencia.
subn(patrón, repl, cadena [, cuenta=0])

Ejecute sub( ), pero devuelva un par de la nueva cadena y el número de reemplazos.
findall(patrón, cadena)
Devuelve coincidencias de patrón en cadena. Si el patrón tiene grupos de captura,
devuelve una lista de subcoincidencias o una lista de tuplas de subcoincidencias.
finditer(patrón, cadena)
Devuelve un iterador sobre las coincidencias del patrón en la cadena. Para cada
coincidencia, el iterador devuelve un objeto de
coincidencia. escapar (cadena)

Devuelve la cadena con los caracteres alfanuméricos con barra invertida para que
la cadena pueda coincidir literalmente.
error de excepción
La excepción generada si se produce un error durante la compilación o la
coincidencia. Esto es común si una cadena pasada a una función no es una
expresión regular válida.

RegExp
Los objetos de expresión regular se crean con la función re.compile . flags
Devuelve el argumento flags utilizado cuando se compiló el objeto, o 0.

groupindex
Devuelve
un diccionario que asigna nombres de grupos simbólicos a números de
grupos.
patrón
Devuelve la cadena de patrón utilizada cuando se compiló el objeto.
match(cadena [, pos [, endpos]])
search(cadena [, pos [, endpos]])
split(cadena [, maxsplit=0]) sub(repl,
string [, count=0]) subn(repl, cadena
[, cuenta=0]) findall(cadena)
Igual que las funciones del módulo re , excepto que el patrón está
implícito. pos y endpos dan índices de cadena de inicio y final para la
coincidencia.
Hacer coincidir objetos
Los objetos de coincidencia son creados por las funciones de coincidencia y búsqueda .
posición
endpos
Valor de pos o endpos pasado para buscar o hacer coincidir.
re
El objeto de expresión regular cuya coincidencia o búsqueda devolvió este
objeto.
cadena
Cadena pasada para hacer coincidir o
buscar. grupo ([g1, g2, ...])
Devuelve una o más subcoincidencias de los grupos de captura.
Los grupos pueden ser números correspondientes a grupos de captura
o cadenas correspondientes a grupos de captura con nombre. Grupo 0
pitón | 63
corresponde a todo el partido. Si no se proporcionan argumentos, esta función

devuelve la coincidencia completa. Los grupos de captura que no coincidieron
tienen un resultado de Ninguno. grupos ([predeterminado])
Devuelve una tupla de los resultados de todos los grupos de captura. Los grupos
que no coincidieron tienen el valor Ninguno o predeterminado.
grupodict([predeterminado])
Devuelve un diccionario de grupos de captura con nombre, con clave por
nombre de grupo. Los grupos que no coincidieron tienen el valor Ninguno o
predeterminado. inicio([grupo])
Índice del inicio de la subcadena coincidente por grupo (o inicio de toda la
cadena coincidente si no hay
grupo). final([grupo])
Índice del final de la subcadena coincidente por grupo (o final de toda la cadena
coincidente si no hay grupo).
lapso([grupo])
Devuelve una tupla de índices iniciales y finales del grupo (o cadena coincidente
si no hay grupo). expandir ([plantilla])
Devuelve una cadena obtenida al hacer una sustitución de barra invertida en la

plantilla. Se expanden los escapes de caracteres, las referencias inversas
numéricas y las referencias inversas con
nombre.
lastgroup Nombre del último grupo de captura coincidente, o Ninguno si no hay
coincidencia o si el grupo no tiene nombre.
últimoíndice
Índice del último grupo de captura coincidente, o Ninguno si no hay coincidencia.
Compatibilidad con
Unicode ofrece compatibilidad limitada con Unicode. Las cadenas

pueden contener caracteres Unicode y los caracteres Unicode
individuales se pueden especificar con \u. Además, el indicador
UNICODE hace que \w, \W, \b y \B reconozcan todos los caracteres
alfanuméricos Unicode. Sin embargo, re no proporciona compatibilidad
para hacer coincidir propiedades, bloques o categorías de Unicode.

Ejemplos
#Find SpiderMan, Spiderman, SPIDERMAN, etc. importar re
dailybugle = '¡SpiderMan amenaza la ciudad!' patrón

= r'araña[ ]?hombre.'
if re.match(patrón, dailybugle, re.IGNORECASE): imprimir dailybugle
#Coincidencia de fechas formateadas como MM/DD/AAAA, MMDDAA,...

importar re
fecha = '30/12/1969'
expresión regular = re.compile(r'^(\d\d)[/](\d\d)[/](\d\d(?:\d\d)?)$')
coincidencia = expresión regular.coincidencia(fecha)
si coincide:
mes = partido.grupo(1) #12 día =
partido.grupo(2) #30 año =
partido.grupo(3) #1969
#Convertir a para la importación de conformidad

con XHTML re
texto = 'Hola mundo. ' expresión

regular = re.compile(r' ', re.IGNORECASE); repl = r' '
resultado = expresión regular.sub(reemplazo,texto)
Pitón | sesenta y cinco

#urlify: convierta las URL en enlaces HTML

importados
text = 'Consulte el sitio web, http://www.oreilly.com/catalog/regexppr.'
patrón = r''' \b #
comienza en el límite de la palabra ( # captura a \1 (https?|
telnet|gopher|file|wais|ftp) :
# recurso y dos puntos #

[\w/#~:.?+=&%@!\] +? uno o más caracteres válidos #
tomar lo menos posible
) (?= # mirar hacia el futuro
[.:?\] * (?: # para un posible golpe

[^\w/#~:.?+=&%@!\] | $ ) )''' # carácter invalido
# o final de cadena
regex = re.compile(patrón, re.IGNORECASE +

re.VERBOSE)
resultado = expresión regular.sub(r'<a href="\1">\1</a>', texto)
Otros recursos
• Documentación en línea de Python en http://www.python.org/
doc/current/lib/modulere.html.
RUBÍ
Ruby proporciona un subconjunto de expresiones regulares de estilo Perl
integradas en las clases Regexp y String . Ruby utiliza un motor de
coincidencia NFA tradicional. Para obtener una explicación de las reglas
detrás de un motor NFA tradicional, consulte "Introducción a expresiones
regulares y coincidencia de patrones".

Ruby 1.9 presenta un nuevo motor de expresiones regulares que incluye

varias características nuevas. Estas funciones están disponibles en
versiones anteriores como parte de la biblioteca de Oniguruma. La
siguiente referencia cubre principalmente Ruby 1.8.6, pero también se
incluyen y marcan las funciones más destacadas de Ruby 1.9.
Metacaracteres admitidos Ruby es
compatible con los metacaracteres y metasecuencias enumerados en

la Tabla 32 a la Tabla 37. Para obtener definiciones ampliadas de cada
metacaracter, consulte "Metacaracteres Regex, modos y construcciones".
Tabla 32. Representaciones de caracteres Ruby
\mi carácter ESC, \x1B.
\0octal Carácter especificado por un código octal de dos dígitos.
Tabla 33. Clases de caracteres de Ruby y tipo de clase

construcciones
Clase Significado
de la lista.
RUBÍ | 67
Tabla 33. Clases de caracteres Ruby y construcciones similares a clases

(continuación)
Clase Significado
. Cualquier carácter, excepto un terminador de línea (a menos que el modo de una

sola línea, s).
\w Carácter de palabra.
\W Personaje sin palabra.
\d Dígito.
\D sin dígitos
\s Carácter de espacio en blanco, [ \f\n\r\t\v].
\S Carácter sin espacio en blanco, [^ \f\n\r\t\v].
Tabla 34. Anclajes Ruby y otras pruebas de ancho cero
^
Comienzo de cadena, o el punto después de cualquier salto de línea.
\A Comienzo de la cadena, en todos los modos de coincidencia.
ps Fin de cadena, o el punto antes de cualquier salto de línea.
\Z Fin de cadena, pero antes de cualquier terminador de línea final, en todos los modos de
coincidencia.
\z Fin de cadena, en todos los modos de partido.
\b Límite entre un carácter \w y un carácter \W .
\GRAMO Fin del partido anterior.
Tabla 35. Comentarios de Ruby y modificadores de modo
Carácter de modo Significado
metro El punto (.) coincide con cualquier carácter, incluido un terminador de línea.
Tenga en cuenta que esto es diferente de la mayoría de las implementaciones de expresiones regulares.
X Ignore los espacios en blanco y permita comentarios incrustados que

comiencen con #.

Tabla 35. Comentarios de Ruby y modificadores de modo (continuación)
Carácter de modo Significado
i Coincidencia que no distingue entre mayúsculas y minúsculas basada en caracteres de la referencia
cultural actual.
norte Desactive el procesamiento de caracteres anchos.
o Evaluar #{...} sustituciones solo una vez. El valor predeterminado es evaluar cada vez que
se evalúa la expresión regular.
(?imnsimns) Active o desactive las banderas de coincidencia para el resto del patrón.
(?imns Active o desactive los indicadores de coincidencia para el resto de la subexpresión.
imns: ...) (?#...) Trate la subcadena como un comentario.
#... Trata el resto de la línea como un comentario en modo /x .
(?<=...) Mirada positiva hacia atrás. (Rubí 1.9)
(?<!...) Mirada negativa hacia atrás. (Rubí 1.9)
Tabla 36. Agrupación, captura, condicional y control de Ruby
(...) Agrupamiento. Las subcoincidencias llenan \1,\2, . . . y $1, $2,....
(?<nombre>...) Nombrado capturado. La coincidencia agrupada llenará \k<nombre>.
(Rubí 1.9)
\norte En una expresión regular, haga coincidir lo que coincidió con la enésima
$n En una cadena de reemplazo, contiene la enésima subcoincidencia anterior.
\k<nombre> En una cadena de reemplazo, contiene el nombre de la subcoincidencia con nombre.
(Rubí 1.9)
(?:...) (? Paréntesis de solo agrupación, sin captura.
>...) ...|... Agrupación atómica.
Alternancia; coincidir con uno u otro.
RUBÍ | 69
Tabla 36. Agrupación, captura, condicional y control de Ruby (continuación)
{norte,} Coincide al menos n veces.
{norte,}? {x, y}? Haga coincidir al menos x veces, no más de y veces y la menor cantidad de veces posible.
Tabla 37. Secuencias de reemplazo de Ruby
${nombre} Texto coincidente de un grupo de captura con nombre.
ps Texto antes del partido.
ps Texto del partido.
$` Texto después del partido.
Interfaz orientada a objetos

Ruby proporciona una interfaz de expresión regular orientada
a objetos a través de las clases Regexp y MatchData , así
como varios métodos integrados de la clase String .
Ruby también proporciona los operadores /.../ y =~ para proporcionar

una sintaxis de operador similar a la de Perl. El operador /.../ es un
sinónimo de Regexp.new, y =~ es un sinónimo de String#match. El
operador /.../ se usa comúnmente para pasar un objeto Regexp a
un método, por ejemplo, "foo, bar, frog".split(/,\s*/).

Cadena
Descripción
Los objetos de cadena contienen métodos integrados para la comparación y

sustitución de patrones de expresiones regulares, así como varios métodos para
la manipulación de cadenas que toman expresiones regulares como argumentos.
Métodos de instancia
string =~ regexp => fixnum o nil Coincide con

la expresión regular y devuelve la posición en la que comienza la coincidencia, o nil.
expresión regular === cadena =>

booleano Devuelve verdadero si la expresión regular coincide con la cadena. Se
utiliza en caso de declaraciones.
gsub(patrón, reemplazo) => nueva_cadena gsub(patrón)
{|coincidencia| bloque } => nueva_cadena Devuelve una copia

de la cadena con todas las ocurrencias de patrón reemplazadas por reemplazo, o el
valor del bloque. De lo contrario, se comporta como Regexp#sub. gsub!(patrón,
reemplazo) => cadena o nil gsub!
(patrón) {|coincidencia| bloque } => cadena o nil Realiza las
sustituciones de String#gsub en su lugar, devolviendo cadena o

devolviendo nil si no se realizaron sustituciones.
index(regexp [, offset]) => fixnum o nil Devuelve el índice

de la primera coincidencia por regexp o nil si no se encuentra. Opcionalmente, el
desplazamiento especifica la posición en la cadena para comenzar la búsqueda.
match(pattern) =>
matchdata o nil Aplicar un patrón aregex o un

objeto Regexp a la cadena, devolver un objeto MatchData o devolver nil si no hubo
ninguna coincidencia.
rindex(regexp [, fixnum]) => fixnum o nil Devuelve el índice

de la primera coincidencia por regexp o nil si no se encuentra. Opcionalmente, el
desplazamiento especifica la posición en la cadena para finalizar la búsqueda; los
caracteres a la derecha de este punto no serán considerados.
RUBÍ | 71
escanear(regexp) => array

escanear(regexp) {|coincidir, ...| bloque } => cadena
Repita la cadena y devuelva una matriz de coincidencias o, si la expresión
regular contiene grupos coincidentes, una matriz de matrices. [regexp] =>
subcadena
o nil [regexp, fixnum] =>
subcadena o nil segmento(regexp) =>
subcadena o nil segmento(regexp,
fixnum) => subcadena o nil Devuelve la subcadena
coincidente o nil. Si se proporciona un número fijo , devuelva la
subcoincidencia correspondiente.
rebanada!(regexp) => new_str o nil
Elimine la parte coincidente de la cadena y devuelva la parte eliminada, o
devuelva nil si no hay ninguna coincidencia. split(pattern=$;,
[limit]) => anArray Divide la cadena en
subcadenas según un delimitador, que puede ser una cadena o un objeto
Regexp .
Si el límite es positivo, devuelve en la mayoría de las coincidencias de
límite . Si no se proporciona ningún límite , se omiten las subcadenas
vacías finales. Si el límite es negativo, se devuelven todas las subcadenas,
incluidas las
subcadenas vacías finales. sub(regexp,
reemplazo) => nueva_cadena sub(regexp) {|
coincidencia| block } => new_string Devuelve una copia de la cadena con
la primera coincidencia de regexp reemplazada por reemplazo, o el valor
del bloque. La cadena de reemplazo puede hacer referencia a
bloque puede hacer subcoincidencias con \n. El formulario de
referencia a las secuencias \1, \2, ..., variables de coincidencia especiales $1, $2, $`, $
sub!(patrón, reemplazo) => cadena o nil sub!(patrón)
{|coincidencia| bloque } => cadena o nil Realiza las
sustituciones de Cadena#sub en su lugar, devolviendo cadena o
devolviendo nil si no se realizaron sustituciones.
expresión regular
Descripción
Contiene una expresión regular que se utiliza para comparar un patrón con
cadenas.

Métodos de clase
escape(cadena) => cadena_escape

cita(cadena) => cadena_escape
Escape de metacaracteres de expresión regular, para que no se
interpreten cuando se usan dentro de un patrón de expresión
regular. last_match => datos
de coincidencia last_match(n)
=> cadena Devuelve los datos de coincidencia de la última coincidencia
exitosa o el campo n en el objeto MatchData .
Regexp.new(patrón [, opciones [, idioma]]) => expresión regular
Regexp.compile(patrón [, opciones [, idioma]]) => expresión regular
Cree un nuevo objeto Regexp a partir de un patrón de expresión regular.
Las opciones pueden ser una combinación OR de Regexp::EXTENDED,
Regexp::IGNORECASE y Regexp::MULTILINE. El parámetro lang habilita el
soporte multibyte para la expresión regular: 'n', 'N' = ninguno, 'e', 'E' = EUC,
's', 'S' = SJIS, 'u', 'U' = UTF 8.
Regexp.union([pattern]*) => new_str Crea un

objeto Regexp que es la unión de patrones dados unidos por el operador de
alternancia, donde cada patrón es una cadena de patrón o un objeto Regexp .
regexp == second_regexp => boolean

regexp.eql?(second_regexp) => boolean
Devuelve verdadero si dos objetos Regexp se basan en patrones idénticos y
tienen el mismo código de conjunto de caracteres y opciones de
modo. match(string) => matchdata o nil
Devuelve un objeto MatchData que describe la coincidencia, o nil si no hubo
coincidencia.
plegable? => verdadero o falso
Retorna verdadero si IGNORECASE está configurado para todo
el patrón. inspeccionar
=> cadena Devuelve una representación de cadena del objeto
Regexp . kcode =>
string Devuelve el código del juego de caracteres para el objeto
Regexp . options =>
fixnum Devuelve el conjunto de bits correspondientes a las opciones utilizadas
al crear este Regexp. Estos bits se pueden pasar como opciones a una nueva
expresión regular.
RUBÍ | 73
fuente => cadena

Devuelve la cadena de patrón
original. to_s
=> cadena Devuelve una cadena que contiene la expresión regular
y sus opciones, utilizando la notación (?imnsimns:...) .
MatchData
Descripción
Contiene los resultados de una coincidencia exitosa, incluida la cadena coincidente

y las subcoincidencias de los grupos de coincidencias.
[i] => cadena

[inicio, longitud] => matriz
[rango] => matriz
Acceda a los resultados de las coincidencias como una matriz. El elemento 0
es la cadena coincidente completa y los elementos del 1 al n contienen
subcoincidencias.
begin(n) => entero Devuelve el desplazamiento del inicio de la enésima
subcoincidencia en
la cadena. captures => matriz Devuelve la matriz de capturas, equivalente
a MatchData#to_a.
end(n) => entero Devuelve el desplazamiento del final de la enésima
subcoincidencia en
la cadena. length
=> integer size => integer Devuelve el número de elementos, incluidas la
coincidencia completa y las
subcoincidencias, en
la matriz de coincidencias. offset(n) => matriz Devuelve una matriz de dos
elementos que contiene las compensaciones
inicial y final de la enésima
subcoincidencia. post_match => cadena Devuelve la parte de la cadena
original después de la coincidencia actual (igual que $`).
pre_match => cadena

Devuelve la parte de la cadena original antes de la coincidencia actual (igual
que $`).

select([index]*) => matriz Utilice

cada índice para acceder a las subcoincidencias, devolviendo una matriz
de los valores correspondientes.
cadena => cadena_original
Devuelve una copia de la cadena pasada para que
coincida. to_a =>
anArray Devuelve la matriz de
coincidencias.
to_s => cadena Devuelve la cadena coincidente completa.
Compatibilidad con
Unicode Ruby tiene cierta compatibilidad con UTF8, pero debe

habilitarla incluyendo la línea $KCODE = "UTF8" antes de usar las
construcciones. Cuando están habilitadas, las metasecuencias \w,
\d, \s y \b admiten caracteres Unicode fuera del rango ASCII.
También puede habilitar el procesamiento de expresiones regulares
multibyte pasando un parámetro de idioma a Regexp.new y
desactivar el procesamiento multibyte con el modificador /n .
Ejemplos
#Encontrar SpiderMan, Spiderman, SPIDERMAN, etc.
dailybugle = '¡SpiderMan amenaza la ciudad!'
si dailybugle.match(/spider[ ]?man./i) pone dailybugle
fin
#Fechas de partidos formateadas como MM/DD/AAAA, MMDDAA,...
fecha = '30/12/1969'
expresión regular = expresión regular.nuevo('^(\d\d)[/](\d\d)[/](\d\d(?:\d\d)?)$')
RUBÍ | 75
Ejemplo 22. Grupo de emparejamiento y captura (continuación)
if md = regexp.match(fecha)
mes = md[1] #12 día
= md[2] #30 año =
md[3] #1969 fin
#Convertir en para cumplir con XHTML
texto = 'Hola mundo. ' expresión
regular = expresión regular.new(' ', expresión regular::IGNORECASE)
resultado = texto.sub(regexp, " ")
#urlify convierte URLs en enlaces HTML

text = 'Consulte el sitio web, http://www.oreilly.com/catalog/regexppr.'
expresión regular = expresión regular.nuevo('

\b # comenzar en el límite de la palabra ( # capturar a \1
(https?|telnet|gopher|file|wais|ftp): # recurso y dos
puntos # uno o más caracteres válidos
[\w/#~:.?+=&%@!\] +?
# tomar lo menos posible
) (? # anticipación
= [.:?\] * # para un posible punc
(?: [^\w/#~:.?+=&%@!\] | # carácter inválido # o
$) fin de cadena
)', Regexp::EXTENDIDO)
resultado = texto.sub(regexp, '<a href="\1">\1</a>')

JavaScript
JavaScript introdujo el soporte de expresiones regulares similar a Perl
con la versión 1.2. Esta referencia cubre las versiones 1.5 a 1.7 según
lo definido por el estándar ECMA. Las implementaciones compatibles
incluyen Microsoft Internet Explorer 5.5+ y Firefox 1.0++. JavaScript
utiliza un motor de coincidencia NFA tradicional. Para obtener una
explicación de las reglas detrás de este motor NFA, consulte
Metacaracteres admitidos JavaScript
admite los metacaracteres y las metasecuencias enumerados en la

Tabla 38 a la Tabla 42. Para obtener definiciones ampliadas de cada
metacarácter, consulte “Metacaracteres, modos y construcciones
Regex”.
Tabla 38. Representaciones de caracteres de JavaScript
\0 Carácter nulo, \x00.
\b Retroceso, \x08; solo se admite en la clase de caracteres.
\t Pestaña vertical, \x0B.
\xhh Carácter especificado por un código hexadecimal de dos dígitos.
\uhhhh Carácter especificado por un código hexadecimal de cuatro dígitos.
JavaScript | 77
Tabla 39. Clases de caracteres de JavaScript y construcciones similares a clases
Clase Significado
de la lista.
. Cualquier carácter excepto un terminador de línea, [^\x0A\x0D\

u2028\u2029].
\w Carácter de palabra, [azAZ09_].
\W Carácter sin palabra, [âzAZ09_].
\s Carácter de espacio en blanco.
\S Carácter sin espacio en blanco.
Tabla 40. Anclajes de JavaScript y otras pruebas de ancho cero
^ Comienzo de cadena, o el punto después de cualquier nueva línea si está en modo de

coincidencia multilínea, /m.
ps Fin de la cadena de búsqueda, o el punto antes de una línea nueva que finaliza la
cadena, o antes de cualquier línea nueva si está en el modo de coincidencia de varias líneas, /m.
Tabla 41. Modificadores de modo de JavaScript
metro
^ y $ coinciden junto a los terminadores de línea incrustados.
i
Coincidencia que no distingue entre mayúsculas y minúsculas.

Tabla 42. Agrupación, captura, condicional y control de JavaScript
(...) Agrupe el subpatrón y capture la subcoincidencia en \1,\2, . . . y $1, $2,....
\norte En una expresión regular, contiene texto que coincide con el grupo de captura
n.
$n En una cadena de reemplazo, contiene texto que coincide con el grupo de

captura n.
(?:...) ...|... Agrupe el subpatrón, pero no capture la subcoincidencia.
?? Coincide 0 o 1 vez, pero la menor cantidad de veces posible.
{norte}? {x, y}? Haga coincidir al menos x veces, no más de y veces y la menor cantidad de veces
posible.
Objetos y métodos de coincidencia de patrones
JavaScript proporciona métodos convenientes de coincidencia de

patrones en objetos String , así como un objeto RegExp para una
coincidencia de patrones más compleja. Las cadenas de JavaScript
usan la barra invertida para los escapes; por lo tanto, cualquier escape
destinado al motor de expresiones regulares debe tener doble escape
(por ejemplo, \\w en lugar de \w). También puede usar la sintaxis literal
de expresión regular, /pattern/img.
JavaScript | 79
Cadena
Las cadenas admiten cuatro métodos convenientes para la coincidencia de patrones.

Cada método toma un argumento de patrón , que puede ser un objeto RegExp o una
cadena que contiene un patrón de expresión regular.
Métodos
buscar (patrón)
Haga coincidir el patrón con la cadena, devolviendo la posición del carácter
del comienzo de la primera subcadena coincidente o 1.
reemplazar (patrón, reemplazo)

Busque en la cadena una coincidencia de patrón y reemplace la subcadena
coincidente con reemplazo. Si el patrón tiene establecido el modo global, se
reemplazan todas las coincidencias del patrón . La cadena de reemplazo
puede tener $n construcciones que se reemplazan con el texto coincidente del
enésimo grupo de captura en el patrón. partido (patrón)
Haga coincidir el patrón con la cadena, devolviendo una matriz o 1. El

elemento 0 de la matriz contiene la coincidencia completa. Los elementos
adicionales contienen subcoincidencias de grupos de captura. En el
modo global (g) , la matriz contiene todas las coincidencias del patrón
sin subcoincidencias del grupo
de captura. dividir (patrón, límite)
Devuelve una matriz de cadenas rotas alrededor del patrón. Si se incluye el
límite , la matriz contiene como máximo las primeras subcadenas de límite rotas
alrededor del patrón. Si el patrón contiene grupos de captura, las subcadenas
capturadas se devuelven como elementos después de cada subcadena dividida.
RegExp
Modela una expresión regular y contiene métodos para la coincidencia de patrones.
Constructor
new RegExp(patrón, atributos) /patrón/
atributos Los objetos
RegExp se pueden crear con el constructor RegExp( ) o con una sintaxis
literal especial /.../. El patrón de parámetro es un patrón de expresión
regular requerido, y el

Los atributos de parámetro son una cadena opcional que contiene cualquiera
de los modificadores de modo g, i o m. El patrón de parámetro también puede
ser un objeto RegExp , pero luego se requiere el parámetro de atributos .
El constructor puede lanzar dos excepciones. SyntaxError se genera si el patrón

tiene un formato incorrecto o si los atributos contienen modificadores de modo no
válidos. Se genera TypeError si el patrón es un objeto RegExp y se omite el
parámetro de atributos .
Propiedades de
instancia
booleanas globales que indican si RegExp tiene el atributo g .
ignoreCase
Booleano que indica si RegExp tiene el atributo i .
últimoÍndice
La posición del personaje de la última coincidencia.
multilínea
Booleano que indica si RegExp tiene el atributo m .
fuente
El patrón de texto utilizado para crear este objeto.
Métodos
ejecutivo (texto)
Busque texto y devuelva una matriz de cadenas si la búsqueda tiene éxito, y
nula si falla. El elemento 0 de la matriz contiene la subcadena que coincide
con la expresión regular completa. Los elementos adicionales corresponden
a grupos de captura.
Si se establece el indicador global (g) , lastIndex se establece en la posición
del carácter después de la coincidencia, o cero si no hubo coincidencia.
Las sucesivas llamadas exec( ) o test( ) comenzarán en lastIndex. Tenga en
cuenta que lastIndex es una propiedad de la expresión regular, no de la
cadena que se busca. Debe restablecer lastIndex manualmente si está
utilizando un objeto RegExp en modo global para buscar varias cadenas.
prueba (texto)
Devuelve verdadero si el objeto RegExp coincide con el texto. El método test()

se comporta de la misma manera que exec() cuando se usa en modo global:
las llamadas sucesivas comienzan en lastIndex, incluso si se usan en diferentes
cadenas.
JavaScript | 81
Ejemplos
//Encontrar SpiderMan, Spiderman, SPIDERMAN, etc.

var dailybugle = "¡SpiderMan amenaza la ciudad!";
//regex debe coincidir con toda la cadena

var regex = /spider[ ]?man/i;
if (dailybugle.search(regex)) { //hacer
algo}
//Coincidencia de fechas formateadas como MM/DD/AAAA, MMDDAA,...

var fecha = "30/12/1969"; var p
=
nueva RegExp("^(\\d\\d)[/](\\d\\d)[/](\\d\\d(?:\\d\\ d)?)$" );
var resultado = p.exec(fecha); si

(resultado! = nulo) {
var mes = resultado[1]; var
dia = resultado[2]; var año =
resultado[3];
//Convertir a para cumplir con XHTML String text
= "Hello world. ";
var patrón = / /ig;
prueba.reemplazar(patrón, " ");
//urlify convierte las URL en enlaces HTML var

text = "Consulte el sitio web, http://www.oreilly.com/
catálogo/regexppr."; var
expresión
regular // comienza en el límite de la
= "\\b" + "(" palabra // captura a $1

Ejemplo 28. Sustitución más dura (continuación)
+ "(https?|telnet|gopher|archivo|wais|ftp) :" //
recurso y dos puntos
+ "[\\w/\\#~:.?+=&%@!\\]+?" // uno o más caracteres válidos //
toma lo menos posible
+ ")"
+ "(?=" // anticipación + "[.:?\\]*" // para posibles
puntos + "(?:[^\\w/\\#~:.?+= &%@!\\]"// carácter inválido +
"|$)" // o fin de cadena + ")";
text.replace(regex, "<a href=\"$1\">$1</a>");
Otros recursos
• JavaScript: The Definitive Guide, de David Flanagan (O'Reilly), es una
referencia para todo JavaScript, incluidas las expresiones regulares.
PCRE
La biblioteca de expresiones regulares compatibles con Perl (PCRE) es una
biblioteca de expresiones regulares en lenguaje C, de código abierto y
gratuita para cualquier uso, desarrollada por Philip Hazel. PCRE se ha
incorporado a PHP, el servidor web Apache 2.0, KDE, Exim, Analog y
Postfix. Los usuarios de esos programas pueden usar los metacaracteres
admitidos que se enumeran en la Tabla 43 a la Tabla 47.
La biblioteca PCRE utiliza un motor de coincidencia NFA tradicional. Para

obtener una explicación de las reglas detrás de un motor NFA, consulte
Esta referencia cubre la versión 7.0 de PCRE, cuyo objetivo es emular las
expresiones regulares al estilo de Perl 5.8, pero también incluye
características del próximo Perl 5.10.
PCRE se puede compilar con o sin soporte para cadenas UTF8, y con o
sin soporte para propiedades de caracteres Unicode. Las siguientes listas y
tablas asumen que ambas características están disponibles.
PCR | 83
Metacaracteres admitidos PCRE
admite los metacaracteres y las metasecuencias que se enumeran

en la Tabla 43 a la Tabla 47. Para obtener definiciones ampliadas
de cada metacarácter, consulte "Metacaracteres, modos y
construcciones Regex".
Tabla 43. Representaciones de caracteres PCRE
\b Retroceso, \x08; solo se admite en la clase de caracteres.
\mi Carácter de escape, \x1B.
\p{accesorio} Carácter contenido en un bloque o propiedad Unicode determinado.
\P{accesorio} Carácter no incluido en el bloque o la propiedad Unicode dados.
Tabla 44. Clases de caracteres PCRE y construcciones similares a clases
Clase Significado
[:clase:] Clase de caracteres de estilo POSIX válida solo dentro de una clase de
caracteres regex.
. Cualquier carácter, excepto nueva línea (a menos que el modo de una sola
línea, PCRE_DOTALL).

Tabla 44. Clases de caracteres PCRE y construcciones similares a clases
Clase Significado
\C un byte; sin embargo, esto puede corromper un carácter Unicode

arroyo.
\s Carácter de espacio en blanco, [\n\r\f\t\v ].
\S Carácter sin espacios en blanco, [^\n\r\f\t\v ].
\R Secuencia de nueva línea Unicode.
Tabla 45. Anclajes PCRE y pruebas de ancho cero
^ Inicio de cadena, o el punto después de cualquier nueva línea si está
en modo de coincidencia de varias líneas, PCRE_MULTILINE.
ps
Fin de la cadena de búsqueda, o el punto antes de una línea nueva que finaliza
la cadena, o antes de cualquier línea nueva si está en el modo de
coincidencia de varias líneas, PCRE_MULTILINE.
\Z Fin de cadena, o el punto anterior a una nueva línea que finaliza una
cadena, en cualquier modo de coincidencia.
\GRAMO
Comienzo de la búsqueda actual.
\b Límite de palabra; posición entre un carácter de palabra (\w) y un carácter

que no es de palabra (\W), el comienzo de la cadena o el final de la
cadena.
PCR | 85
Tabla 46. Comentarios PCRE y modificadores de modo
Carácter de modo
Modificador/secuencia Perl equivalente Significado
PCRE_CASELESS i Coincidencia que no distingue entre
mayúsculas y minúsculas para caracteres con
valores de puntos de código inferiores a 256. En
el modo UTF8, funciona para todos los caracteres
si está disponible la compatibilidad con propiedades Unicode.
PCRE_MULTILINE metro
^ y $coincidencia junto a \n
incrustado.
PCRE_DOTALL s El punto (.) coincide con la nueva línea.
PCRE_EXTENDIDO X
Ignore los espacios en blanco y permita
comentarios (#) en el patrón.
PCRE_UNGREEDY tu Codicia inversa de todos los

cuantificadores: * se vuelve no
codicioso, y *? se vuelve codicioso.
PCRE_ANCHORED Forzar coincidencia para comenzar en la
primera posición buscada.
PCRE_DOLLAR_ Obligue a $ a coincidir solo al final de una

ÚNICAMENTE
cadena en lugar de antes de una cadena
que termine con una nueva línea.
Anulado por el modo multilínea.
PCRE_NO_AUTO_ Deshabilitar la función de captura de

CAPTURA
paréntesis.
PCRE_UTF8 Trate las expresiones regulares y las
cadenas de asunto como cadenas de
caracteres UTF8 multibyte.
PCRE_AUTO_CALLOUT Insertar llamadas automáticas.
PCRE_DUPNAMES Permitir grupos con nombre duplicados.
PCRE_FIRSTLINE El patrón no anclado debe coincidir antes de

la primera línea nueva del sujeto.
PCRE_NEWLINE_CR Especifique la secuencia de caracteres

PCRE_NEWLINE_LF de nueva línea.
PCRE_NEWLINE_CRLF
PCRE_NEWLINE_ANY
PCRE_NOTBOL El comienzo del asunto no es el comienzo de la línea.
PCRE_NOTEOL El final del asunto no es el final de la línea.

Tabla 46. Comentarios PCRE y modificadores de modo (continuación)
Carácter de modo
Modificador/secuencia Perl equivalente Significado
PCRE_NOTEMPTY Una cadena vacía no es una

coincidencia válida.
PCRE_NO_UTF8_CHECK No valide cadenas UTF8.
PCRE_PARTIAL Las coincidencias fallidas que llegan al
final de la cadena de entrada devuelven

PCRE_ PARTIAL en lugar de
PCRE_ ERROR_NO_MATCH.

imsxU) para el resto de la subexpresión.
(?modo) Desactive los modos enumerados (uno o más

de imsxU) para el resto de la
subexpresión.
(?modo:...) Active los modos enumerados (uno o más de
imsx) entre paréntesis.
(?modo:...) Desactive los modos enumerados (uno o más
de imsx) entre paréntesis.
\Q Cita todos los siguientes metacaracteres

\MI
Finaliza un lapso que comienza con \Q.
#... Trata el resto de la línea como un comentario
en el modo PCRE_EXTENDED .
Tabla 47. Agrupamiento PCRE, captura, condicional y control
(...) Agrupe el subpatrón y capture la subcoincidencia en

\1,\2,....
(?P<nombre>...), Subpatrón de grupo y subcoincidencia de captura en

(?<nombre>),(?'nombre') un grupo de captura con nombre, nombre.
(?P=nombre),\k<nombre>, \k'nombre' Referencia inversa a la captura con
nombre. \n, \gn, \g{n} Contiene los resultados de la enésima
subcoincidencia anterior de un grupo de captura

entre paréntesis o un grupo de captura con nombre.
PCR | 87
Tabla 47. Agrupación, captura, condicional y control de PCRE (continuación)
(?:...) Agrupe el subpatrón, pero no capture la

subcoincidencia.
(?>...) ...|... Agrupación atómica.
*? Haga coincidir 0 o más veces, pero la menor cantidad
de veces posible.
+? Combina 1 o más veces, pero la menor cantidad de
veces posible.
?? Coincidir 0 o 1 veces, pero la menor cantidad de
veces posible.
{norte,}? Haga coincidir al menos n veces, pero la menor cantidad
de veces posible.
{x, y}? Haga coincidir al menos x veces, no más de y veces

y la menor cantidad de veces posible.
*+ Haga coincidir 0 o más veces, y nunca

retroceda.
++ Haga coincidir 1 o más veces, y nunca

retroceda.
{n}+ Haga coincidir al menos n veces, y nunca

retroceda.
{n,}+ Haga coincidir al menos n veces, y nunca

retroceda.
{x,y}+ Haga coincidir al menos x veces, no más de y veces,

y nunca retroceda.

Tabla 47. Agrupación, captura, condicional y control de PCRE (continuación)
(?(condición)...|...) Coincide con el patrón ifthenelse. La

condición puede ser el número de un grupo de
captura o una construcción de búsqueda

anticipada o posterior.
(?(condición)...) Empareja con el patrón sientonces.

La condición puede ser el número de un grupo
de captura o una construcción de

búsqueda anticipada o posterior.
API PCRE
Las aplicaciones que utilizan PCRE deben buscar los prototipos

de API en pcre.h e incluir el archivo de biblioteca real, libpcre.a,
compilando con lpcre.
La mayor parte de la funcionalidad está contenida en las funciones

pcre_ compile( ), que prepara una estructura de datos de
expresión regular, y pcre_exec( ), que realiza la comparación de patrones.
Usted es responsable de liberar memoria, aunque PCRE
proporciona pcre_free_substring() y pcre_free_substring_list() para
ayudar.
Sinopsis de la API de PCRE
pcre *pcre_compile(const char *patrón, int opciones, const char

**errptr, int *erroffset, const char sin firmar *tableptr)
Patrón de compilación con opciones de modificadores de modo
opcionales y tablas de configuración regional opcionales tableptr,
que se crean con pcre_maketables( ). Devuelve una expresión
regular compilada, o NULL, con errptr apuntando a un mensaje
de error y erroffset apuntando a la posición en el
patrón donde ocurrió el error. int pcre_exec(const pcre *código, const
pcre_extra *extra, const char *asunto, int longitud, int startoffset, int
opciones, int *ovector, int ovecsize)
Realice la coincidencia de patrones con una expresión regular compilada, un código y una
cadena de entrada suministrada, sujeto, de longitud de longitud. Los resultados de una coincidencia
exitosa se almacenan en ovector. El primer y segundo elementos de ovector contienen el
PCR | 89
posición del primer personaje en la partida general y el personaje que sigue

al final de la partida general. Cada par adicional de elementos, hasta dos
tercios de la longitud del ovector, contiene las posiciones del carácter inicial
y el carácter después de las subcoincidencias del grupo de captura. Las
opciones de parámetros opcionales contienen modificadores de modo y
pcre_extra contiene los resultados de una llamada a pcre_study( ).
pcre_extra *pcre_study(const pcre *código, int opciones, const char

**errptr)
Devuelve información para acelerar las llamadas a pcre_exec( )
con código. Actualmente no hay opciones, por lo que las opciones
siempre deben ser 0. Si se produce un error, errptr apunta a un
mensaje de error. int pcre_copy_named_substring(const pcre *código,
const char *sujeto, int *ovector, int stringcount, const char *stringname,
char *buffer, int buffersize)
Copie la subcadena que coincida con el nombre de cadena del
grupo de captura nombrado en el búfer. stringcount es el número
de subcadenas colocadas en ovector, generalmente el resultado
devuelto por
pcre_exec( ). int pcre_copy_substring(const char *subject, int *ovector,
int stringcount, int stringnumber, char *buffer, int buffersize)
Copie la subcadena que coincide con el número de cadena del
grupo de captura numerado en el búfer. stringcount es el número
de subcadenas colocadas en ovector, generalmente el resultado
devuelto por
pcre_exec( ). int pcre_get_named_substring(const pcre *código, const
char *sujeto, int *ovector, int stringcount, const char *stringname, const
char **stringptr)
Cree una nueva cadena, apuntada por stringptr, que contenga la subcadena
que coincida con el nombre de cadena del grupo de captura con nombre.
Devuelve la longitud de la subcadena. stringcount es el número de
subcadenas colocadas en ovector, generalmente el resultado devuelto por
pcre_exec( ).
int pcre_get_stringnumber(const pcre *código, const char *nombre)
Devuelve el número del grupo de captura asociado con el grupo de captura
nombrado, nombre.
int pcre_get_substring(const char *subject, int *ovector, int stringcount,
int stringnumber, const char **stringptr)
Cree una nueva cadena, apuntada por stringptr, que contenga la subcadena
que coincida con el grupo de captura numerado

número de cadena. Devuelve la longitud de la subcadena. stringcount es el

número de subcadenas colocadas en ovector, generalmente el resultado
devuelto por pcre_exec( ).
int pcre_get_substring_list(const char *subject, int *ovector, int stringcount, const
char ***listptr)
Devuelve una lista de punteros, listptr, a todas las subcadenas capturadas.
void pcre_free_substring(const char *stringptr)
Memoria libre señalada por stringptr y asignada por pcre_get_named_substring( ) o
pcre_get_substring_list( ).
void pcre_free_substring_list(const char **stringptr)

Memoria libre señalada por stringptr y asignada por pcre_ get_substring_list( ).
const char sin firmar
*pcre_maketables(void)
Cree tablas de caracteres para la configuración regional actual.
int pcre_fullinfo(const pcre *código, const pcre_extra *extra, int qué, void *dónde)
Coloque información en una expresión regular especificada por qué en dónde.

Los valores disponibles para PCRE_INFO_BACKREFMAX , PCRE_INFO_
CAPTURECOUNT, PCRE_INFO_FIRSTBYTE, PCRE_INFO_FIRSTTABLE,
PCRE_INFO_LASTLITERAL , PCRE_INFO_NAMECOUNT , PCRE_INFO_
NAMEENTRYSIZE, PCRE_INFO_NAMETABLE, PCRE_INFO_OPTIONS,
PCRE_ INFO_SIZE y PCRE_INFO_STUDYSIZE.
int pcre_config(int qué, void *dónde)
Coloque el valor de las opciones de tiempo de compilación especificadas por
qué en dónde. Los valores disponibles para PCRE_CONFIG_UTF8 , PCRE_
CONFIG_NEWLINE, PCRE_CONFIG_LINK_SIZE, PCRE_CONFIG_POSIX_
MALLOC_THRESHOLD y PCRE_CONFIG_MATCH_LIMIT.
char *pcre_version(vacío)
Devuelve un puntero a una cadena que contiene la versión de PCRE y la fecha de lanzamiento.
vacío *(*pcre_malloc)(tamaño_t)
El punto de entrada que utiliza PCRE para las llamadas malloc() .
vacío (*pcre_free)(vacío *)
Punto de entrada que utiliza PCRE para llamadas pcre_free( ) .
int (*pcre_callout)(pcre_callout_block *)
Se puede configurar en una función de llamada que se llamará durante los partidos.
PCR | 91
Compatibilidad con Unicode
PCRE proporciona compatibilidad básica con Unicode 5.0. Cuando se compila un

patrón con el indicador PCRE_UTF8 , el patrón se ejecutará en texto Unicode. Sin
embargo, PCRE determina el caso y la propiedad de ser una letra o un dígito en
función de un conjunto de tablas predeterminadas.
Puede proporcionar un conjunto de tablas alternativo basado en una configuración
regional diferente. Por ejemplo:
setlocale(LC_CTYPE, "en"); tablas

= pcre_maketables( ); re =
pcre_compile(..., tablas);
Ejemplos El
ejemplo 29 y el ejemplo 30 están adaptados de un ejemplo de

código abierto escrito por Philip Hazel y con derechos de autor de
la Universidad de Cambridge, Inglaterra.
#include <stdio.h>
#include <cadena.h>
#include <pcre.h>
#define CAPTUREVECTORSIZE 30 /* debe ser múltiplo de 3 */
int main(int argc, char **argv) { pcre
*regex; const
char *error;
compensación de
error interno; int capturevector[TAMAÑO DEL
VECTOR DE CAPTURA]; int rc;
char *patrón = "araña[ ]?hombre"; char *text

="¡SPIDERMAN amenaza la ciudad!";
/* Compilar expresión regular

*/ expresión regular =
pcre_compile(patrón,
PCRE_CASELESS, /* Modificadores de modo OR'd */

&error, /* mensaje de error */ /*

&desplazamiento de error, posición en la expresión regular donde ocurrió el error */ /* usar
NULO); configuración regional predeterminada */
/* Manejar errores */ if
(regex = = NULL)
{ printf("La compilación falló en el desplazamiento %d: %s\n", erroffset, error); devolver

1; }
/* Try Match */ rc =
pcre_exec( /*
expresión regular compilada */ regex, /* resultados
NULL,
opcionales de pcre_study */
texto, /* cadena de entrada */
(int)strlen(text), /* longitud de la cadena de entrada */ 0, 0, vector de
/* posición inicial en la cadena de entrada */
/* Opciones OR */
captura, /* contiene los resultados de los grupos de captura */
TAMAÑO DEL VECTOR DE CAPTURA);
/* Manejar errores */ if (rc <

0) { switch(rc)
{ case
PCRE_ERROR_NOMATCH: printf("Sin coincidencia\n"); romper;

predeterminado: printf("Error de coincidencia %d\n", rc); romper; }
devuelve 1; }
devuelve 0; }
#include <stdio.h> #include

<cadena.h> #include
<pcre.h>
PCR | 93
Ejemplo 30. Grupo de coincidencia y captura (continuación)
#define CAPTUREVECTORSIZE 30 /* debe ser múltiplo de 3 */
int main(int argc, char **argv) { pcre
*regex; const
char *error;
compensación de
error interno; int capturevector[TAMAÑO DEL
VECTOR DE CAPTURA]; int rc, yo;
char *patrón = "(\\d\\d)[/](\\d\\d)[/](\\d\\d(?:\\d\\d)?)"; char *texto="30/12/1969";
/* Compilar Regex */ re =
pcre_compile( patrón,
PCRE_CASELESS, /* Modificadores de modo OR */

&error, /* mensaje de error */ &erroffset, /*
posición en la expresión regular donde ocurrió el error */
NULO); /* usa la configuración regional predeterminada */
/* Manejar errores de compilación */ if (re

= = NULL) { printf("La
compilación falló en el desplazamiento %d: %s\n", erroffset,

error); devolver 1; }
rc = pcre_exec( /*
expresión regular compilada */ regex, /*
NULL,
resultados opcionales de pcre_study */
texto, /* cadena de entrada */
(int)strlen(text), /* longitud de la cadena de entrada */ 0, 0,
/* posición inicial en la cadena de entrada */
/* Opciones OR */
vector de captura, /* contiene los resultados de los grupos de captura */
TAMAÑO DEL VECTOR DE CAPTURA);

Ejemplo 30. Grupo de coincidencia y captura (continuación)
/* Manejar errores de coincidencia

*/ if (rc < 0)
{ switch(rc)
{ case PCRE_ERROR_NOMATCH: printf("No hay coincidencia\n");

romper; /*
Maneja otros casos especiales si quieres */
predeterminado: printf("Error de coincidencia %d\n", rc); romper; }
devuelve
1; }
/* Coincidencia exitosa */
printf("Coincidencia exitosa\n");
/* Comprobar el vector de salida para los grupos de captura */ if

(rc = = 0) { rc =
CAPTUREVECTORSIZE/3;
printf("ovector solo tiene espacio para %d subcadenas capturadas\n", rc 1);
/* Mostrar grupos de captura */
para (i = 0; i < rc; i++)
{ char *inicio_subcadena = texto + ovector[2*i]; int

longitud_subcadena = vectorcaptura[2*i+1]
vectorcaptura[2*i];
printf("%2d: %.*s\n", i, substring_length, substring_start); }
devolver
0; }
PCR | 95
Otros recursos
• El código fuente C y la documentación para PCRE en http://

www.pcre.org.
Servidor Web Apache

El servidor web Apache 2.0 introdujo expresiones regulares estilo Perl
basadas en la biblioteca PCRE. Apache 2.2 ahora tiene soporte para
PCRE 5.0. La biblioteca utiliza un motor de coincidencia NFA tradicional.
Para obtener una explicación de las reglas detrás de un motor NFA,
consulte "Introducción a expresiones regulares y coincidencia de patrones".
Varias directivas de Apache funcionan con expresiones

regulares. Esta sección cubre Apache 2.2 (que en su
mayoría es compatible con 2.0) y las directivas más
comunes: RewriteRule, LocationMatch, DirectoryMatch,
FilesMatch, ProxyMatch y AliasMatch.
Metacaracteres admitidos Apache

es compatible con los metacaracteres y metasecuencias
enumerados en la Tabla 48 a la Tabla 52. Para obtener
definiciones ampliadas de cada metacarácter, consulte
“Metacaracteres, modos y construcciones Regex”.
Tabla 48. Representaciones de caracteres de Apache
\x{hexadecimal}
Carácter especificado por cualquier código hexadecimal.
Carácter de control con nombre.

\cchar

Tabla 49. Clases de caracteres de Apache y construcciones similares a clases
Clase Significado
[...] Un solo carácter enumerado o contenido dentro de un rango

enumerado.
[:clase:] Clase de caracteres de estilo POSIX (válida solo dentro de una clase
de caracteres regex).
. Cualquier carácter, excepto nueva línea (a menos que el modo de una sola
línea, /s).
\C un byte; sin embargo, esto puede corromper un flujo de caracteres Unicode.
\s Carácter de espacio en blanco, [\n\r\f\t ].
\S Carácter sin espacios en blanco, [^\n\r\f\t ].
Tabla 50. Anclajes de Apache y pruebas de ancho cero
^
Comienzo de cadena.
ps Fin de la cadena de búsqueda.
\b Límite de palabra; posición entre un carácter de palabra (\w) y un carácter

que no es de palabra (\W), el comienzo de la cadena o el final de la
cadena.
Servidor Web Apache | 97

Tabla 51. Comentarios de Apache y modificadores de modo
Modos Significado
Coincidencia que no distingue entre mayúsculas y minúsculas.

CAROLINA DEL NORTE
(?modo) Active los modos enumerados (uno o más de imsxU) para el resto de la
subexpresión.
(?modo) Desactive los modos enumerados (uno o más de imsxU) para el resto de
la subexpresión.
(?modo:...) Active el modo (uno de xsmi) entre paréntesis.
(?modo:...) Desactive el modo (uno de xsmi) entre paréntesis.
Trate la subcadena como un comentario.

(?#...)
#... El resto de la línea se trata como un comentario en modo x .
Cita todos los siguientes metacaracteres de expresiones regulares.

\Q
Finaliza un lapso que comenzó con \Q.
\MI
Tabla 52. Agrupación, captura, condicional y control de Apache
secuencia (...) Significado
Agrupe el subpatrón y capture la subcoincidencia en \1, \2....
(?P<nombre>...) Subpatrón de grupo y subcoincidencia de captura en un grupo de captura
con nombre, nombre.
\norte Contiene los resultados de la enésima subcoincidencia anterior de un
grupo de captura entre paréntesis o un grupo de captura con nombre.
Agrupa el subpatrón, pero no captura la subcoincidencia.

(?:...)
Agrupación atómica.
(?>...)
Coincide 0 o más veces.

*
Coincidir 1 o más veces.
+
Coincide al menos n veces.

{n,}
Haga coincidir 0 o más veces, pero la menor cantidad de veces posible.

*?

Tabla 52. Agrupación, captura, condicional y control de Apache (continuación)
{x, y}? Haga coincidir al menos x veces, no más de y veces y la menor

cantidad de veces posible.
{n}+ Haga coincidir al menos n veces, y nunca retroceda.

retroceda.
(?(condición)...|...) Coincide con el patrón ifthenelse. La condición puede ser el número de un grupo de captura,
o una construcción de búsqueda anticipada o posterior.
(?(condición)...) Empareja con el patrón sientonces. La condición puede ser el

número de un grupo de captura, o una construcción de búsqueda
anticipada o posterior.
Regla de reescritura
El motor de reescritura permite la reescritura de direcciones URL basada

en expresiones regulares. La función está habilitada con la directiva
RewriteEngine On . La mayoría de las reescrituras son una RewriteRule
única o una combinación de directivas RewriteCond seguidas de una RewriteRule.
Sustitución del patrón RewriteRule [[FLAG1, FLAG2, ...]]

Reescribe la URL en sustitución si la URL coincide correctamente con
el patrón. La cadena de sustitución puede contener referencias
inversas ($N) al patrón RewriteRule , referencias inversas (%N) al
último patrón RewriteCond coincidente, variables de servidor como
en cadenas de prueba de condición de regla (%{VARNAME} ), y
llamadas a funciones de mapeo ( ${mapname: key|default} ). Los
indicadores opcionales, enumerados en la Tabla 53, hacen que el
servidor realice varias acciones cuando se produce una coincidencia.

Patrón de cadena de prueba

RewriteCond Defina una condición de prueba (Tabla 54) para
aplicar una regla de reescritura. Varias directivas RewriteCond que
preceden a RewriteRule se combinan con un AND implícito, a
menos que se especifique como OR. La cadena de prueba puede
contener referencias inversas ($N) al patrón RewriteRule ,
referencias inversas (%N) al último patrón RewriteCond
coincidente , variables de servidor como en cadenas de prueba de
condición de regla ( %{VARNAME}) y llamadas de función de mapeo ( ${mapna
Las variables del servidor que afectan las reescrituras se enumeran en la Tabla 55.
Tabla 53. Marcas de Apache RewriteRule
Modos Cadena de
C significados con la siguiente regla. Si la regla coincide, aplique la
reescritura y las siguientes reescrituras encadenadas; de lo
contrario, detenga la cadena.
CO=NOMBRE:VAL:dominio [:vida Pon una galleta.
útil[:ruta]]
E=VAR:VALOR Establecer una variable de entorno.
F Prohibido; devolver el código 403 .
GRAMO Desaparecido; devolver el código 401 .
H = controlador de contenido Establecer el controlador de contenido.
L Última regla; no aplique más reglas de reescritura.
norte
Siguiente regla; vuelva a aplicar las reglas de reescritura a la URL
recién reescrita.
CAROLINA DEL NORTE

No hay caso; aplicar coincidencias que no distinguen entre mayúsculas y minúsculas.
nordeste Deshabilite la aplicación de reglas de escape de URL a la salida de
una regla.
NS Omita el procesamiento si la solicitud es una subsolicitud
interna.
PAG
Detenga el procesamiento de reescritura y procese el resultado como
una solicitud de proxy interno.
PT Pase al siguiente controlador, configurando la estructura de
solicitud para que Alias, ScriptAlias y Redirect puedan trabajar con

el resultado.
QSA Agregar cadena de consulta.

Tabla 53. Marcas de Apache RewriteRule (continuación)
Modos Significado
R[=Código] Redirigir a una nueva URL con código opcional. El código

predeterminado es 302.
S=num Omita las siguientes reglas numéricas .
T=tipo MIME Establezca el tipo MIME.
Tabla 54. Marcas de Apache RewriteCond
Modos Significado
No hay caso; aplicar coincidencias que no distinguen entre mayúsculas y minúsculas.

CAROLINA DEL NORTE
O Úselo para combinar las condiciones de la regla con un OR local
en lugar del AND implícito.
Tabla 55. Variables del servidor Apache
Encabezados HTTP Conexión y solicitud
HTTP_USER_AGENT DIRECCIÓN_REMOTA
HTTP_REFERER SERVIDOR REMOTO
HTTP_COOKIE PUERTO REMOTO
HTTP_REENVIADO USUARIO_REMOTO
HTTP_HOST REMOTE_IDENT
HTTP_PROXY_CONEXIÓN SOLICITUD_MÉTODO
HTTP_ACEPTAR SCRIPT_NOMBRE DE ARCHIVO
Internos del servidor PATH_INFO
RAIZ DEL DOCUMENTO TIPO DE AUTENTICACIÓN
SERVIDOR_ADMIN Fecha y hora
SERVIDOR_ADDR HORA_AÑO
PUERTO DE SERVICIO HORA_MON
SERVIDOR_PROTOCOLO HORA DEL DÍA
SERVIDOR_SOFTWARE HORA_HORA

Tabla 55. Variables del servidor Apache (continuación)
Encabezados HTTP Conexión y solicitud
Especiales TIME_MIN
API_VERSION TIME_WDAY
LA SOLICITUD TIEMPO
SOLICITUD_URI
SOLICITUD_NOMBRE DE ARCHIVO
IS_SUBREQ
HTTPS
Directivas coincidentes
Varias otras directivas de Apache utilizan expresiones
regulares. Los siguientes son los más comunes.
Patrón AliasMatch rutaarchivo|rutadirectorio Asignar direcciones
URL a ubicaciones del sistema de archivos. Utilice las variables de subcoincidencia
$1...$n para acceder a las subcoincidencias en la ruta del archivo resultante.
<Patrón DirectoryMatch> ... </DirectoryMatch>

Aplique las directivas adjuntas cuando el directorio del sistema de archivos coincida
con el patrón.
<Patrón FilesMatch> ... </FilesMatch> Aplicar

directivas adjuntas cuando el archivo coincide con el patrón.
<Patrón LocationMatch> ... </LocationMatch>

Aplique las directivas adjuntas cuando la URL coincida con el patrón.
<Patrón ProxyMatch> ... </ProxyMatch>

Aplicar directivas adjuntas cuando la URL coincide con el patrón.
Ejemplos
# Reescribir /foo a /bar

Motor de reescritura encendido
Regla de reescritura ^/foo$ /bar

# Reescribir URL bonita como parámetros de secuencia

de comandos RewriteRule ^/(\w+)/(\d+) /index.php?action=$1&id=$2
Ejemplo 33. Reescribir condiciones
# Limite la URL de administración a las direcciones IP

internas RewriteCond %{REMOTE_ADDR} !192.168.\d*.
\d* RewriteCond %{PATH_INFO} âdmin
RewriteRule .* [F]
Ejemplo 34. Redirigir a SSL
# ¡Asegúrese de que las URL de administración se

sirvan en SSL RewriteCond %{SERVER_PORT} !
^443$ RewriteRule ^/admin/(.*)$ https://www.example.com/admin/$1 [L,R]
vi Redactor
El programa vi es un editor de texto popular en todos los sistemas Unix, y

Vim es un clon vi popular con soporte ampliado para expresiones regulares.
Ambos utilizan un motor de coincidencias de DFA. Para obtener una
explicación de las reglas detrás de un motor DFA, consulte "Introducción
a expresiones regulares y coincidencia de patrones".
Metacaracteres admitidos De la Tabla
56 a la Tabla 60 se enumeran los metacaracteres y metasecuencias

admitidos por vi. Para obtener definiciones ampliadas de cada metacarácter,
consulte "Metacaracteres, modos y construcciones Regex".
Tabla 56. Representación del carácter vi
solo video
\b Retroceso, \x08.
\mi Carácter de escape, \x1B.
vi Redactor | 103
Tabla 56. Representación del carácter vi (continuación)
Tabla 57. Clases de caracteres vi y construcciones similares a clases
Clase Significado
[...] Cualquier carácter enumerado o contenido dentro de un rango enumerado.
[^...] Cualquier carácter que no esté en la lista o que esté contenido dentro de un rango
de la lista.
[:clase:] Clase de carácter de estilo POSIX (válida solo dentro de una clase de carácter).
. Cualquier carácter excepto nueva línea (a menos que esté en modo /s ).
solo video
\a Carácter de letra, [azAz].
\A Carácter no alfabético, [âzAz].
\h Encabezamiento del carácter verbal, [azAz_].
\H No es la cabeza de un carácter de palabra, [âzAz_].
\s Carácter de espacio en blanco, [\t].
\S Carácter sin espacio en blanco, [^ \t].
\X Dígito hexadecimal, [afAF09].
\X Dígito no hexadecimal, [âfAF09].
\o Dígito octal, [07].
\O Dígito no octal, [^07].
\l Letra minúscula, [az].
\L Letra no minúscula, [âz].

Tabla 57. Clases de caracteres vi y construcciones similares a clases (continuación)
Clase Significado
\u Letra mayúscula, [AZ].
\U Letra no mayúscula, [ÂZ].
\i Carácter identificador definido por isident.
\I Cualquier carácter identificador que no sea un dígito.
\k Carácter de palabra clave definido por iskeyword, a menudo establecido por

modos de idioma.
\K Cualquier carácter de palabra clave que no sea un dígito.
\F Carácter de nombre de archivo definido por isfname. Dependiente del sistema

operativo.
\F Cualquier carácter de nombre de archivo que no sea un dígito.
\pag Carácter imprimible definido por isprint, generalmente x20x7E.
\PAG Cualquier carácter imprimible que no sea un dígito.
Tabla 58. Anclajes vi y pruebas de ancho cero
^ Comienzo de una línea cuando aparece primero en una expresión regular; de

lo contrario, se empareja a sí mismo.
ps Fin de una línea cuando aparece en último lugar en una expresión regular;
de lo contrario, se empareja a sí mismo.
\< Comienzo del límite de la palabra (es decir, una posición entre un carácter
de puntuación o espacio y un carácter de palabra).
\> Límite de fin de palabra.
Tabla 59. Modificadores del modo vi
:establecer ic Active el modo que no distingue entre mayúsculas y minúsculas para todas las
búsquedas y sustituciones.
:set noico Desactive el modo que no distingue entre mayúsculas y minúsculas.
\u Forzar el siguiente carácter en una cadena de reemplazo a mayúsculas.
\l Forzar el siguiente carácter en una cadena de reemplazo a minúsculas.
vi Redactor | 105
Tabla 59. Modificadores del modo vi (continuación)
\U Fuerce todos los siguientes caracteres en una cadena de reemplazo a

mayúsculas.
\L Fuerce todos los siguientes caracteres en una cadena de reemplazo a

minúsculas.
\E o \e
Finaliza un lapso que comenzó con \U o \L.
Tabla 60. vi agrupación, captura, condicional y control
$...$ Agrupe el subpatrón y capture la subcoincidencia en \1,\2,....
\norte Contiene los resultados de la enésima subcoincidencia anterior. Válido en un patrón
de expresión regular o en una cadena de reemplazo.
& Se evalúa como el texto coincidente cuando se usa en una cadena de

reemplazo.
solo video
\+ Coincidir 1 o más veces.
\= Partido 1 o 0 veces.
\{norte} Coincidir exactamente n veces.
\{norte,} Coincide al menos n veces.
\{,norte} Coincide como máximo n veces.
\{x,y} Coincidir al menos x veces, pero no más de y veces.
La coincidencia de patrones
buscando
/patrón ?patrón
Se mueve al inicio de la siguiente posición en el archivo que coincide con el patrón. Un patrón ? busca hacia atrás.
Una búsqueda se puede repetir con los comandos n (búsqueda hacia adelante) o N (búsqueda hacia atrás).

Sustitución
:[dirección1[,dirección2]]s/patrón/reemplazo/[cgp]
Reemplace el texto que coincide con el patrón con el reemplazo en cada línea del rango de direcciones. Si no se proporciona un
rango de direcciones, se utiliza la línea actual. Cada dirección puede ser un número de línea o una expresión regular. Si se
proporciona addr1 , la sustitución comienza en ese número de línea (o la primera línea coincidente) y continúa hasta el final del
archivo o la línea indicada (o coincidente) por addr2. También hay una serie de atajos de direcciones, que se describen en las
siguientes tablas.
Opciones de sustitución
Opción Significado
C Indicar antes de cada sustitución.
gramo
Reemplace todas las coincidencias en una línea.
pag
Línea de impresión después de la sustitución.
Atajos de direcciones
DIRECCIÓN Significado
. Línea actual.
Última línea en el archivo.

ps
% Archivo completo.
no Posición T.
/...[/] Siguiente línea emparejada por patrón.
?...[?] Línea anterior emparejada por patrón.
\/ Siguiente línea coincidente con la última búsqueda.
\? Línea anterior coincidente con la última búsqueda.
\& Siguiente línea donde coincidió el último patrón de sustitución.
vi Redactor | 107
Ejemplos
Ejemplo 35. Búsqueda simple en vi
Encuentra al Hombre Araña, Hombre Araña, Hombre Araña

/[Ss]araña[ ][Mm]an
Ejemplo 36. Búsqueda simple en Vim
Encuentra al hombre araña, al Hombre Araña, al Hombre Araña, al Hombre Araña, al

HOMBRE
ARAÑA,
etc. :set ic /spider[ ]\=man
Ejemplo 37. Sustitución simple en vi
Convierta globalmente a para cumplir con
XHTML. :conjunto ic : % s/ / /g
Ejemplo 38. Sustitución simple en Vim
Convierta globalmente a para cumplir con XHTML. :

% s/ / /ig
Ejemplo 39. Sustitución más dura en Vim
Urlify: Convierta las URL en enlaces

HTML : % s/$https\=:\/\/[az_.\\w\/\\#~:?+=&;%@!]*$/ <a href="
\1">\1<\/a>/ic
Otros recursos
• Learning the vi Editor, Sixth Edition, de Linda Lamb y Arnold
Robbins (O'Reilly), es una guía para el editor vi y los clones
populares de vi . •
http://www.geocities.com/volontir/, por Oleg Raisky, es una
descripción general de la sintaxis de expresiones regulares de Vim .

Herramientas de concha
awk, sed y egrep son un conjunto relacionado de herramientas de shell

de Unix para el procesamiento de texto. awk usa un motor de
coincidencias aDFA, egrep cambia entre un motor de coincidencias
DFA y NFA, según las funciones que se utilicen, y sed usa un motor
NFA. Para obtener una explicación de las reglas detrás de estos
motores, consulte "Introducción a expresiones regulares y coincidencia de patrones
Esta referencia cubre GNU egrep 2.4.2, un programa para buscar

líneas de texto; GNU sed 3.02, una herramienta para escribir comandos
de edición; y GNU awk 3.1, un lenguaje de programación para
procesamiento de texto.
Los metacaracteres admitidos awk,
egrep y sed admiten los metacaracteres y metasecuencias enumerados

en la Tabla 61 a la Tabla 65. Para obtener definiciones ampliadas de
cada metacarácter, consulte "Metacaracteres, modos y construcciones
Regex".
Tabla 61. Representaciones de caracteres de shell
Secuencia Significado Herramienta
\a Alerta (campana). awk, sed
\b Retroceso; solo se admite en la awk

clase de caracteres.
\F Alimentación de formulario. awk, sed
\norte Nueva línea (avance de línea). awk, sed
\r Retorno de carro. awk, sed
\t Pestaña horizontal. awk, sed
\v Pestaña vertical. awk, sed
\ooctal Un carácter especificado por un sed
código octal de uno, dos o tres

dígitos.
Herramientas de carcasa | 109

Tabla 61. Representaciones de caracteres de shell (continuación)
\ octal Un carácter especificado por un awk
código octal de uno, dos o tres

dígitos.
\xhex Un carácter especificado por un awk, sed
código hexadecimal de dos

dígitos.
\ddecimal Un carácter especificado por un awk, sed
código de uno, dos o tres decimales.
\cchar Un carácter de control con nombre awk, sed
(p. ej., \cC es ControlC).
\b Retroceso. awk
\metacaracter Escapar del metacarácter, para que awk, sed, egrep
literalmente se
represente a sí mismo.
Tabla 62. Clases de caracteres shell y similares a clases
construcciones
Clase Significado Herramienta
[...] Coincide con cualquier awk, sed, egrep

carácter individual
enumerado o contenido dentro de
un rango enumerado.
[^...] Coincide con cualquier awk, sed, egrep

carácter individual que no esté en la
lista o que esté dentro de un
rango de la lista.
. Coincide con cualquier awk, sed, egrep
carácter individual, excepto nueva línea.
\w Coincide con un carácter de egrep, sed

palabra ASCII, [azA
Z09_].

Tabla 62. Clases de caracteres de shell y construcciones similares a clases (continuación)
Clase Significado Herramienta
\W Coincide con un carácter que no es un egrep, sed

carácter de palabra ASCII,
[âzAZ0 9_].
[:apuntalar:] Coincide con cualquier carácter de la awk, sed

clase de caracteres POSIX.
[^[:accesorio:]] Coincide con cualquier carácter que no awk, sed

esté en la clase de caracteres
POSIX.
Tabla 63. Anclajes de coraza y otras herramientas de coraza de prueba de ancho cero
Herramienta
^
Coincide solo con el inicio de la awk, sed, egrep
cadena, incluso si las líneas nuevas

están incrustadas.
ps Coincide solo con el final de la cadena awk, sed, egrep
de búsqueda, incluso si las líneas nuevas

están incrustadas.
\< Coincide con el principio del límite egrep
de la palabra.
\> Coincide con el final del límite egrep
de la palabra.
Tabla 64. Comentarios de shell y modificadores de modo
modificador Significado Herramienta
bandera: yo o yo Coincidencia sin distinción entre mayúsculas sed
y minúsculas para caracteres ASCII.
opción de línea de comandos: i Coincidencia que no distingue entre mayúsculas y minúsculas egrep
para caracteres ASCII.
establezca IGNORECASE en Coincidencia que no distingue entre mayúsculas

awk
distinto de cero y minúsculas para caracteres Unicode.

Tabla 65. Agrupación, captura, condicional y control de Shell
awk
(PATRÓN) Agrupamiento.
sed
$PATRÓN$ Agrupar y capturar
subcoincidencias, llenando
\1, \2,...,\9.
\norte Contiene la enésima sed

...|... Alternancia; coincidir con uno egrep, awk, sed

u otro.
Cuantificadores codiciosos
* Coincide 0 o más veces. awk, sed, egrep
+ Coincidir 1 o más veces. awk, sed, egrep
? Partido 1 o 0 veces. awk, sed, egrep
\{norte\} Coincidir exactamente n veces. sed, egrep
\{n,\} \ Coincide al menos n veces. sed, egrep
{x,y\} Coincidir al menos x veces, sed, egrep

pero no más de y veces.
egrep
egrep [opciones] archivos de patrón
egrep busca en los archivos las ocurrencias del patrón e imprime cada línea coincidente.
Ejemplo
$ echo 'Spiderman Menaces City!' > dailybugle.txt $ egrep
i 'spider[ ]?man' dailybugle.txt ¡ Spiderman
amenaza la ciudad!
sed
archivos sed '[dirección1][, dirección2]s/patrón/reemplazo/[banderas]'
archivos sed f script
De forma predeterminada, sed aplica la sustitución a cada línea de los archivos. Cada dirección puede ser
un número de línea o un patrón de expresión regular. Se debe definir una expresión regular proporcionada
dentro de los delimitadores de barra inclinada (/.../).

Si se proporciona la dirección1 , la sustitución comenzará en ese número de

línea, o en la primera línea coincidente, y continuará hasta el final del archivo o
hasta la línea indicada o coincidente con la dirección2 . Dos subsecuencias, & y
\n, se interpretarán en reemplazo según los resultados de la coincidencia.
La secuencia & se reemplaza con el texto que coincide con el patrón. La

secuencia \n corresponde a un grupo de captura (1...9) en el partido actual. Estas
son las banderas disponibles:
norte
Sustituya la enésima coincidencia en una línea, donde n está entre 1 y 512.

gramo
Sustituya todas las apariciones de patrón en una línea.

pag
Imprimir líneas con sustituciones exitosas.
w archivo
Escribe líneas con sustituciones exitosas en el archivo.
Ejemplo
Cambie los formatos de fecha de MM/DD/AAAA a DD.MM.AAAA.

$ echo 30/12/1969' |
sed's!$[09][09]$/$[09][09]$/$[09]\{2,4\}$ ! \2.\1.\3!g'
awk
awk 'instructions' files awk f
script files El script awk
contenido en instrucciones o script debe ser una serie de pares /patrón/ {acción} .
El código de acción se aplica a cada línea que coincide con el patrón. awk
también proporciona varias funciones para la coincidencia de patrones.
Funciones
coincidencia (texto, patrón)
Si el patrón coincide en el texto, devuelve la posición en el texto donde

comienza la coincidencia. Una coincidencia fallida devuelve cero. Una
coincidencia exitosa también establece la variable RSTART en la posición
donde comenzó la coincidencia y la variable RLENGTH en el número de
caracteres de la coincidencia.

gsub(patrón, reemplazo, texto)

Sustituya cada coincidencia de patrón en el texto con reemplazo y
devuelva el número de sustituciones. El valor predeterminado es $0
si no se
proporciona texto . sub(patrón, reemplazo, texto)
Sustituya la primera coincidencia del patrón en el texto con reemplazo.
Una sustitución exitosa devuelve 1 y una sustitución fallida devuelve 0.
El valor predeterminado es $0 si no se proporciona texto .
Ejemplo
Cree un archivo awk y luego ejecútelo desde la línea de comandos.
$ gato sub.awk
{
gsub(/https?:\/\/[az_.\\w\/\\#~:?+=&;%@!]*/, "<a
href=\"\&\"> \&</a>");
imprimir
}
$ echo "Consulte el sitio web, http://www.oreilly.com/ catalog/

repr" | awk f sub.awk
Otros recursos
• sed and awk, de Dale Dougherty y Arnold Robbins
(O'Reilly), es una introducción y referencia a ambas herramientas.

Índice
clases
Símbolos
Grupo, 46
[...] clase de caracteres, 6
java.util.regex
[^...] clase de caracteres, 6
Matcher, 30
Patrón, 30
A
PatternSyntaxException, 30
atajos de direcciones, editor vi, 107 Coincidencia,
anclas, 9 46 Regex,
servidor web apache, 96 43
directivas coincidentes, 102 Ruby MatchData,
motor de reescritura, 99 70 Regexp,
ASCII, 5 70 clases, .NET, 42
caracteres de control, 5
B
D
barras invertidas en expresiones
regulares Literales de Autómata finito determinista
cadena, Java (DFA), 3
(java.util.regex), 30 límite, palabra, 10
mi
C
motores, 3
C#, 38 DFA (Determinista Finito
clases de caracteres, 6 Autómata), 3
abreviaturas de caracteres, 5 NFA (No determinista Finito
interfaz CharSequence, 30 Autómata), 3
Nos gustaría escuchar sus sugerencias para mejorar nuestros índices. Envíe un correo
electrónico a index@oreilly.com.
115
F metasecuencias, 5
modificadores, modo, 10
función de búsqueda (Python), 63
norte
GRAMO
clases de caracteres negados, 6

clase grupal, 46
NFA (No determinista Finito
Autómata), 3
H
Hazel, Philip, 83
escape hexagonal, 5
O escape octal, 5
I
PAG
interfaces, 42
paréntesis, captura y agrupación,
Java (java.util.regex), 30
11 clase de
patrón, java.util.regex, 30 coincidencia
j de patrones, 3 clase
Java (java.util.regex), 26 PatternSyntaxException, java.util.regex,
java.util.regex 30 API de PCRE, 89
Clase Matcher, 30 ejemplos de
Clase Pattern, 30 bibliotecas de PCRE, 92
Clase PatternSyntaxException, función pcre_compile( ) (PCRE),
30 89 pcre_exec
JavaScript, 77 ( ) función (PCRE), 89
Coincidencia de patrones, Biblioteca de
79 Objeto RegExp, 80 expresiones regulares
Objeto String, 80 compatibles con Perl
(PCRE), 83
Perl versión 5.8, 16
L
operadores de
mirar hacia adelante,
expresiones
10 construcciones de mirar alrededor,
regulares, 21 comillas
10 mirar hacia atrás, 10
simples,
21 PHP, 50 funciones
M de coincidencia
de patrones,
Match class, 46, 70 match
54 Python, 58 Compatibilidad con Unicode, 64
function (Python), 63 Matcher class,
java.util.regex, 30 coincidencia, iterativo, 10
metacaracteres, 3, 5 Java Q
(java.util.regex), 26 Perl
cuantificadores, 3
versión 5.8, 16
116 | Índice
R tu
módulo re (Python), 61 Unicode

funciones, 62 Java (java.util.regex), 35
clase Regex, 43 compatibilidad, 13, 23, 64, 92
rubí, 66 Unicode 3.1, 47
Clase expresión regular, 70 Unicode escape, 5 usar
Objeto RegExp, JavaScript, 80 motores configuración regional, 23
de expresiones regulares, 3
descripción general de expresiones regulares, 3
V
Ruby, 66
editor vi, 103
interfaz orientada a objetos, 70
biblioteca Oniguruma, 67
Compatibilidad con Unicode, 75
Z aserciones de ancho cero, 9

S
herramientas shell,
109 ejemplos, 114
Objeto de cadena, JavaScript, 80
subpatrones, agrupación, 11
opciones de
sustitución, editor vi, 107
Índice | 117

RegExp Perl Python Java Etc

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

RegExp Perl Python Java Etc

Cargado por

Copyright:

Formatos disponibles

Machine Translated by Google

Machine Translated by Google

Pekín • Cambridge • Farnham • Colonia • París • Sebastopol • Taipéi • Tokio

Referencia de bolsillo de expresiones regulares, segunda

Los libros de O'Reilly se pueden comprar con fines educativos, comerciales o de

Montaje: Andy Oram Indexador: Johnna VanHoose Dinse

agosto de 2003: Primera edición.

Nutshell Handbook, el logotipo de Nutshell Handbook y el logotipo de O'Reilly son marcas

Sobre este libro 1

Introducción a expresiones regulares y coincidencia de patrones 3

Metacaracteres Regex, modos y construcciones 5

Libro de recetas de expresiones regulares 13

Operadores de expresiones regulares 21

con Unicode Otros recursos 25

Expresiones regulares Clases e interfaces Ejemplos 30

Clases e interfaces de expresiones regulares 42

Funciones de coincidencia de patrones 54

con objetos y funciones del módulo 61

Ejemplos sesenta y cinco

Interfaz orientada a objetos 70

Objetos y métodos de coincidencia de patrones 79

Servidor Web Apache 96

Directivas coincidentes 102

Metacaracteres compatibles 103

La coincidencia de patrones 106

Otros recursos 108

Herramientas de concha 109

Metacaracteres compatibles 109

Otros recursos 114

Bolsillo de expresión regular

Las expresiones regulares son un lenguaje utilizado para analizar y manipular

Hoy en día, las expresiones regulares se incluyen en la mayoría de los

Sobre este libro

Las convenciones usadas en este libro

En este libro se utilizan las siguientes convenciones tipográficas:

Se utiliza para opciones, valores, fragmentos de código y cualquier

Cursiva de ancho constante

Negrita de ancho constante

Se utiliza en ejemplos de comandos u otro texto que el usuario debe

Regular Expressions (O'Reilly) de Jeffrey EF Friedl es el trabajo definitivo

Nat Torkington y Linda Mui fueron excelentes editores que me guiaron a

2 | Referencia de bolsillo de expresiones regulares

Introducción a expresiones regulares y patrones

La coincidencia de patrones consiste en encontrar una sección de texto

1. Gana el partido más temprano (más a la izquierda)

Las expresiones regulares se aplican a la entrada comenzando en el

2. Los cuantificadores estándar son

Los motores de expresiones regulares tienen diferencias según su tipo.

Introducción a expresiones regulares y coincidencia de patrones | 3

Motores NFA tradicionales

Motores POSIX NFA

4 | Referencia de bolsillo de expresiones regulares

Metacaracteres, modos y construcciones de expresiones regulares

Los metacaracteres y las metasecuencias que se muestran aquí

Muchas implementaciones proporcionan atajos para representar

Escape octal: \num

Escapes hexadecimales y Unicode: \xnum, \x{num}, \unum, \Unum

Caracteres de control: \cchar

Introducción a expresiones regulares y coincidencia de patrones | 5

representaciones. Por ejemplo, \cH coincide con Control­H, un carácter de

Clases de caracteres y construcciones similares a clases

Las clases de caracteres se utilizan para especificar un conjunto de caracteres.

Clases normales: [...] y [^...]

representaciones. Por ejemplo, \cH coincide con ControlH, un carácter de

\p{CC} Caracteres de control ASCII y Latin1.