Modified ECMAScript regular expression grammar

Esta página describe la gramática de expresiones regulares que se utiliza cuando std::basic_regex se construye con syntax_option_type establecido en ECMAScript (el valor predeterminado). Consulte syntax_option_type para conocer las otras gramáticas de expresiones regulares admitidas.

La gramática de expresiones regulares ECMAScript 3 en C++ es la gramática ECMA-262 con modificaciones marcadas con (solo C++) a continuación.

Resumen

La gramática de expresiones regulares modificada es principalmente la gramática ECMAScript RegExp con una expansión de tipo POSIX en configuraciones regionales bajo ClassAtom . Se realizan algunas aclaraciones sobre verificaciones de igualdad y análisis numérico. Para muchos de los ejemplos aquí, puede probar este equivalente en la consola de su navegador:

function match(s, re) { return s.match(new RegExp(re)); }

Las "referencias normativas" en el estándar especifican ECMAScript 3. Enlazamos a la especificación ECMAScript 5.1 aquí porque es una versión con solo cambios menores respecto a ECMAScript 3, y también tiene una versión HTML. Consulte la Guía de MDN sobre JavaScript RegExp para obtener una descripción general de las características del dialecto.

Alternativas

Un patrón de expresión regular es una secuencia de una o más Alternativas , separadas por el operador de disyunción | (en otras palabras, el operador de disyunción tiene la precedencia más baja).

Pattern ::

Disyunción

Disyunción ::

Alternativa

Alternativa | Disyunción

El patrón primero intenta omitir la Disjunction y coincidir con la Alternative izquierda seguida por el resto de la expresión regular (después de la Disjunction).

Si falla, intenta omitir la Alternative izquierda y coincidir con la Disjunction derecha (seguida del resto de la expresión regular).

Si la Alternativa izquierda, la Disyunción derecha y el resto de la expresión regular tienen puntos de elección, todas las opciones en el resto de la expresión se prueban antes de pasar a la siguiente opción en la Alternativa izquierda. Si se agotan las opciones en la Alternativa izquierda, se prueba la Disyunción derecha en lugar de la Alternativa izquierda.

Cualquier paréntesis de captura dentro de una Alternativa omitida produce subcoincidencias vacías.

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
void show_matches(const std::string& in, const std::string& re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if (!m.empty())
    {
        std::cout << "input=[" << in << "], regex=[" << re << "]\n  "
                     "prefix=[" << m.prefix() << "]\n  smatch: ";
        for (std::size_t n = 0; n < m.size(); ++n)
            std::cout << "m[" << n << "]=[" << m[n] << "] ";
        std::cout << "\n  suffix=[" << m.suffix() << "]\n";
    }
    else
        std::cout << "input=[" << in << "], regex=[" << re << "]: NO MATCH\n";
}
int main()
{
    show_matches("abcdef", "abc|def");
    show_matches("abc", "ab|abc"); // la Alternativa izquierda coincide primero
    // La coincidencia de la entrada contra la Alternativa izquierda (a) seguida
    // por el resto de la expresión regular (c|bc) tiene éxito, lo que resulta
    // en m[1]="a" y m[4]="bc".
    // Las Alternativas omitidas (ab) y (c) dejan sus subcoincidencias
    // m[3] y m[5] vacías.
    show_matches("abc", "((a)|(ab))((c)|(bc))");
}

input=[abcdef], regex=[abc|def]
  prefix=[]
  smatch: m[0]=[abc]
  suffix=[def]
input=[abc], regex=[ab|abc]
  prefix=[]
  smatch: m[0]=[ab]
  suffix=[c]
input=[abc], regex=[((a)|(ab))((c)|(bc))]
  prefix=[]
  smatch: m[0]=[abc] m[1]=[a] m[2]=[a] m[3]=[] m[4]=[bc] m[5]=[] m[6]=[bc]
  suffix=[]

Términos

Cada Alternative está vacío o es una secuencia de Term s (sin separadores entre los Term s)

Alternativa ::

[vacío]

Término Alternativo

Vacío Alternativa siempre coincide y no consume ninguna entrada.

Los Términos consecutivos intentan coincidir simultáneamente con porciones consecutivas de la entrada.

Si la Alternativa izquierda, el Término derecho y el resto de la expresión regular tienen puntos de elección, todas las opciones en el resto de la expresión se prueban antes de pasar a la siguiente opción en el Término derecho, y todas las opciones en el Término derecho se prueban antes de pasar a la siguiente opción en la Alternativa izquierda.

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
void show_matches(const std::string& in, const std::string& re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if (!m.empty())
    {
        std::cout << "input=[" << in << "], regex=[" << re << "]\n  "
                     "prefix=[" << m.prefix() << "]\n  smatch: ";
        for (std::size_t n = 0; n < m.size(); ++n)
            std::cout << "m[" << n << "]=[" << m[n] << "] ";
        std::cout << "\n  suffix=[" << m.suffix() << "]\n";
    }
    else
        std::cout << "input=[" << in << "], regex=[" << re << "]: NO MATCH\n";
}
int main()
{
    show_matches("abcdef", ""); // expresión regular vacía es una única Alternativa vacía
    show_matches("abc", "abc|"); // la Alternativa izquierda coincide primero
    show_matches("abc", "|abc"); // la Alternativa izquierda coincide primero, dejando abc sin coincidir
}

input=[abcdef], regex=[]
  prefix=[]
  smatch: m[0]=[]
  suffix=[abcdef]
input=[abc], regex=[abc|]
  prefix=[]
  smatch: m[0]=[abc]
  suffix=[]
input=[abc], regex=[|abc]
  prefix=[]
  smatch: m[0]=[]
  suffix=[abc]

Cuantificadores

• Cada Término es ya sea una Aserción (ver abajo), o un Átomo (ver abajo), o un Átomo seguido inmediatamente por un Cuantificador

Término ::

Aserción

Átomo

Átomo Cuantificador

Cada Quantifier es un greedy quantifier (que consiste únicamente en un QuantifierPrefix ) o un non-greedy quantifier (que consiste en un QuantifierPrefix seguido del signo de interrogación ? ).

Cuantificador ::

PrefijoCuantificador

PrefijoCuantificador ?

Cada QuantifierPrefix determina dos números: el número mínimo de repeticiones y el número máximo de repeticiones, de la siguiente manera:

Los valores de los DecimalDigits individuales se obtienen llamando a std::regex_traits::value (solo C++) en cada uno de los dígitos.

Un Atom seguido de un Quantifier se repite el número de veces especificado por el Quantifier . Un Quantifier puede ser non-greedy , en cuyo caso el patrón Atom se repite la menor cantidad de veces posible mientras aún coincida con el resto de la expresión regular, o puede ser greedy , en cuyo caso el patrón Atom se repite tantas veces como sea posible mientras aún coincida con el resto de la expresión regular.

El patrón Atom es lo que se repite, no la entrada que coincide, por lo que diferentes repeticiones del Atom pueden coincidir con diferentes subcadenas de entrada.

Si el Atom y el resto de la expresión regular tienen puntos de elección, el Atom se empareja primero tantas (o tan pocas, si es non-greedy ) veces como sea posible. Todas las opciones en el resto de la expresión regular se prueban antes de pasar a la siguiente opción en la última repetición del Atom . Todas las opciones en la última (enésima) repetición del Atom se prueban antes de pasar a la siguiente opción en la penúltima (n-1) repetición del Atom ; en ese punto puede resultar que ahora sean posibles más o menos repeticiones del Atom ; estas se agotan (nuevamente, comenzando con tantas o tan pocas como sea posible) antes de pasar a la siguiente opción en la (n-1) repetición del Atom y así sucesivamente.

Las capturas del Atom' s se borran cada vez que se repite (consulte el ejemplo "(z)((a+)?(b+)?(c))*" a continuación)

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
void show_matches(const std::string& in, const std::string& re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if (!m.empty())
    {
        std::cout << "input=[" << in << "], regex=[" << re << "]\n  "
                     "prefix=[" << m.prefix() << "]\n  smatch: ";
        for (std::size_t n = 0; n < m.size(); ++n)
            std::cout << "m[" << n << "]=[" << m[n] << "] ";
        std::cout << "\n  suffix=[" << m.suffix() << "]\n";
    }
    else
        std::cout << "input=[" << in << "], regex=[" << re << "]: NO MATCH\n";
}
int main()
{
    // coincidencia greedy, repite [a-z] 4 veces
    show_matches("abcdefghi", "a[a-z]{2,4}");
    // coincidencia non-greedy, repite [a-z] 2 veces
    show_matches("abcdefghi", "a[a-z]{2,4}?");
    // El orden de puntos de elección para cuantificadores resulta en una coincidencia
    // con dos repeticiones, primero coincidiendo con la subcadena "aa",
    // segundo coincidiendo con la subcadena "ba", dejando "ac" sin coincidir
    // ("ba" aparece en la cláusula de captura m[1])
    show_matches("aabaac", "(aa|aabaac|ba|b|c)*");
    // El orden de puntos de elección para cuantificadores hace que esta expresión regular
    // calcule el máximo común divisor entre 10 y 15
    // (la respuesta es 5, y llena m[1] con "aaaaa")
    show_matches("aaaaaaaaaa,aaaaaaaaaaaaaaa", "^(a+)\\1*,\\1+$");
    // la subcadena "bbb" no aparece en la cláusula de captura m[4]
    // porque se borra cuando la segunda repetición del átomo
    // (a+)?(b+)?(c) coincide con la subcadena "ac"
    // NOTA: gcc comete un error aquí - no borra correctamente el
    // grupo de captura matches[4] como requiere ECMA-262 21.2.2.5.1,
    // y por lo tanto captura incorrectamente "bbb" para ese grupo.
    show_matches("zaacbbbcac", "(z)((a+)?(b+)?(c))*");
}

input=[abcdefghi], regex=[a[a-z]{2,4}]
  prefix=[]
  smatch: m[0]=[abcde]
  suffix=[fghi]
input=[abcdefghi], regex=[a[a-z]{2,4}?]
  prefix=[]
  smatch: m[0]=[abc]
  suffix=[defghi]
input=[aabaac], regex=[(aa|aabaac|ba|b|c)*]
  prefix=[]
  smatch: m[0]=[aaba] m[1]=[ba]
  suffix=[ac]
input=[aaaaaaaaaa,aaaaaaaaaaaaaaa], regex=[^(a+)\1*,\1+$]
  prefix=[]
  smatch: m[0]=[aaaaaaaaaa,aaaaaaaaaaaaaaa] m[1]=[aaaaa]
  suffix=[]
input=[zaacbbbcac], regex=[(z)((a+)?(b+)?(c))*]
  prefix=[]
  smatch: m[0]=[zaacbbbcac] m[1]=[z] m[2]=[ac] m[3]=[a] m[4]=[] m[5]=[c] 
  suffix=[]

Aserciones

Assertion s coinciden con condiciones, en lugar de subcadenas de la cadena de entrada. Nunca consumen ningún carácter de la entrada. Cada Assertion es una de las siguientes

Assertion ::

^

$

\ b

\ B

( ? = Disyunción )

( ? ! Disyunción )

La aserción ^ (inicio de línea) coincide

La aserción $ (fin de línea) coincide

En las dos afirmaciones anteriores y en el Átomo . a continuación, LineTerminator es uno de los siguientes cuatro caracteres: U+000A ( \n o salto de línea), U+000D ( \r o retorno de carro), U+2028 (separador de línea), o U+2029 (separador de párrafo)

La aserción \b (límite de palabra) coincide

La aserción \B (límite de palabra negativo) coincide con todo EXCEPTO lo siguiente

La aserción ( ? = Disjunction ) (búsqueda anticipada positiva de ancho cero) coincide si Disjunction coincidiría con la entrada en la posición actual

La aserción ( ? ! Disjunction ) (búsqueda anticipada negativa de ancho cero) coincide si Disjunction NO coincidiría con la entrada en la posición actual.

Para ambas aserciones de anticipación, al coincidir la Disyunción , la posición no avanza antes de coincidir con el resto de la expresión regular. Además, si la Disyunción puede coincidir en la posición actual de varias maneras, solo se prueba la primera.

ECMAScript prohíbe el retroceso hacia las Disyunciones de anticipación, lo cual afecta el comportamiento de las referencias inversas hacia una anticipación positiva desde el resto de la expresión regular (ver ejemplo abajo). Las referencias inversas hacia la anticipación negativa desde el resto de la expresión regular siempre están indefinidas (ya que la Disyunción de anticipación debe fallar para proceder).

Nota: Las aserciones de búsqueda anticipada pueden utilizarse para crear un AND lógico entre múltiples expresiones regulares (ver ejemplo a continuación).

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
void show_matches(const std::string& in, const std::string& re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if (!m.empty())
    {
        std::cout << "input=[" << in << "], regex=[" << re << "]\n  "
                     "prefix=[" << m.prefix() << "]\n  smatch: ";
        for (std::size_t n = 0; n < m.size(); ++n)
            std::cout << "m[" << n << "]=[" << m[n] << "] ";
        std::cout << "\n  suffix=[" << m.suffix() << "]\n";
    }
    else
        std::cout << "input=[" << in << "], regex=[" << re << "]: NO MATCH\n";
}
int main()
{
    // coincide con la a al final de la entrada
    show_matches("aaa", "a$");
    // coincide con la o al final de la primera palabra
    show_matches("moo goo gai pan", "o\\b");
    // la búsqueda anticipada coincide con la cadena vacía inmediatamente después de la primera b
    // esto llena m[1] con "aaa" aunque m[0] está vacío
    show_matches("baaabac", "(?=(a+))");
    // debido a que se prohíbe el retroceso en búsquedas anticipadas,
    // esto coincide con aba en lugar de aaaba
    show_matches("baaabac", "(?=(a+))a*b\\1");
    // AND lógico mediante búsqueda anticipada: esta contraseña coincide SI contiene
    // al menos una letra minúscula
    // Y al menos una letra mayúscula
    // Y al menos un carácter de puntuación
    // Y tener al menos 6 caracteres de longitud
    show_matches("abcdef", "(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}");
    show_matches("aB,def", "(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}");
}

input=[aaa], regex=[a$]
  prefix=[aa]
  smatch: m[0]=[a] 
  suffix=[]
input=[moo goo gai pan], regex=[o\b]
  prefix=[mo]
  smatch: m[0]=[o] 
  suffix=[ goo gai pan]
input=[baaabac], regex=[(?=(a+))]
  prefix=[b]
  smatch: m[0]=[] m[1]=[aaa] 
  suffix=[aaabac]
input=[baaabac], regex=[(?=(a+))a*b\1]
  prefix=[baa]
  smatch: m[0]=[aba] m[1]=[a] 
  suffix=[c]
input=[abcdef], regex=[(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}]: NO MATCH
input=[aB,def], regex=[(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}]
  prefix=[]
  smatch: m[0]=[aB,def] 
  suffix=[]

Átomos

Un Atom puede ser uno de los siguientes:

Atom ::

PatternCharacter

.

\ AtomEscape

CharacterClass

( Disjunction )

( ? : Disjunction )

donde AtomEscape ::

EscapeDecimal

EscapeCarácter

EscapeClaseCarácter

Diferentes tipos de átomos se evalúan de manera diferente.

Sub-expresiones

El Atom ( Disjunction ) es una subexpresión marcada: ejecuta la Disjunction y almacena la copia de la subcadena de entrada que fue consumida por la Disjunction en el array de subcoincidencias en el índice que corresponde al número de veces que el paréntesis abierto izquierdo ( de subexpresiones marcadas ha sido encontrado en la expresión regular completa en este punto.

Además de ser devueltos en std::match_results , las subcoincidencias capturadas son accesibles como referencias inversas ( \1 , \2 , ...) y pueden ser referenciadas en expresiones regulares. Nótese que std::regex_replace utiliza $ en lugar de \ para referencias inversas ( $1 , $2 , ...) de la misma manera que String.prototype.replace (ECMA-262, parte 15.5.4.11).

El Atom ( ? : Disjunction ) (subexpresión no capturadora) simplemente evalúa la Disjunction y no almacena sus resultados en la subcoincidencia. Esta es una agrupación puramente léxica.

Retroreferencias

DecimalEscape ::

DecimalIntegerLiteral [ lookahead ∉ DecimalDigit ]

Si \ es seguido por un número decimal N cuyo primer dígito no es 0 , entonces la secuencia de escape se considera una retroreferencia . El valor N se obtiene llamando a std::regex_traits::value (solo C++) en cada uno de los dígitos y combinando sus resultados usando aritmética en base 10. Es un error si N es mayor que el número total de paréntesis de captura izquierdos en toda la expresión regular.

Cuando una retroreferencia \N aparece como un Átomo , coincide con la misma subcadena que está actualmente almacenada en el N-ésimo elemento del arreglo de subcoincidencias.

El escape decimal \0 NO es una retroreferencia: es un escape de carácter que representa el NUL carácter. No puede ir seguido de un dígito decimal.

Como se mencionó anteriormente, tenga en cuenta que std::regex_replace utiliza $ en lugar de \ para las referencias inversas ( $1 , $2 , ...).

Coincidencias de caracteres individuales

El Atom . coincide y consume cualquier carácter de la cadena de entrada excepto LineTerminator ( U+000D , U+000A , U+2029 , o U+2028 )

El Atom PatternCharacter , donde PatternCharacter es cualquier SourceCharacter EXCEPTO los caracteres ^ $ \ . * + ? ( ) [ ] { } | , coincide y consume un carácter de la entrada si es igual a este PatternCharacter .

La igualdad para este y todos los demás caracteres individuales se define de la siguiente manera:

Cada Atom que consiste en el carácter de escape \ seguido por CharacterEscape así como el DecimalEscape especial \0 , coincide y consume un carácter de la entrada si es igual al carácter representado por el CharacterEscape . Se reconocen las siguientes secuencias de escape de caracteres:

CharacterEscape ::

ControlEscape

c ControlLetter

HexEscapeSequence

UnicodeEscapeSequence

IdentityEscape

Aquí, ControlEscape es uno de los siguientes cinco caracteres: f n r t v

ControlLetter es cualquier letra ASCII minúscula o mayúscula y esta secuencia de escape coincide con el carácter cuya unidad de código es igual al resto de dividir el valor de la unidad de código de ControlLetter por 32 . Por ejemplo, \cD y \cd coinciden ambos con la unidad de código U+0004 (EOT) porque 'D' es U+0044 y 0x44 % 32 == 4 , y 'd' es U+0064 y 0x64 % 32 == 4 .

HexEscapeSequence es la letra x seguida exactamente por dos HexDigit s (donde HexDigit es uno de 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F ). Esta secuencia de escape de caracteres coincide con el carácter cuya unidad de código es igual al valor numérico del número hexadecimal de dos dígitos.

UnicodeEscapeSequence es la letra u seguida de exactamente cuatro HexDigit s. Esta secuencia de escape de caracteres coincide con el carácter cuya unidad de código es igual al valor numérico de este número hexadecimal de cuatro dígitos. Si el valor no cabe en el std::basic_regex 's CharT , std::regex_error es lanzada (solo C++) .

IdentityEscape puede ser cualquier carácter no alfanumérico: por ejemplo, otra barra invertida. Coincide con el carácter tal cual.

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
void show_matches(const std::wstring& in, const std::wstring& re)
{
    std::wsmatch m;
    std::regex_search(in, m, std::wregex(re));
    if (!m.empty())
    {
        std::wcout << L"input=[" << in << L"], regex=[" << re << L"]\n  "
                      L"prefix=[" << m.prefix() << L"]\n  wsmatch: ";
        for (std::size_t n = 0; n < m.size(); ++n)
            std::wcout << L"m[" << n << L"]=[" << m[n] << L"] ";
        std::wcout << L"\n  suffix=[" << m.suffix() << L"]\n";
    }
    else
        std::wcout << L"input=[" << in << "], regex=[" << re << L"]: NO MATCH\n";
}
int main()
{
    // La mayoría de los escapes son similares a C++, excepto por los metacaracteres. Tendrás que
    // escapar doblemente o usar cadenas sin formato en las barras invertidas.
    show_matches(L"C++\\", LR"(C\+\+\\)");
    // Secuencias de escape y NUL.
    std::wstring s(L"ab\xff\0cd", 5);
    show_matches(s, L"(\\0|\\u00ff)");
    // No está definida la coincidencia para Unicode no-BMP, porque ECMAScript usa
    // átomos UTF-16. Si este emoji de banana coincide puede depender de la plataforma:
    // ¡Estas necesitan ser cadenas anchas!
    show_matches(L"\U0001f34c", L"[\\u0000-\\ufffe]+");
}

input=[C++\], regex=[C\+\+\\]
  prefix=[]
  wsmatch: m[0]=[C++\]
  suffix=[]
input=[ab?c], regex=[(\0{{!}}\u00ff)]
  prefix=[ab]
  wsmatch: m[0]=[?] m[1]=[?]
  suffix=[c]
input=[?], regex=[[\u0000-\ufffe]+]: NO MATCH

Clases de caracteres

Un Atom puede representar una clase de caracteres, es decir, coincidirá y consumirá un carácter si pertenece a uno de los grupos predefinidos de caracteres.

Una clase de caracteres puede introducirse mediante un escape de clase de caracteres:

Atom ::

\ Escape de Clase de Carácter

o directamente

Atom ::

ClaseDeCaracter

Los escapes de clase de caracteres son abreviaturas para algunas de las clases de caracteres comunes, de la siguiente manera:

Una CharacterClass es una secuencia entre corchetes de ClassRanges , que opcionalmente comienza con el operador de negación ^ . Si comienza con ^ , este Atom coincide con cualquier carácter que NO esté en el conjunto de caracteres representado por la unión de todos los ClassRanges . De lo contrario, este Atom coincide con cualquier carácter que SÍ esté en el conjunto de los caracteres representado por la unión de todos los ClassRanges .

CharacterClass ::

[ [ lookahead ∉ { ^ }] ClassRanges ]

[ ^ ClassRanges ]

ClassRanges ::

[vacío]

NonemptyClassRanges

NonemptyClassRanges ::

ClassAtom

ClassAtom NonemptyClassRangesNoDash

ClassAtom - ClassAtom ClassRanges

Si un rango de clase no vacío tiene la forma ClassAtom - ClassAtom , coincide con cualquier carácter de un rango definido como sigue: (solo C++)

El primer ClassAtom debe coincidir con un único elemento de intercalación c1 y el segundo ClassAtom debe coincidir con un único elemento de intercalación c2 . Para probar si el carácter de entrada c coincide con este rango, se siguen los siguientes pasos:

El carácter - se trata literalmente si está

• el primer o último carácter de ClassRanges
• el ClassAtom inicial o final de una especificación de rango separada por guiones
• sigue inmediatamente a una especificación de rango separada por guiones.
• escapado con una barra invertida como CharacterEscape

NonemptyClassRangesNoDash ::

ClassAtom

ClassAtomNoDash NonemptyClassRangesNoDash

ClassAtomNoDash - ClassAtom ClassRanges

ClassAtom ::

-

ClassAtomNoDash

ClassAtomExClass (solo C++)

ClassAtomCollatingElement (solo C++)

ClassAtomEquivalence (solo C++)

ClassAtomNoDash ::

SourceCharacter pero no uno de \ o ] o -

\ ClassEscape

Cada ClassAtomNoDash representa un solo carácter -- ya sea SourceCharacter tal cual o escapado de la siguiente manera:

ClassEscape ::

EscapeDecimal

b

EscapeCarácter

EscapeClaseCarácter

El especial ClassEscape \b produce un conjunto de caracteres que coincide con la unidad de código U+0008 (retroceso). Fuera de CharacterClass , es la Assertion de límite de palabra.

El uso de \B y el uso de cualquier retroreferencia ( DecimalEscape distinto de cero) dentro de una CharacterClass es un error.

Los caracteres - y ] pueden necesitar ser escapados en algunas situaciones para ser tratados como átomos. Otros caracteres que tienen significado especial fuera de CharacterClass , como * o ? , no necesitan ser escapados.

Clases de caracteres basadas en POSIX

Estas clases de caracteres son una extensión a la gramática de ECMAScript, y son equivalentes a las clases de caracteres encontradas en las expresiones regulares POSIX.

ClassAtomExClass (Solo C++) ::

[: ClassName :]

Representa todos los caracteres que son miembros de la clase de caracteres nombrada ClassName . El nombre es válido únicamente si std::regex_traits::lookup_classname devuelve un valor distinto de cero para este nombre. Como se describe en std::regex_traits::lookup_classname , se garantiza el reconocimiento de los siguientes nombres: alnum, alpha, blank, cntrl, digit, graph, lower, print, punct, space, upper, xdigit, d, s, w . Los locales proporcionados por el sistema pueden ofrecer nombres adicionales (como jdigit o jkanji en japonés) o pueden implementarse como una extensión definida por el usuario.

ClassAtomCollatingElement (Solo C++) ::

[. ClassName .]

Representa el elemento de intercalación con nombre, que puede representar un solo carácter o una secuencia de caracteres que se intercala como una unidad única bajo la configuración regional establecida, como [.tilde.] o [.ch.] en checo. El nombre es válido solo si std::regex_traits::lookup_collatename no es una cadena vacía.

Al usar std::regex_constants::collate , los elementos de intercalación siempre pueden usarse como puntos finales de un rango (por ejemplo, [[.dz.]-g] en húngaro).

ClassAtomEquivalence (Solo C++) ::

[= ClassName =]

Representa todos los caracteres que son miembros de la misma clase de equivalencia que el elemento de intercalación nombrado, es decir, todos los caracteres cuya clave de intercalación primaria es la misma que la del elemento de intercalación ClassName . El nombre es válido solo si std::regex_traits::lookup_collatename para ese nombre no es una cadena vacía y si el valor devuelto por std::regex_traits::transform_primary para el resultado de la llamada a std::regex_traits::lookup_collatename no es una cadena vacía.

Una clave de ordenación primaria es aquella que ignora mayúsculas/minúsculas, acentuación o adaptaciones específicas de la localización; por ejemplo [[=a=]] coincide con cualquiera de los caracteres: a, À, Á, Â, Ã, Ä, Å, A, à, á, â, ã, ä and å.

ClassName (Solo C++) ::

CarácterNombreClase

CarácterNombreClase NombreClase

ClassNameCharacter (C++ only) ::

SourceCharacter pero no uno de . = :