Double Commander utiliza la biblioteca gratuita TRegExpr, escrita por Andrey Sorokin.
La mayoría de las explicaciones provienen del archivo de ayuda de esta biblioteca.
Las expresiones regulares son una forma ampliamente utilizada de especificar patrones de búsqueda de texto. Los caracteres especiales (metacaracteres) nos permiten especificar, por ejemplo, que la cadena específica que estamos buscando aparezca al principio o al final de una línea, o contenga n apariciones de un carácter o grupo de caracteres.
Double Commander admite expresiones regulares en las siguientes funciones:
La biblioteca TRegExpr admite dos modos de operación: ANSI y Unicode. Al buscar en archivos de texto, Double Commander usa ambos (dependiendo de la codificación del archivo). En búsquedas por nombre, se utiliza Unicode.
Cualquier carácter individual coincide consigo mismo, a menos que sea un metacarácter con significado especial descrito a continuación.
Una secuencia de caracteres coincide con esa misma secuencia en la cadena objetivo, por lo tanto, el patrón bluh coincidirá con bluh en la cadena objetivo.
Podemos hacer que los metacaracteres o secuencias de escape sean interpretados literalmente anteponiéndoles una barra invertida \. Por ejemplo: el metacarácter ^ coincide con el inicio de la cadena, pero \^ coincide con el carácter ^, \\ coincide con \, etc.
A continuación algunos ejemplos:
| Ejemplos de coincidencia simple | |
|---|---|
| Expresión | Resultado |
foobar |
Coincide con la cadena foobar |
\^FooBarPtr |
Coincide con ^FooBarPtr |
Los caracteres pueden especificarse usando una sintaxis similar a las secuencias de escape usadas en C y Perl: \n coincide con un salto de línea, \t con un tabulador, etc.
Más generalmente, \xnn, donde nn es una cadena de dígitos hexadecimales, coincide con el carácter cuyo valor ASCII es nn.
Si necesita un carácter Unicode (de ancho amplio), puede usar \x{nnnn}, donde nnnn – uno o más dígitos hexadecimales.
| Secuencias de escape | |
|---|---|
| Expresión | Resultado |
\xnn |
Carácter con código ASCII nn |
\x{nnnn} |
Carácter con código ASCII nnnn (un byte para texto normal, dos bytes para Unicode) |
\t |
Tabulador (HT/TAB), igual que \x09 |
\n |
Salto de línea (NL/LF), igual que \x0a |
\r |
Retorno de carro (CR), igual que \x0d |
\f |
Salto de página (FF), igual que \x0c |
\a |
Alerta (timbre) (BEL), igual que \x07 |
\e |
Escape (ESC), igual que \x1b |
A continuación algunos ejemplos:
| Ejemplos de secuencias de escape | |
|---|---|
| Expresión | Resultado |
foo\x20bar |
Coincide con foo bar (observe el espacio en medio) |
\tfoobar |
Coincide con foobar precedido por un tabulador |
Puede especificar una clase de caracteres encerrando una lista de caracteres entre corchetes [], lo cual coincidirá con cualquiera de los caracteres en la lista.
Si el primer carácter después de [ es ^, entonces la clase coincide con cualquier carácter que no esté en la lista.
Dentro de la lista, el carácter - se usa para especificar un rango, así que a-z representa todos los caracteres desde a hasta z, inclusive.
Si desea que - forme parte de la clase, colóquelo al inicio o al final de la lista, o escápelo con una barra invertida.
Si desea incluir ], puede colocarlo al inicio de la lista o escaparlo con una barra invertida.
| Clases de caracteres | |
|---|---|
| Expresión | Resultado |
[-az] |
Coincide con a, z y - |
[az-] |
Coincide con a, z y - |
[a\-z] |
Coincide con a, z y - |
[a-z] |
Coincide con las 26 letras minúsculas desde a hasta z |
[\n-\x0D] |
Coincide con cualquier carácter \x10, \x11, \x12, \x13 |
[\d-t] |
Coincide con cualquier dígito, - o t |
[]-a] |
Coincide con cualquier carácter desde ] hasta a |
A continuación algunos ejemplos:
| Ejemplos de clases de caracteres | |
|---|---|
| Expresión | Resultado |
foob[aeiou]r |
Encuentra cadenas como foobar, foober, etc., pero no foobbr, foobcr, etc. |
foob[^aeiou]r |
Encuentra cadenas como foobbr, foobcr, etc., pero no foobar, foober, etc. |
Los metacaracteres son la esencia de las expresiones regulares, son caracteres especiales.
Existen diferentes tipos de metacaracteres, como se describe a continuación.
Algunas expresiones ayudan a detectar separadores de línea.
| Separadores de línea | |
|---|---|
| Expresión | Resultado |
^ |
Inicio de línea |
$ |
Fin de línea |
\A |
Inicio del texto |
\Z |
Fin del texto |
. |
Cualquier carácter en la línea |
A continuación algunos ejemplos:
| Ejemplos de separadores de línea | |
|---|---|
| Expresión | Resultado |
^foobar |
Solo coincide si la cadena foobar está al inicio de una línea |
foobar$ |
Solo coincide si la cadena foobar está al final de una línea |
^foobar$ |
Solo coincide si la cadena foobar es la única en la línea |
foob.r |
Coincide con cadenas como foobar, foobbr, foob1r, etc. |
Por defecto, el metacarácter ^ solo garantiza coincidir al inicio de la cadena de entrada/texto, y $ solo al final. Los separadores de línea incrustados no coinciden con ^ o $.
Sin embargo, es posible tratar la cadena como un búfer multilínea, de modo que ^ coincida después de cualquier separador de línea dentro de la cadena, y $ antes de cualquier separador de línea. Esto se logra activando el modificador m.
\A y \Z funcionan como ^ y $, pero cuando se usa el modificador m, no coinciden varias veces, mientras que ^ y $ coincidirán en cada separador de línea interno.
Por defecto, el metacarácter . coincide con cualquier carácter, pero si se desactiva el modificador s, . no coincidirá con los separadores de línea incrustados.
TRegExpr maneja los separadores de línea según el Estándar Técnico Unicode (Estándar técnico #18):
^ coincide al inicio de la cadena de entrada, y si el modificador m está activado, también después de cualquier ocurrencia de \x0D\x0A o \x0A o \x0D (compatible con Unicode: \x2028 o \x2029 o \x0B o \x0C o \x85). Tenga en cuenta que no hay línea vacía en la secuencia \x0D\x0A.
$ coincide al final de la cadena de entrada, y si el modificador m está activado, también antes de cualquier ocurrencia de \x0D\x0A o \x0A o \x0D (compatible con Unicode: \x2028 o \x2029 o \x0B o \x0C o \x85). Tenga en cuenta que no hay línea vacía en la secuencia \x0D\x0A.
. coincide con cualquier carácter, pero si el modificador s está desactivado, . no coincide con \x0D\x0A y \x0A y \x0D (compatible con Unicode: \x2028 y \x2029 y \x0B y \x0C y \x85).
Tenga en cuenta que ^.*$ (patrón de línea vacía) no coincide con una cadena vacía en la secuencia \x0D\x0A, pero sí en la secuencia \x0A\x0D.
Algunas expresiones ayudan a detectar grupos de caracteres.
| Clases predefinidas | |
|---|---|
| Expresión | Resultado |
\w |
Caracteres alfanuméricos (incluyendo _), es decir, [0-9A-Za-z_] |
\W |
Caracteres no alfanuméricos |
\d |
Caracteres numéricos |
\D |
Caracteres no numéricos |
\s |
Cualquier carácter de espacio en blanco (igual que [ \t\n\r\f]) |
\S |
Caracteres que no son espacios en blanco |
Puede usar \w, \d y \s dentro de clases de caracteres personalizadas.
A continuación algunos ejemplos:
| Ejemplos de clases predefinidas | |
|---|---|
| Expresión | Resultado |
foob\dr |
Coincide con cadenas como foob1r, foob6r, etc., pero no con foobar, foobbr, etc. |
foob[\w\s]r |
Coincide con cadenas como foobar, foob r, foobbr, etc., pero no con foob=r, etc. |
Un límite de palabra (\b) es la posición entre dos caracteres donde uno es \w y el otro es \W (en cualquier orden), considerando los caracteres imaginarios al inicio y final de la cadena como si coincidieran con \W.
| Límites de palabra | |
|---|---|
| Expresión | Resultado |
\b |
Coincide con un límite de palabra |
\B |
Coincide con un lugar que NO es un límite de palabra |
Cualquier elemento de una expresión regular puede ser seguido por otro tipo de metacaracteres – cuantificadores.
Con estos metacaracteres puedes especificar cuántas veces debe aparecer el carácter anterior, metacarácter o subexpresión.
| Cuantificadores | |
|---|---|
| Expresión | Resultado |
* |
Cero o más veces ("codicioso"), similar a {0,} |
+ |
Una o más veces ("codicioso"), similar a {1,} |
? |
Cero o una vez ("codicioso"), similar a {0,1} |
{n} |
Exactamente n veces ("codicioso") |
{n,} |
Al menos n veces ("codicioso") |
{n,m} |
Al menos n veces pero no más de m veces ("codicioso") |
*? |
Cero o más veces ("no codicioso"), similar a {0,}? |
+? |
Una o más veces ("no codicioso"), similar a {1,}? |
?? |
Cero o una vez ("no codicioso"), similar a {0,1}? |
{n}? |
Exactamente n veces ("no codicioso") |
{n,}? |
Al menos n veces ("no codicioso") |
{n,m}? |
Al menos n veces pero no más de m veces ("no codicioso") |
Así, los números entre llaves en la forma {n,m} especifican el número mínimo de veces n y el número máximo de veces m que debe coincidir el elemento.
La forma {n} equivale a {n,n} y coincide exactamente n veces.
La forma {n,} coincide n veces o más.
No hay límite para el tamaño de n o m, pero los números grandes ralentizarán la ejecución y consumirán más memoria.
Si las llaves aparecen en cualquier otro contexto, se tratan como caracteres normales.
A continuación algunos ejemplos:
| Ejemplos de cuantificadores | |
|---|---|
| Expresión | Resultado |
foob.*r |
Coincide con cadenas como foobar, foobalkjdflkj9r y foobr |
foob.+r |
Coincide con cadenas como foobar, foobalkjdflkj9r, pero no con foobr |
foob.?r |
Coincide con cadenas como foobar, foobbr y foobr, pero no con foobalkj9r |
fooba{2}r |
Coincide con la cadena foobaar |
fooba{2,}r |
Coincide con cadenas como foobaar, foobaaar, foobaaaar, etc. |
fooba{2,3}r |
Coincide con cadenas como foobaar o foobaaar, pero no con foobaaaar |
Una breve explicación sobre "codicia".
"Codicioso" toma lo máximo posible, "no codicioso" toma lo mínimo posible.
Por ejemplo, aplicando b+ y b* a la cadena abbbbc devuelve bbbb, b+? devuelve b, b*? devuelve una cadena vacía, b{2,3}? devuelve bb, b{2,3} devuelve bbb.
Puedes cambiar todos los cuantificadores al modo "no codicioso" (ver modificador g).
Puedes especificar un patrón usando una serie de alternativas separadas por |, por lo tanto fee|fie|foe coincidirá con fee, fie o foe en la cadena objetivo (lo mismo sucede con f(e|i|o)e).
La primera alternativa incluye todo desde el último separador de patrón ((, [ o el comienzo del patrón) hasta el primer |, y la última alternativa contiene todo desde el último | hasta el siguiente separador de patrón.
Por lo tanto, es común rodear las alternativas con paréntesis para minimizar la confusión sobre dónde comienzan y terminan.
Las alternativas se intentan de izquierda a derecha, por lo tanto, la primera alternativa que haga coincidir toda la expresión será seleccionada.
Esto significa que las alternativas no necesariamente son codiciosas.
Por ejemplo: al usar foo|foot para coincidir con barefoot, solo coincidirá la parte foo, porque es la primera alternativa probada y coincide exitosamente con la cadena objetivo. (Esto puede no ser importante cuando usamos paréntesis para capturar texto coincidente.)
También recuerda que | se interpreta literalmente dentro de corchetes, por lo tanto, si escribes [fee|fie|foe], realmente solo coincide con [feio|].
Ejemplos:
| Ejemplos de alternativas | |
|---|---|
| Expresión | Resultado |
foo(bar|foo) |
Coincide con la cadena foobar o foofoo |
La estructura de paréntesis ( ... ) también se puede usar para definir subexpresiones de expresiones regulares.
Después de la búsqueda, puedes invocar cualquier subexpresión, también puedes usar subexpresiones como máscaras.
Las subexpresiones se numeran según el orden de sus paréntesis izquierdos de izquierda a derecha.
La primera subexpresión se numera como 1, y se admiten hasta 90 subexpresiones (la coincidencia completa de la expresión regular se numera como 0 – puedes reemplazarla con $0 o $&).
A continuación algunos ejemplos:
| Subexpresiones | |
|---|---|
| Expresión | Resultado |
(foobar){8,10} |
Coincide con una cadena que contiene 8, 9 o 10 instancias de foobar |
foob([0-9]|a+)r |
Coincide con foob0r, foob1r, foobar, foobaar, foobaar, etc. |
Notas sobre la plantilla "Reemplazar con":
$ o \ original en la plantilla, usa el prefijo \.1\$ is $2\\rub\\ devolverá 1$ is <subexpr2>\rub\.$n, debes rodear n con llaves {}.a$12bc devolverá a<subexpr12>bc, pero a${1}2bc devolverá a<subexpr1>2bc.Ejemplo:
Invertimos la fecha 21.01.2018 a 2018.01.21:
Buscar: (\d{2})\.(\d{2})\.(\d{4})
Reemplazar con: $3.$2.$1
Los metacaracteres \1 a \9 se interpretan como referencias hacia atrás. \n coincide con la subexpresión n previamente coincidente.
A continuación algunos ejemplos:
| Ejemplos de referencias hacia atrás | |
|---|---|
| Expresión | Resultado |
(.)\1+ |
Coincide con aaaa y cc |
(.+)\1+ |
También coincide con abab y 123123 |
(['"]?)(\d+)\1 |
Coincide con "13" (entre comillas dobles), '4' (entre comillas simples) o 77 (sin comillas), etc. |
Aserción positiva lookahead: foo(?=bar) coincide con foo solo si le sigue bar, y bar no se incluye en la coincidencia.
Aserción negativa lookahead: foo(?!bar) coincide con foo solo si no le sigue bar.
Aserción positiva lookbehind: (?<=foo)bar coincide con bar solo si está precedido por foo, y foo no se incluye en la coincidencia.
Aserción negativa lookbehind: (?<!foo)bar coincide con bar solo si no está precedido por foo.
Restricciones:
Los paréntesis de lookahead deben estar al final de la expresión, y los de lookbehind deben estar al inicio. Por lo tanto, no se admiten aserciones dentro de opciones | o grupos.
Para lookbehind (?<!foo)bar, la expresión regular foo debe tener longitud fija, es decir, solo puede contener operaciones de coincidencia de longitud fija. No se permiten cuantificadores, excepto aquellos con números repetidos como {n} o {n,n} entre llaves. Se permiten clases de caracteres, el punto, \b y \B. No se permiten grupos ni selecciones.
Para los otros tres tipos de aserciones, la expresión entre paréntesis puede ser de complejidad arbitraria.
Sintaxis: (?:expr).
Este tipo de grupo no tiene "índice", por lo que no es visible para referencias posteriores. Usamos grupos sin captura cuando queremos agrupar subexpresiones pero no deseamos guardarlas como parte de la coincidencia/captura del string. El uso de grupos sin captura acelera el procesamiento de la expresión regular.
| Grupos sin captura | |
|---|---|
| Expresión | Resultado |
(https?|ftp)://([^/\r\n]+) |
Coincide con https y doublecmd.sourceforge.io en https://doublecmd.sourceforge.io |
(?:https?|ftp)://([^/\r\n]+) |
Solo coincide con doublecmd.sourceforge.io en https://doublecmd.sourceforge.io |
Sintaxis: (?>expr|expr|...).
Los grupos atómicos son un caso especial de grupos sin captura: si ya se ha encontrado una parte del patrón, este tipo de agrupación deshabilita el retroceso (backtracking) del grupo entre paréntesis. Los grupos atómicos trabajan más rápido y son útiles para optimizar grupos con muchas expresiones diferentes.
Por ejemplo, a(bc|b)c coincide con abcc y abc; a(?>bc|b)c coincide con abcc pero no con abc, porque el motor está prohibido de retroceder e intentar establecer el grupo como b.
El estándar Unicode asigna nombres a categorías de caracteres. Estos son strings de dos letras. Por ejemplo, Lu representa letras mayúsculas, Ll letras minúsculas. La categoría mayor de una sola letra L representa todas las letras.
| Categorías Unicode | |
|---|---|
| Categoría | Descripción |
L | Letras |
Lu | Letra mayúscula |
Ll | Letra minúscula |
Lt | Letra título |
Lm | Letra modificadora |
Lo | Otra letra |
M | Marcas |
Mn | Marca no espaciadora |
Mc | Marca espaciadora combinante |
Me | Marca adjunta |
N | Números |
Nd | Número decimal |
Nl | Número letra |
No | Otro número |
P | Puntuación |
Pc | Puntuación conector |
Pd | Guión |
Ps | Signo de apertura |
Pe | Signo de cierre |
Pi | Signo inicial |
Pf | Signo final |
Po | Otra puntuación |
S | Símbolos |
Sm | Símbolo matemático |
Sc | Símbolo monetario |
Sk | Símbolo modificador |
So | Otro símbolo |
Z | Separadores |
Zs | Separador de espacio |
Zl | Separador de línea |
Zp | Separador de párrafo |
C | Otros |
Cc | Control |
Cf | Formato |
Cs | Sustituto |
Co | Uso privado |
Cn | Sin asignar |
El metacarácter \p representa un carácter Unicode de la categoría especificada. Sintaxis: \pL y \p{L} para nombres de una letra, \p{Lu} para nombres de dos letras.
El metacarácter \P es inverso, representa un carácter Unicode que NO pertenece a la categoría especificada.
Estos metacaracteres también están soportados dentro de clases de caracteres.
Sintaxis de un solo modificador: (?i) para activar, (?-i) para desactivar. Se permiten varios modificadores, por ejemplo: (?msgxr-imsgxr).
Los modificadores se utilizan para cambiar el comportamiento de las expresiones regulares. Solo afectan a la parte de la expresión regular que sigue al operador (?imsgxr-imsgxr).
Cualquiera de estos modificadores se puede incrustar directamente en la expresión regular. Si un modificador se aplica a una subexpresión, solo afectará a esa subexpresión.
^ y $ para que coincidan con el inicio o final de cualquier línea dentro de la cadena, no solo con el inicio o final de la cadena completa. Consulte también separadores de línea. Está desactivado por defecto.. coincida con cualquier carácter, incluso con separadores de línea (consulte también separadores de línea), cosa que normalmente no haría. Está activado por defecto.g está desactivado, + funciona como +?, * como *?, etc.а-я incluye además la letra rusa ё, А-Я incluye además Ё, y а-Я incluye todas las letras rusas. Está activado por defecto.texto se ignora. Tenga en cuenta que TRegExpr cierra el comentario cuando encuentra ), por lo que no se puede incluir un ) literal dentro del comentario.A continuación algunos ejemplos:
| Ejemplos de extensiones Perl | |
|---|---|
| Expresión | Resultado |
(?i)Saint-Petersburg |
Coincide con Saint-petersburg y Saint-Petersburg |
(?i)Saint-(?-i)Petersburg |
Coincide con Saint-Petersburg pero no con Saint-petersburg |
(?i)(Saint-)?Petersburg |
Coincide con Saint-petersburg y saint-petersburg |
((?i)Saint-)?Petersburg |
Coincide con saint-Petersburg pero no con saint-petersburg |
El modificador x requiere una explicación adicional.
Indica que se deben ignorar los espacios que no estén precedidos por una barra invertida ni dentro de una clase de caracteres.
Puede utilizarlo para dividir la expresión regular en partes (algo) más legibles.
El carácter # también se considera un metacarácter que introduce comentarios, por ejemplo:
(
(abc) # Comentario 1
| # Puede usar espacios para dar formato a la expresión regular - TRegExpr los ignorará
(efg) # Comentario 2
)
Esto también implica que si desea usar espacios reales o el carácter # en el patrón (fuera de una clase de caracteres, ya que estos no se ven afectados por x), debe escaparlos o codificarlos mediante secuencias de escape octal o hexadecimal.
En general, estas características mejoran considerablemente la legibilidad del texto de la expresión regular.
