## Cheat Sheet de Expresiones Regulares (Regex) para Linux

Para una navegación sencilla, un índice de las secciones de la página:

- [Caracteres](#chars)
- [Cuantificadores](#quantifiers)
- [Más Caracteres](#morechars)
- [Lógica](#logic)
- [Espacios en Blanco](#whitespace)
- [Más Cuantificadores](#morequants)
- [Clases de Caracteres](#classes)
- [Anclajes y Límites](#anchors)
- [Clases POSIX](#posix)
- [Modificadores en Línea](#modifiers)
- [Lookaheads y Lookbehinds](#lookarounds)
- [Operaciones con Clases de Caracteres](#classoperations)
- [Otra Sintaxis](#other)


## Caracteres

| Carácter | Leyenda                                                                                                                                | Ejemplo      | Coincidencia de Ejemplo |
| -------- | -------------------------------------------------------------------------------------------------------------------------------------- | ------------ | ----------------------- |
| `\d`     | La mayoría de los motores: un dígito del 0 al 9                                                                                        | `file_\d\d`  | `file_25`               |
| `\w`     | La mayoría de los motores: "carácter de palabra": letra ASCII, dígito o guión bajo                                                     | `\w-\w\w\w`  | `A-b_1`                 |
| `\s`     | La mayoría de los motores: "carácter de espacio en blanco": espacio, tabulación, salto de línea, retorno de carro, tabulación vertical | `a\sb\sc`    | `a b c`                 |
| `\D`     | Un carácter que no es un dígito según el `\d` del motor                                                                                | `\D\D\D`     | `ABC`                   |
| `\W`     | Un carácter que no es un carácter de palabra según el `\w` del motor                                                                   | `\W\W\W\W\W` | `*-+=)`                 |
| `\S`     | Un carácter que no es un carácter de espacio en blanco según el `\s` del motor                                                         | `\S\S\S\S`   | `Yoyo`                  |


## Cuantificadores

| Cuantificador | Leyenda                | Ejemplo          | Coincidencia de Ejemplo |
| ------------- | ---------------------- | ---------------- | ----------------------- |
| `+`           | Una o más veces        | `Versión \w-\w+` | `Versión A-b1_1`        |
| `{3}`         | Exactamente tres veces | `\D{3}`          | `ABC`                   |
| `{2,4}`       | De dos a cuatro veces  | `\d{2,4}`        | `156`                   |
| `{3,}`        | Tres o más veces       | `\w{3,}`         | `tutorial_de_regex`     |
| `*`           | Cero o más veces       | `A*B*C*`         | `AAACC`                 |
| `?`           | Una vez o ninguna      | `plurales?`      | `plural`                |


## Más Caracteres

| Carácter | Leyenda                                              | Ejemplo                 | Coincidencia de Ejemplo |
| -------- | ---------------------------------------------------- | ----------------------- | ----------------------- |
| `.`      | Cualquier carácter excepto salto de línea            | `a.c`                   | `abc`                   |
| `\.`     | Un punto (carácter especial: debe escaparse con `\`) | `a\.c`                  | `a.c`                   |
| `\\`     | Escapa un carácter especial                          | `\\.*\\+\\?\\$^\\/\\\\` | `.*+?$^/\\`             |
| `[...]`  | Uno de los caracteres entre corchetes                | `[AEIOU]`               | Una vocal mayúscula     |
| `[^...]` | Uno de los caracteres que no está en los corchetes   | `[^a-z]{3}`             | `A1!`                   |


## Lógica

| Lógica    | Leyenda                   | Ejemplo                         | Coincidencia de Ejemplo  |
| --------- | ------------------------- | ------------------------------- | ------------------------ |
| `\|`      | Alternancia / Operador OR | `22\|33`                        | `33`                     |
| `( … )`   | Grupo de captura          | `A(nt\|pple)`                   | `Apple` (captura "pple") |
| `\\1`     | Contenido del Grupo 1     | `r(\\w)g\\1x`                   | `regex`                  |
| `\\2`     | Contenido del Grupo 2     | `(\\d\\d)\\+(\\d\\d)=\\2\\+\\1` | `12+65=65+12`            |
| `(?: … )` | Grupo no capturador       | `A(?:nt\|pple)`                 | `Apple`                  |


## Más Espacios en Blanco

| Carácter | Leyenda                                                                                                                                                               | Ejemplo      | Coincidencia de Ejemplo |
| -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ | ----------------------- |
| `\t`     | Tabulación                                                                                                                                                            | `T\\t\\w{2}` | `T    ab`               |
| `\r`     | Carácter de retorno de carro                                                                                                                                          | Ver abajo    |                         |
| `\n`     | Carácter de salto de línea                                                                                                                                            | Ver abajo    |                         |
| `\r\n`   | Separador de línea en Windows                                                                                                                                         | `AB\\r\\nCD` | `AB<br>CD`              |
| `\N`     | Perl, PCRE (C, PHP, R…): un carácter que no es un salto de línea                                                                                                      | `\\N+`       | `ABC`                   |
| `\h`     | Perl, PCRE (C, PHP, R…), Java: un carácter de espacio horizontal: tabulación o separador de espacio Unicode                                                           |              |                         |
| `\H`     | Un carácter que no es un espacio horizontal                                                                                                                           |              |                         |
| `\v`     | .NET, JavaScript, Python, Ruby: tabulación vertical                                                                                                                   |              |                         |
| `\v`     | Perl, PCRE (C, PHP, R…), Java: un carácter de espacio vertical: salto de línea, retorno de carro, tabulación vertical, avance de página, separador de párrafo o línea |              |                         |
| `\V`     | Perl, PCRE (C, PHP, R…), Java: cualquier carácter que no sea un espacio vertical                                                                                      |              |                         |
| `\R`     | Perl, PCRE (C, PHP, R…), Java: un salto de línea (par de retorno de carro + salto de línea, y todos los caracteres coincidentes con \v)                               |              |                         |


## Más Cuantificadores

| Cuantificador | Leyenda                                       | Ejemplo     | Coincidencia de Ejemplo |
| ------------- | --------------------------------------------- | ----------- | ----------------------- |
| `+`           | Una o más veces                               | `\\d+`      | `12345`                 |
| `?`           | Hace que los cuantificadores sean "perezosos" | `\\d+?`     | `1` en `12345`          |
| `*`           | Cero o más veces                              | `A*`        | `AAA`                   |
| `?`           | Hace que los cuantificadores sean "perezosos" | `A*?`       | Vacío en `AAA`          |
| `{2,4}`       | De dos a cuatro veces                         | `\\w{2,4}`  | `abcd`                  |
| `?`           | Hace que los cuantificadores sean "perezosos" | `\\w{2,4}?` | `ab` en `abcd`          |


## Clases de Caracteres

| Carácter | Leyenda                                                                               | Ejemplo          | Coincidencia de Ejemplo                                                          |
| -------- | ------------------------------------------------------------------------------------- | ---------------- | -------------------------------------------------------------------------------- |
| `[ … ]`  | Uno de los caracteres entre corchetes                                                 | `[AEIOU]`        | Una vocal mayúscula                                                              |
| `[ … ]`  | Uno de los caracteres entre corchetes                                                 | `T[ao]p`         | `Tap` o `Top`                                                                    |
| `-`      | Indicador de rango                                                                    | `[a-z]`          | Una letra minúscula                                                              |
| `[x-y]`  | Uno de los caracteres en el rango de x a y                                            | `[A-Z]+`         | `GREAT`                                                                          |
| `[ … ]`  | Uno de los caracteres entre corchetes                                                 | `[AB1-5w-z]`     | Uno de: A, B, 1, 2, 3, 4, 5, w, x, y, z                                          |
| `[x-y]`  | Uno de los caracteres en el rango de x a y                                            | `[ -~]+`         | Caracteres en la sección imprimible de la tabla ASCII                            |
| `[^x]`   | Un carácter que no es x                                                               | `[^a-z]{3}`      | `A1!`                                                                            |
| `[^x-y]` | Uno de los caracteres que <b>no</b> está en el rango de x a y                         | `[^ -~]+`        | Caracteres que <b>no</b> están en la sección imprimible de la tabla ASCII        |
| `[\d\D]` | Un carácter que es un dígito o no es un dígito                                        | `[\d\D]+`        | Cualquier carácter, incluyendo saltos de línea, que el punto regular no coincide |
| `[\x41]` | Coincide con el carácter en la posición hexadecimal 41 en la tabla ASCII, es decir, A | `[\x41-\x45]{3}` | `ABE`                                                                            |


## Anclajes y Límites

| Anclaje | Leyenda                                                                                                                       | Ejemplo           | Coincidencia de Ejemplo            |
| ------- | ----------------------------------------------------------------------------------------------------------------------------- | ----------------- | ---------------------------------- |
| `^`     | inicio de línea según el modo multilinea. (Pero cuando [^dentro de corchetes], significa "no")                                | `^abc .*`         | `abc` (inicio de línea)            |
| `$`     | final de línea según el modo multilinea. Muchas sutilezas dependientes del motor.                                             | `.*? el fin$`     | `este es el fin`                   |
| `\A`    | Inicio de cadena (todos los motores principales excepto JS)                                                                   | `\Aabc[\d\D]*`    | `abc` (inicio de cadena)           |
| `\z`    | Fin de cadena muy al final de la cadena. No disponible en Python y JS                                                         | `el fin\z`        | `esto es...<br>...<b>el fin</b>`   |
| `\Z`    | Final de cadena o (excepto Python) antes del salto de línea final. No disponible en JS                                        | `el fin\Z`        | `esto es...<br>...<b>el fin</b>\n` |
| `\G`    | Inicio de Cadena o Final de Coincidencia Anterior<br>.NET, Java, PCRE (C, PHP, R…), Perl, Ruby                                |                   |                                    |
| `\b`    | Límite de palabra La mayoría de los motores: posición en la que solo un lado es una letra ASCII, un dígito o un guión bajo    | `Bob.*\bcat\b`    | `Bob comió al gato`                |
| `\b`    | Límite de palabra .NET, Java, Python 3, Ruby: posición en la que solo un lado es una letra Unicode, un dígito o un guión bajo | `Bob.*\b\кошка\b` | `Bob comió al кошка`               |
| `\B`    | No es un límite de palabra                                                                                                    | `c.*\Bcat\B.*`    | `imitadores`                       |


## Clases POSIX

| Carácter    | Leyenda                                             | Ejemplo           | Coincidencia de Ejemplo |
| ----------- | --------------------------------------------------- | ----------------- | ----------------------- |
| `[:alpha:]` | PCRE (C, PHP, R…): letras ASCII A-Z y a-z           | `[8[:alpha:]]+`   | `BienHecho88`           |
| `[:alpha:]` | Ruby 2: letra Unicode o ideograma                   | `[:alpha:]\d]+`   | `кошка99`               |
| `[:alnum:]` | PCRE (C, PHP, R…): dígitos y letras ASCII A-Z y a-z | `[[:alnum:]]{10}` | `ABCDE12345`            |
| `[:alnum:]` | Ruby 2: dígito, letra o ideograma Unicode           | `[[:alnum:]]{10}` | `кошка90210`            |
| `[:punct:]` | PCRE (C, PHP, R…): signo de puntuación ASCII        | `[[:punct:]]+`    | `?!.,:;`                |
| `[:punct:]` | Ruby: signo de puntuación Unicode                   | `[[:punct:]]+`    | `‽,:〽⁆`                |


## Modificadores en Línea

Ninguno de estos es compatible con JavaScript. En Ruby, ten cuidado con (?s) y (?m).

| Modificador | Leyenda                                                                                                                                                                                                | Ejemplo                                                                                                                          | Coincidencia de Ejemplo |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------- | ----------------------- |
| `(?i)`      | Modo insensible a mayúsculas y minúsculas <br>(excepto JavaScript)                                                                                                                                     | `(?i)Lunes`                                                                                                                      | `lunES`                 |
| `(?s)`      | Modo DOTALL (excepto JS y Ruby). El punto (.) coincide con caracteres de nueva línea (\r\n). También conocido como "modo de línea única" porque el punto trata la entrada completa como una sola línea | `(?s)Desde A.*hasta Z`                                                                                                           | `Desde A<br>hasta Z`    |
| `(?m)`      | Modo multilinea (excepto Ruby y JS) ^ y $ coinciden al principio y al final de cada línea                                                                                                              | `(?m)1\r\n^2$\r\n^3$`                                                                                                            | `1<br>2<br>3`           |
| `(?m)`      | En Ruby: lo mismo que (?s) en otros motores, es decir, modo DOTALL, es decir, el punto coincide con saltos de línea                                                                                    | `(?m)Desde A.*hasta Z`                                                                                                           | `Desde A<br>hasta Z`    |
| `(?x)`      | Modo de espaciado libre (excepto JavaScript). También conocido como modo de comentario o modo de espacio en blanco                                                                                     | `(?x) # este es un<br># comentario<br>abc # escribir en varias<br># líneas<br>[ ]d # los espacios deben estar<br># en corchetes` | `abc d`                 |
| `(?n)`      | .NET, PCRE 10.30+: solo captura con nombre                                                                                                                                                             | Convierte todos los (paréntesis) en grupos de no captura. Para capturar, usa grupos con nombre.                                  |                         |
| `(?d)`      | Java: solo saltos de línea de Unix                                                                                                                                                                     | El punto y los anclajes ^ y $ solo se ven afectados por \n                                                                       |                         |
| `(?^)`      | PCRE 10.32+: desactiva modificadores                                                                                                                                                                   | Desactiva los modificadores ismnx                                                                                                |                         |


## Búsquedas Adelante y Atrás

| Búsqueda | Leyenda                    | Ejemplo             | Coincidencia de Ejemplo      |
| -------- | -------------------------- | ------------------- | ---------------------------- |
| `(?=…)`  | Búsqueda positiva adelante | `(?=\d{10})\d{5}`   | `01234` en <b>01234</b>56789 |
| `(?<=…)` | Búsqueda positiva atrás    | `(?<=\d)gato`       | `gato` en 1<b>gato</b>       |
| `(?!…)`  | Búsqueda negativa adelante | `(?!teatro)el\w+`   | `tema`                       |
| `(?<!…)` | Búsqueda negativa atrás    | `\w{3}(?<!mon)stro` | Munster                      |


## Operaciones de Clase de Caracteres

| Operación de Clase | Leyenda                                                                                                               | Ejemplo                                                                                        | Coincidencia de Ejemplo                                                         |
| ------------------ | --------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| `[…-[…]]`          | .NET: sustracción de clase de caracteres. Un carácter que está en los de la izquierda, pero no en la clase sustraída. | `[a-z-[aeiou]]`                                                                                | Cualquier consonante minúscula                                                  |
| `[…&[…]]`          | .NET: intersección de clase de caracteres. Un carácter que está en ambos lados                                        | `[A-Za-z&&[aeiou]]`                                                                            | Vocales en mayúsculas o minúsculas                                              |
| `[…]`              | .NET, PCRE (C, PHP, R…), Perl, Ruby                                                                                   | `[aeiou]`                                                                                      | Cualquier vocal minúscula                                                       |
| `(?(?=…)           | )`                                                                                                                    | .NET, PCRE (C, PHP, R…), Perl: subpatrón condicional. Si la expresión en el lado izquierdo del | coincide, intenta el subpatrón del lado derecho. De lo contrario, no hace nada. | `(?(?=4)d | D)` |  |


## Propiedades Unicode y Bloques

| Propiedad Unicode o Bloque | Leyenda                                                                    | Ejemplo                | Coincidencia de Ejemplo |
| -------------------------- | -------------------------------------------------------------------------- | ---------------------- | ----------------------- |
| `\p{Lu}`                   | .NET, Java, PCRE (C, PHP, R…), Perl, Ruby: una letra en mayúsculas Unicode | `^\p{Lu}.*$`           | `Ábaco`                 |
| `\p{IsGreek}`              | .NET, Java, PCRE (C, PHP, R…), Perl, Ruby: bloque Unicode                  | `\p{IsGreek}\p{Lu}{2}` | `ΑΒΓ`                   |


## Scripts Unicode

| Script Unicode | Leyenda                                                                                 | Ejemplo              | Coincidencia de Ejemplo |
| -------------- | --------------------------------------------------------------------------------------- | -------------------- | ----------------------- |
| `\p{Latin}`    | .NET, Java, PCRE (C, PHP, R…), Perl, Ruby: un carácter en el script Unicode             | `\p{Latin}\p{Latin}` | `abcde`                 |
| `\P{Latin}`    | .NET, Java, PCRE (C, PHP, R…), Perl, Ruby: un carácter que no está en el script Unicode | `\P{Latin}`          | `Ω本Є`                  |


## Bloques Unicode

| Bloque Unicode     | Leyenda                                                                     | Ejemplo             | Coincidencia de Ejemplo |
| ------------------ | --------------------------------------------------------------------------- | ------------------- | ----------------------- |
| `\p{InGreek}`      | .NET, Java, PCRE (C, PHP, R…), Perl, Ruby: un carácter en el bloque Unicode | `\p{InGreek}\p{Lu}` | `ΔΕΛΤΑ`                 |
| `\p{IsBasicLatin}` | .NET, Java, PCRE (C, PHP, R…), Perl, Ruby: un carácter en el bloque Unicode | `\p{IsBasicLatin}`  | `Ⅲ`                     |


## Comentarios

| Comentario | Leyenda    | Ejemplo    | Coincidencia de Ejemplo |
| ---------- | ---------- | ---------- | ----------------------- |
| `(?#…)`    | Comentario | `(?#hola)` |                         |


## Reemplazar con Referencias

| Referencia   | Leyenda                                   | Ejemplo                   | Coincidencia de Ejemplo |
| ------------ | ----------------------------------------- | ------------------------- | ----------------------- |
| `$1`, `${1}` | El contenido del primer grupo de captura  | `(\d)\s+`                 | `1` en `1   2   3`      |
| `$2`, `${2}` | El contenido del segundo grupo de captura | `(\d)\s+(\d)`             | `2` en `1   2   3`      |
| `$+`, `${+}` | El contenido del último grupo de captura  |                           |                         |
| `$&`         | La cadena coincidente completa            | `(\d)\s+`                 | `1   ` en `1   2   3`   |
| `$``         | El texto antes de la cadena coincidente   | `(\d)\s+`                 | `   ` en `1   2   3`    |
| `$'`         | El texto después de la cadena coincidente | `(\d)\s+`                 | `2   3` en `1   2   3`  |
| `$n`         | Cualquier número                          | `(\d)\s+(\d)`             | `2` en `1   2   3`      |
| `${name}`    | Cualquier nombre                          | `(?<num>\d)\s+(?<num>\d)` | `2` en `1   2   3`      |


## Grupos Condicionales

| Grupo Condicional | Leyenda | Ejemplo                                                                                                 | Coincidencia de Ejemplo |
| ----------------- | ------- | ------------------------------------------------------------------------------------------------------- | ----------------------- |
| `(?(?=…)          | )`      | Si la expresión adelante coincide, entonces coincide con el grupo vacío. De lo contrario, no hace nada. | `(?(?=1)\d              | -)` | `1`   |
| `(?(1)a           | b)`     | Si el grupo 1 coincide, coincide con "a". De lo contrario, coincide con "b".                            | `(\d)(?(1)\d            | -)` | `12-` |


## Comprobación de Cadenas

| Comprobación de Cadena | Leyenda | Ejemplo                                                             | Coincidencia de Ejemplo |
| ---------------------- | ------- | ------------------------------------------------------------------- | ----------------------- |
| `(?(1)a                | b)`     | Si 1 coincide, coincide con "a". De lo contrario, coincide con "b". | `(?(\d)\d               | -)` | `12-` |


## Modificadores en Línea

Estos solo son compatibles con Perl. Los modos x, d, s y m afectan a toda la expresión. Los modos i y U solo afectan a las partes específicas. Si se combinan, aparece la nube de puntos.

| Modificador  | Leyenda                      | Ejemplo                | Coincidencia de Ejemplo |
| ------------ | ---------------------------- | ---------------------- | ----------------------- |
| (?imsx-imsx) | Activa y desactiva los modos | (?i)hola(?-i) hola(?i) | hola hola               |


## Átomos Predefinidos

| Átomo Predefinido  | Leyenda                                                                                                                                                                           | Ejemplo                | Coincidencia de Ejemplo |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | ----------------------- |
| `.`                | Coincide con cualquier carácter excepto un salto de línea. Si se activa el modo /s, también coincide con saltos de línea                                                          | `(?s)`                 | `hola\nmundo`           |
| `\w`               | Coincide con una letra ASCII, un dígito o un guión bajo (equivale a [a-zA-Z0-9_])                                                                                                 | `\w{5}`                | `alpha`                 |
| `\W`               | Coincide con cualquier carácter que no sea una letra ASCII, un dígito o un guión bajo (equivale a [^a-zA-Z0-9_])                                                                  | `\W{5}`                | `!@#$%`                 |
| `\s`               | Coincide con un espacio en blanco (espacio, tabulación, salto de línea, retorno de carro, avance de página, espacio de línea, espacio en blanco sin separar, espacio ideográfico) | `\s\s`                 | `  `                    |
| `\S`               | Coincide con cualquier carácter que no sea un espacio en blanco                                                                                                                   | `\S\S`                 | `12`                    |
| `\d`               | Coincide con un dígito (equivale a [0-9])                                                                                                                                         | `\d{3}`                | `123`                   |
| `\D`               | Coincide con cualquier carácter que no sea un dígito                                                                                                                              | `\D{3}`                | `abc`                   |
| `\b`               | Coincide con un límite de palabra                                                                                                                                                 | `\bcat\b`              | `el gato`               |
| `\B`               | Coincide con cualquier posición que no sea un límite de palabra                                                                                                                   | `\Bcat\B`              | `imitadores`            |
| `(?i)`             | Modo insensible a mayúsculas y minúsculas                                                                                                                                         | `(?i)ABC`              | `abc`                   |
| `(?s)`             | Modo DOTALL. El punto (.) coincide con cualquier carácter, incluido un salto de línea (\n)                                                                                        | `(?s)a.b`              | `a\nb`                  |
| `(?m)`             | Modo multilinea. ^ y $ coinciden con el inicio y el final de cada línea                                                                                                           | `(?m)^abc$`            | `abc` en `abc<br>def`   |
| `(?x)`             | Modo de espaciado libre. Ignora los espacios en blanco y los comentarios                                                                                                          | `(?x) ab c`            | `abc`                   |
| `(?n)`             | Solo captura con nombre                                                                                                                                                           | `(?(?=d)d              | D)`                     | `d` |
| `(?^)`             | Desactiva los modificadores                                                                                                                                                       | `(?i)(?^i)abc`         | `abc`                   |
| `(?=…)`            | Búsqueda positiva adelante                                                                                                                                                        | `a(?=b)`               | `a` en `ab`             |
| `(?<=…)`           | Búsqueda positiva atrás                                                                                                                                                           | `(?<=a)b`              | `b` en `ab`             |
| `(?!…)`            | Búsqueda negativa adelante                                                                                                                                                        | `a(?!b)`               | `a` en `ac`             |
| `(?<!…)`           | Búsqueda negativa atrás                                                                                                                                                           | `(?<!a)b`              | `b` en `cb`             |
| `(?(?=…)           | )`                                                                                                                                                                                | Grupo condicional      | `(?(?=a)b               | c)` | `b` en `ab` |
| `(?(1)a            | b)`                                                                                                                                                                               | Grupo condicional      | `(a)(?(1)b              | c)` | `b` en `ab` |
| `(?(\d)\d          | -)`                                                                                                                                                                               | Comprobación de cadena | `(?(\d)\d               | -)` | `1`         |
| `.`                | Punto                                                                                                                                                                             | `.`                    | Cualquier carácter      |
| `\p{Lu}`           | Letra en mayúsculas Unicode                                                                                                                                                       | `\p{Lu}`               | `A`                     |
| `\p{IsGreek}`      | Bloque Unicode                                                                                                                                                                    | `\p{IsGreek}`          | `α`                     |
| `\p{Latin}`        | Carácter en el script Unicode                                                                                                                                                     | `\p{Latin}`            | `a`                     |
| `\p{InGreek}`      | Carácter en el bloque Unicode                                                                                                                                                     | `\p{InGreek}`          | `α`                     |
| `\p{IsBasicLatin}` | Carácter en el bloque Unicode                                                                                                                                                     | `\p{IsBasicLatin}`     | `a`                     |


## Caracteres Especiales

| Carácter Especiale | Descripción                                                                                                                                                                       |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `\`                | Escapa un carácter especial                                                                                                                                                       |
| `^`                | Coincide con el principio de la cadena o el inicio de una línea (modo multilinea)                                                                                                 |
| `$`                | Coincide con el final de la cadena o el final de una línea (modo multilinea)                                                                                                      |
| `.`                | Coincide con cualquier carácter excepto un salto de línea                                                                                                                         |
| `[` y `]`          | Delimita una clase de caracteres                                                                                                                                                  |
| `(` y `)`          | Delimita un grupo de captura                                                                                                                                                      |
| `?`                | Hace que el elemento anterior sea opcional. También se usa en las búsquedas adelante y atrás                                                                                      |
| `*`                | Coincide con el elemento anterior 0 o más veces                                                                                                                                   |
| `+`                | Coincide con el elemento anterior 1 o más veces                                                                                                                                   |
| `                  | `                                                                                                                                                                                 | Indica alternancia, similar a OR lógico |
| `{` y `}`          | Cuantificadores. Especifica un rango o un número exacto de repeticiones                                                                                                           |
| `\d`               | Coincide con un dígito (0-9)                                                                                                                                                      |
| `\D`               | Coincide con cualquier carácter que no sea un dígito                                                                                                                              |
| `\w`               | Coincide con una letra, un dígito o un guión bajo (caracteres de palabra)                                                                                                         |
| `\W`               | Coincide con cualquier carácter que no sea una letra, un dígito o un guión bajo                                                                                                   |
| `\s`               | Coincide con un espacio en blanco (espacio, tabulación, salto de línea, retorno de carro, avance de página, espacio de línea, espacio en blanco sin separar, espacio ideográfico) |
| `\S`               | Coincide con cualquier carácter que no sea un espacio en blanco                                                                                                                   |
| `\b`               | Coincide con un límite de palabra                                                                                                                                                 |
| `\B`               | Coincide con cualquier posición que no sea un límite de palabra                                                                                                                   |
| `\n`               | Coincide con un salto de línea (newline)                                                                                                                                          |
| `\r`               | Coincide con un retorno de carro (carriage return)                                                                                                                                |
| `\t`               | Coincide con un tabulador horizontal                                                                                                                                              |
| `\xhh`             | Coincide con un carácter ASCII hexadecimal (por ejemplo, `\x20` para espacio)                                                                                                     |
| `\uhhhh`           | Coincide con un carácter Unicode hexadecimal (por ejemplo, `\u00A9` para el símbolo de derechos de autor)                                                                         |


## Estructura de Alternancia

| Estructura de Alternancia | Leyenda | Ejemplo                                                                                                 | Coincidencia de Ejemplo |
| ------------------------- | ------- | ------------------------------------------------------------------------------------------------------- | ----------------------- |
| `(?(?=…)                  | )`      | Si la expresión adelante coincide, entonces coincide con el grupo vacío. De lo contrario, no hace nada. | `(?(?=1)\d              | -)` | `1`   |
| `(?(1)a                   | b)`     | Si el grupo 1 coincide, coincide con "a". De lo contrario, coincide con "b".                            | `(\d)(?(1)\d            | -)` | `12-` |


## Recetas de Reemplazo

| Receta de Reemplazo | Leyenda                                | Ejemplo                   | Coincidencia de Ejemplo |
| ------------------- | -------------------------------------- | ------------------------- | ----------------------- |
| `$1`                | Contenido del primer grupo de captura  | `(\d)\s+`                 | `1` en `1   2   3`      |
| `$2`                | Contenido del segundo grupo de captura | `(\d)\s+(\d)`             | `2` en `1   2   3`      |
| `$+`                | Contenido del último grupo de captura  |                           |                         |
| `$&`                | Cadena coincidente completa            | `(\d)\s+`                 | `1   ` en `1   2   3`   |
| `$``                | Texto antes de la cadena coincidente   | `(\d)\s+`                 | `   ` en `1   2   3`    |
| `$'`                | Texto después de la cadena coincidente | `(\d)\s+`                 | `2   3` en `1   2   3`  |
| `$n`                | Cualquier número                       | `(\d)\s+(\d)`             | `2` en `1   2   3`      |
| `${name}`           | Cualquier nombre                       | `(?<num>\d)\s+(?<num>\d)` | `2` en `1   2   3`      |


## Ejemplos de Búsqueda

| Ejemplo de Búsqueda       | Leyenda                                                        | Ejemplo                       | Coincidencia de Ejemplo                                              |
| ------------------------- | -------------------------------------------------------------- | ----------------------------- | -------------------------------------------------------------------- |
| `[A-Za-z]`                | Cualquier letra en mayúscula o minúscula                       | `[A-Za-z]`                    | `A` en `Apple`                                                       |
| `\d{3}`                   | Tres dígitos                                                   | `\d{3}`                       | `123` en `12345`                                                     |
| `(gato                    | perro)`                                                        | Coincide con "gato" o "perro" | `(gato                                                               | perro)` | `gato` en `gato y perro` |
| `^Inicio`                 | Coincide con "Inicio" al principio de la cadena o de una línea | `^Inicio`                     | `Inicio` en `Inicio del día`                                         |
| `Final$`                  | Coincide con "Final" al final de la cadena o de una línea      | `Final$`                      | `Final` en `El Final`                                                |
| `.*`                      | Cualquier carácter 0 o más veces                               | `.*`                          | `Hola Mundo!`                                                        |
| `\b\w+\b`                 | Cualquier palabra completa                                     | `\b\w+\b`                     | `Hola` en `Hola Mundo!`                                              |
| `(?>patrón)`              | Patron no capturado                                            | `(?>patrón)`                  | Coincidencia completa                                                |
| `(?=adelante)`            | Búsqueda positiva adelante                                     | `(?=adelante)`                | Coincide en la posición antes de "adelante"                          |
| `(?<=atrás)`              | Búsqueda positiva atrás                                        | `(?<=atrás)`                  | Coincide en la posición después de "atrás"                           |
| `(?!no adelante)`         | Búsqueda negativa adelante                                     | `(?!no adelante)`             | Coincide en cualquier posición que no esté seguida por "no adelante" |
| `(?<!no atrás)`           | Búsqueda negativa atrás                                        | `(?<!no atrás)`               | Coincide en cualquier posición que no esté precedida por "no atrás"  |
| `(?i)mayusculas`          | Coincide de manera insensible a mayúsculas y minúsculas        | `(?i)mayusculas`              | `MAYUSCULAS` o `mayusculas`                                          |
| `(?s)abc.def`             | El punto coincide con saltos de línea                          | `(?s)abc.def`                 | `abc`<br>`def` en `abc`<br>`def`                                     |
| `(?m)^Inicio`             | Coincide con "Inicio" al principio de una línea                | `(?m)^Inicio`                 | `Inicio` en `Inicio del día`                                         |
| `(?x)  hola mundo  `      | Ignora espacios en blanco y comentarios                        | `(?x)  hola mundo  `          | `holamundo`                                                          |
| `(?(?=condición)verdadero | falso)`                                                        | Grupos condicionales          | `(?(?=1)d                                                            | D)`     | `d`                      |
| `(?(1)a                   | b)`                                                            | Grupos condicionales          | `(a)(?(1)b                                                           | c)`     | `b`                      |
| `(?(\d)\d                 | -)`                                                            | Comprobación de cadena        | `(?(\d)\d                                                            | -)`     | `1`                      |
| `\p{Lu}`                  | Coincide con una letra en mayúsculas Unicode                   | `\p{Lu}`                      | `Á` en `Ábaco`                                                       |
| `\p{IsGreek}`             | Coincide con un carácter en el bloque Unicode "Greek"          | `\p{IsGreek}`                 | `α` en `αΒΓ`                                                         |
| `\p{Latin}`               | Coincide con un carácter en el script Unicode "Latin"          | `\p{Latin}`                   | `a` en `abcde`                                                       |
| `\p{InGreek}`             | Coincide con un carácter en el bloque Unicode "Greek"          | `\p{InGreek}`                 | `Δ` en `ΔΕΛΤΑ`                                                       |
| `\p{IsBasicLatin}`        | Coincide con un carácter en el bloque Unicode "Basic Latin"    | `\p{IsBasicLatin}`            | `a` en `Ⅲ`                                                           |
| `\.`                      | Coincide con un punto literal                                  | `\.`                          | `.` en `www.example.com`                                             |
| `\w{4}`                   | Cuatro caracteres de palabra                                   | `\w{4}`                       | `jump` en `jump over`                                                |
| `\W{3}`                   | Tres caracteres que no son de palabra                          | `\W{3}`                       | `@#$` en `@#$%!`                                                     |
| `\s\s`                    | Dos espacios en blanco                                         | `\s\s`                        | `  ` en `Hello  World`                                               |
| `\S\S`                    | Dos caracteres que no son espacios en blanco                   | `\S\S`                        | `He` en `Hello  World`                                               |
| `\d{2,4}`                 | Dos a cuatro dígitos                                           | `\d{2,4}`                     | `123` en `12345`                                                     |
| `a*`                      | Cero o más "a"                                                 | `a*`                          | `aaa` en `aaabbb`                                                    |
| `b+`                      | Una o más "b"                                                  | `b+`                          | `bbb` en `aaabbb`                                                    |
| `c?`                      | Cero o un "c"                                                  | `c?`                          | `c` en `abc`                                                         |
| `(a                       | b)`                                                            | "a" o "b"                     | `(a                                                                  | b)`     | `a` en `abc`             |
| `(a                       | b                                                              | c)`                           | "a", "b" o "c"                                                       | `(a     | b                        | c)` | `b` en `abc` |
| `(abc)+`                  | "abc" una o más veces                                          | `(abc)+`                      | `abcabc` en `abcabcabc`                                              |
| `[aeiou]`                 | Cualquier vocal                                                | `[aeiou]`                     | `e` en `hello`                                                       |
| `[A-Za-z]`                | Cualquier letra en mayúscula o minúscula                       | `[A-Za-z]`                    | `H` en `Hello`                                                       |
| `[^0-9]`                  | Cualquier carácter que no sea un dígito                        | `[^0-9]`                      | `H` en `H3llo`                                                       |
| `(?!no)`                  | Búsqueda negativa adelante                                     | `(?!no)`                      | `ha` en `hasta`                                                      |
| `(?<=pre)`                | Búsqueda positiva atrás                                        | `(?<=pre)`                    | `post` en `prepost`                                                  |
| `(?i)abc`                 | Coincide de manera insensible a mayúsculas y minúsculas        | `(?i)abc`                     | `ABC` o `abc`                                                        |
| `(?s)h.b`                 | El punto coincide con saltos de línea                          | `(?s)h.b`                     | `h\nb` en `h\nb`                                                     |
| `(?x)  hola  mundo  `     | Ignora espacios en blanco y comentarios                        | `(?x)  hola  mundo  `         | `holamundo`                                                          |
| `(?(\d)\d                 | -)`                                                            | Comprobación de cadena        | `(?(\d)\d                                                            | -)`     | `1`                      |
| `(?<=antes)b`             | Búsqueda positiva atrás                                        | `(?<=antes)b`                 | `b` en `antesb`                                                      |
| `\b\w+\b`                 | Palabra completa                                               | `\b\w+\b`                     | `Hola` en `¡Hola Mundo!`                                             |
| `\B!\B`                   | Posición que no es un límite de palabra                        | `\B!\B`                       | `!` en `Hola!Mundo`                                                  |
| `(?i)(?^i)abc`            | Desactiva modificadores                                        | `(?i)(?^i)abc`                | `abc` en `ABC`                                                       |
| `(?i)mayusculas`          | Coincide de manera insensible a mayúsculas y minúsculas        | `(?i)mayusculas`              | `MAYUSCULAS` o `mayusculas`                                          |
| `(?s)abc.def`             | El punto coincide con saltos de línea                          | `(?s)abc.def`                 | `abc`<br>`def` en `abc`<br>`def`                                     |
| `(?m)^Inicio`             | Coincide con "Inicio" al principio de una línea                | `(?m)^Inicio`                 | `Inicio` en `Inicio del día`                                         |
| `(?x)  hola mundo  `      | Ignora espacios en blanco y comentarios                        | `(?x)  hola mundo  `          | `holamundo`                                                          |
| `(?(?=condición)verdadero | falso)`                                                        | Grupos condicionales          | `(?(?=1)d                                                            | D)`     | `d`                      |
| `(?(1)a                   | b)`                                                            | Grupos condicionales          | `(a)(?(1)b                                                           | c)`     | `b`                      |
| `(?(\d)\d                 | -)`                                                            | Comprobación de cadena        | `(?(\d)\d                                                            | -)`     | `1`                      |
| `\p{Lu}`                  | Letra en mayúsculas Unicode                                    | `\p{Lu}`                      | `Á` en `Ábaco`                                                       |
| `\p{IsGreek}`             | Bloque Unicode                                                 | `\p{IsGreek}`                 | `α` en `αΒΓ`                                                         |
| `\p{Latin}`               | Carácter en el script Unicode "Latin"                          | `\p{Latin}`                   | `a` en `abcde`                                                       |
| `\p{InGreek}`             | Carácter en el bloque Unicode "Greek"                          | `\p{InGreek}`                 | `Δ` en `ΔΕΛΤΑ`                                                       |
| `\p{IsBasicLatin}`        | Carácter en el bloque Unicode "Basic Latin"                    | `\p{IsBasicLatin}`            | `a` en `Ⅲ`                                                           |