QRegExp Class

Descripción detallada

Esta clase está obsoleta en Qt 6. Por favor, utilice QRegularExpression en su lugar para todo el código nuevo. Para directrices sobre la portabilidad de código antiguo de QRegExp a QRegularExpression, véase {Porting to QRegularExpression}

Una expresión regular, o "regexp", es un patrón para emparejar subcadenas en un texto. Resulta útil en muchos contextos, por ejemplo,

Se presenta una breve introducción a las expresiones regulares, una descripción del lenguaje de expresiones regulares de Qt, algunos ejemplos y la propia documentación de la función. QRegExp sigue el modelo del lenguaje regexp de Perl. Es totalmente compatible con Unicode. QRegExp también se puede utilizar en un modo comodín más sencillo, similar a la funcionalidad de los intérpretes de comandos. Las reglas sintácticas utilizadas por QRegExp pueden modificarse con setPatternSyntax(). En concreto, la sintaxis del patrón se puede establecer en QRegExp::FixedString, lo que significa que el patrón que se va a comparar se interpreta como una cadena sin formato, es decir, no se escapan los caracteres especiales (por ejemplo, la barra invertida).

Un buen texto sobre regexps es Mastering Regular Expressions (Third Edition) de Jeffrey E. F. Friedl, ISBN 0-596-52812-4.

Introducción

Las expresiones regulares se construyen a partir de expresiones, cuantificadores y aserciones. La expresión más simple es un carácter, por ejemplo x o 5. Una expresión también puede ser un conjunto de caracteres encerrados entre corchetes. [ ABCD] coincidirá con una A, una B, una C o una D. Podemos escribir esta misma expresión como [A-D], y una expresión que coincida con cualquier letra mayúscula del alfabeto inglés se escribe como [A-Z].

Un cuantificador especifica el número de apariciones de una expresión que debe coincidir. x{1,1} significa que coincide con una y sólo una x. x{1,5} significa que coincide con una secuencia de x caracteres que contiene al menos una x pero no más de cinco.

Tenga en cuenta que, en general, las expresiones regulares no se pueden utilizar para comprobar paréntesis equilibrados o etiquetas. Por ejemplo, se puede escribir una regexp para que coincida con un html de apertura <b> y su cierre </b>, si las etiquetas <b> no están anidadas, pero si las etiquetas <b> están anidadas, esa misma regexp coincidirá con una etiqueta de apertura <b> con el cierre incorrecto </b>. Para el fragmento <b>bold <b>bolder</b></b>, el primer <b> coincidiría con el primer </b>, lo que no es correcto. Sin embargo, es posible escribir una regexp que empareje correctamente paréntesis o etiquetas anidados, pero sólo si el número de niveles de anidamiento es fijo y conocido. Si el número de niveles de anidamiento no es fijo y conocido, es imposible escribir una regexp que no falle.

Supongamos que queremos que una regexp coincida con números enteros en el rango de 0 a 99. Se requiere al menos un dígito, así que empezamos con la expresión [0-9]{1,1}, que coincide con un solo dígito exactamente una vez. Esta expresión regular coincide con números enteros del 0 al 9. Para que coincida con números enteros de hasta 99, aumente el número máximo de ocurrencias a 2, de modo que la regexp se convierta en [0-9]{1,2}. Esta regexp satisface el requisito original de coincidir con los números enteros de 0 a 99, pero también coincidirá con los números enteros que aparecen en medio de las cadenas. Si queremos que el entero coincidente sea toda la cadena, debemos utilizar las aserciones de anclaje, ^ (signo de intercalación) y $ (dólar). Cuando ^ es el primer carácter de una regexp, significa que la regexp debe coincidir desde el principio de la cadena. Cuando $ es el último carácter de la expresión regular, significa que debe coincidir hasta el final de la cadena. La expresión regular se convierte en ^ [0-9]{1,2}$. Tenga en cuenta que las aserciones, por ejemplo ^ y $, no coinciden con caracteres sino con ubicaciones en la cadena.

Si ha visto expresiones regulares descritas en otros sitios, es posible que tengan un aspecto distinto de las que se muestran aquí. Esto se debe a que algunos conjuntos de caracteres y algunos cuantificadores son tan comunes que se les han asignado símbolos especiales para representarlos. [ 0-9] puede sustituirse por el símbolo \d. El cuantificador para que coincida exactamente con una ocurrencia, {1,1}, puede sustituirse por la propia expresión, es decir, x{1,1} es lo mismo que x. Por lo tanto, nuestro comparador de 0 a 99 podría escribirse como ^ \d{1 ,2}$. También se puede escribir ^ \d\d {0 ,1}$, es decir, desde el principio de la cadena, coincide con un dígito, seguido inmediatamente por 0 o 1 dígitos. En la práctica, se escribiría como ^ \d\d?$. ? es la abreviatura del cuantificador {0,1}, es decir, 0 ó 1 ocurrencias. ? hace que una expresión sea opcional. El regexp ^ \d\d?$ significa Desde el principio de la cadena, coincide con un dígito, seguido inmediatamente por 0 o 1 dígito más, seguido inmediatamente por el final de la cadena.

Para escribir una expresión regular que coincida con una de las palabras "correo" o "carta" o "correspondencia", pero que no coincida con palabras que contengan estas palabras, por ejemplo, "correo electrónico", "cartero", "cartero" y "buzón", comience con una expresión regular que coincida con "correo". Expresada de forma completa, la regexp es m{1,1}a{1,1}i{1,1}l{1,1}, pero como una expresión de caracteres se cuantifica automáticamente por {1,1}, podemos simplificar la regexp a mail, es decir, una 'm' seguida de una 'a' seguida de una 'i' seguida de una 'l'. Ahora podemos utilizar la barra vertical |, que significa o, para incluir las otras dos palabras, por lo que nuestra regexp para coincidir con cualquiera de las tres palabras se convierte en mail|carta|correspondencia. Coincide con 'correo' o 'carta' o 'correspondencia'. Aunque esta expresión regular coincidirá con una de las tres palabras que queremos que coincidan, también coincidirá con palabras que no queremos que coincidan, por ejemplo, "correo electrónico". Para evitar que la expresión regular coincida con palabras no deseadas, debemos indicarle que empiece y termine la coincidencia en los límites de las palabras. Primero encerramos la expresión regular entre paréntesis, (correo|carta|correspondencia). Los paréntesis agrupan expresiones e identifican una parte de la expresión regular que deseamos capture. Al encerrar la expresión entre paréntesis, podemos utilizarla como componente en expresiones regulares más complejas. También nos permite examinar cuál de las tres palabras ha coincidido realmente. Para forzar que la coincidencia empiece y termine en los límites de las palabras, encerramos la expresión regular en \b aserciones de límite de palabra: \b(correo|carta|correspondencia)\b. Ahora la expresión regular significa: Coincidir con un límite de palabra, seguido de la expresión regular entre paréntesis, seguida de un límite de palabra. La aserción \b coincide con una posición de la expresión regular, no con un carácter. Un límite de palabra es cualquier carácter que no sea una palabra, por ejemplo, un espacio, una nueva línea o el principio o el final de una cadena.

Si queremos sustituir los caracteres ampersand por la entidad HTML &, la expresión regular a utilizar es simplemente &. Pero esta expresión regular también coincidirá con los ampersands que ya se hayan convertido en entidades HTML. Sólo queremos sustituir los ampersands que no vayan seguidos de amp;. Para ello, necesitamos la aserción lookahead negativa, (?!__). La expresión regular puede escribirse como &(?!amp;), es decir, coincide con un ampersand que no vaya seguido de amp;.

Si queremos contar todas las apariciones de 'Eric' y 'Eirik' en una cadena, dos soluciones válidas son \b(Eric|Eirik)\b y \bEi?ri[ck]\b. La aserción de límite de palabra '\b' es necesaria para evitar coincidencias con palabras que contengan cualquiera de los dos nombres, por ejemplo, 'Ericsson'. Observe que la segunda expresión regular coincide con más grafías de las que deseamos: "Eric", "Erik", "Eiric" y "Eirik".

Algunos de los ejemplos anteriores se explican en la sección code examples.

Caracteres y abreviaturas de conjuntos de caracteres

Nota: El compilador de C++ transforma las barras invertidas en cadenas. Para incluir una \ en una regexp, introdúzcala dos veces, es decir, \\. Para que coincida con el propio carácter de barra invertida, introdúzcalo cuatro veces, es decir, \\\\.

Conjuntos de caracteres

Los corchetes significan que coinciden con cualquier carácter contenido en los corchetes. Las abreviaturas de conjuntos de caracteres descritas anteriormente pueden aparecer en un conjunto de caracteres entre corchetes. Salvo las abreviaturas del juego de caracteres y las dos excepciones siguientes, los caracteres no tienen significados especiales entre corchetes.

El uso de las abreviaturas predefinidas del juego de caracteres es más portable que el uso de rangos de caracteres entre plataformas e idiomas. Por ejemplo, [0-9 ] coincide con un dígito en alfabetos occidentales, pero \d coincide con un dígito de cualquier alfabeto.

Nota: En otra documentación sobre expresiones regulares, los conjuntos de caracteres suelen denominarse "clases de caracteres".

Cuantificadores

Por defecto, una expresión se cuantifica automáticamente con {1,1}, es decir, debe aparecer exactamente una vez. En la siguiente lista, E significa expresión. Una expresión es un carácter, o la abreviatura de un conjunto de caracteres, o un conjunto de caracteres entre corchetes, o una expresión entre paréntesis.

Para aplicar un cuantificador a más de un carácter precedente, utilice paréntesis para agrupar caracteres en una expresión. Por ejemplo, tag+ coincide con una "t" seguida de una "a" seguida de al menos una "g", mientras que (tag)+ coincide con al menos una aparición de "tag".

Nota: Los cuantificadores suelen ser "codiciosos". Siempre coinciden con todo el texto que pueden. Por ejemplo, 0+ coincide con el primer cero que encuentra y con todos los ceros consecutivos después del primer cero. Aplicado a "20005", coincide con "20005". Los cuantificadores pueden hacerse no codiciosos, véase setMinimal().

Captura de texto

Los paréntesis nos permiten agrupar elementos para poder cuantificarlos y capturarlos. Por ejemplo, si tenemos la expresión mail|carta|correspondencia que coincide con una cadena, sabemos que una de las palabras coincide, pero no cuál. El uso de paréntesis nos permite "capturar" todo lo que coincida dentro de sus límites, de modo que si utilizamos (mail|carta|correspondencia) y comparamos esta regexp con la cadena "Te envié un correo electrónico" podemos utilizar las funciones cap() o capturedTexts() para extraer los caracteres coincidentes, en este caso 'mail'.

Podemos utilizar el texto capturado dentro de la propia regexp. Para hacer referencia al texto capturado utilizamos backreferences que se indexan a partir de 1, igual que para cap(). Por ejemplo, podríamos buscar palabras duplicadas en una cadena utilizando \b( \w+ )\W + \1\b , lo que significa que coincide con un límite de palabra seguido de uno o más caracteres de palabra seguidos de uno o más caracteres que no son de palabra seguidos del mismo texto que la primera expresión entre paréntesis seguida de un límite de palabra.

Si queremos utilizar los paréntesis únicamente para agrupar y no para capturar, podemos utilizar la sintaxis de no captura, por ejemplo (?:verde|azul). Los paréntesis de no captura empiezan con '(?:' y terminan con ')'. En este ejemplo coincidimos con 'verde' o 'azul', pero no capturamos la coincidencia, por lo que sólo sabemos si hemos coincidido o no, pero no qué color hemos encontrado. El uso de paréntesis no capturadores es más eficiente que el uso de paréntesis capturadores, ya que el motor regexp tiene que hacer menos contabilidad.

Tanto los paréntesis de captura como los de no captura pueden estar anidados.

Por razones históricas, los cuantificadores (por ejemplo, *) que se aplican a los paréntesis de captura son más "codiciosos" que otros cuantificadores. Por ejemplo, a*(a*) coincidirá con "aaa" con cap(1) == "aaa". Este comportamiento es diferente del de otros motores de expresiones regulares (en particular, Perl). Para obtener un comportamiento de captura más intuitivo, especifique QRegExp::RegExp2 al constructor de QRegExp o llame a setPatternSyntax(QRegExp::RegExp2).

Cuando el número de coincidencias no puede determinarse de antemano, un lenguaje común es utilizar cap() en un bucle. Por ejemplo:

QRegExp rx("(\\d+)");
QString str = "Offsets: 12 14 99 231 7";
QStringList list;
int pos = 0;

while ((pos = rx.indexIn(str, pos)) != -1) {
    list << rx.cap(1);
    pos += rx.matchedLength();
}
// list: ["12", "14", "99", "231", "7"]

Afirmaciones

Las aserciones hacen alguna declaración sobre el texto en el punto en el que aparecen en la regexp, pero no coinciden con ningún carácter. En la siguiente lista , E significa cualquier expresión.

Coincidencia de comodines

La mayoría de los shells de comandos, como bash o cmd.exe, admiten "file globbing", es decir, la posibilidad de identificar un grupo de archivos mediante comodines. La función setPatternSyntax() se utiliza para cambiar entre el modo regexp y el modo comodín. Las coincidencias con comodines son mucho más sencillas que las regexps completas y sólo tienen cuatro funciones:

En el modo Wildcard, los caracteres comodín no pueden escaparse. En el modo WildcardUnix, el carácter '\' escapa del comodín.

Por ejemplo, si estamos en modo comodín y tenemos cadenas que contienen nombres de archivos, podríamos identificar los archivos HTML con *.html. Esto coincidirá con cero o más caracteres seguidos de un punto seguido de 'h', 't', 'm' y 'l'.

Para contrastar una cadena con una expresión comodín, utilice exactMatch(). Por ejemplo:

QRegExp rx("*.txt");
rx.setPatternSyntax(QRegExp::Wildcard);
rx.exactMatch("README.txt");        // returns true
rx.exactMatch("welcome.txt.bak");   // returns false

Notas para usuarios de Perl

La mayoría de las abreviaturas de clases de caracteres admitidas por Perl son compatibles con QRegExp, véase characters and abbreviations for sets of characters.

En QRegExp, aparte de dentro de las clases de caracteres, ^ siempre significa el inicio de la cadena, por lo que las carets siempre deben ser escapadas a menos que se usen para ese propósito. En Perl, el significado de un signo de intercalación varía automáticamente dependiendo de dónde aparezca, por lo que rara vez es necesario escaparlo. Lo mismo ocurre con $, que en QRegExp siempre significa el final de la cadena.

Los cuantificadores de QRegExp son los mismos que los cuantificadores codiciosos de Perl (pero consulte note above). La concordancia no codiciosa no puede aplicarse a cuantificadores individuales, pero puede aplicarse a todos los cuantificadores del patrón. Por ejemplo, para que coincida con el regexp de Perl ro+?m requiere:

QRegExp rx("ro+m");
rx.setMinimal(true);

El equivalente de la opción /i de Perl es setCaseSensitivity(Qt::CaseInsensitive).

La opción /g de Perl puede emularse mediante loop.

En QRegExp . coincide con cualquier caracter, por lo tanto todas las regexps QRegExp tienen el equivalente de la opción /s de Perl. QRegExp no tiene un equivalente a la opción /m de Perl, pero ésta puede emularse de varias maneras, por ejemplo dividiendo la entrada en líneas o haciendo un bucle con una regexp que busque nuevas líneas.

Dado que QRegExp está orientado a cadenas, no existen las aserciones \A, \Z o \z. La aserción \G no está soportada pero puede emularse en un bucle.

$& de Perl es cap(0) o capturedTexts()[0]. No hay equivalentes QRegExp para $`, $' o $+. Las variables de captura de Perl, $1, $2, ... corresponden a cap(1) o capturedTexts()[1], cap(2) o capturedTexts()[2], etc.

Para sustituir un patrón utilice QString::replace().

La sintaxis extendida /x de Perl no está soportada, como tampoco lo están las directivas, por ejemplo (?i), ni los comentarios regexp, por ejemplo (?#comment). Por otro lado, las reglas de C++ para cadenas literales pueden utilizarse para conseguir lo mismo:

QRegExp mark("\\b"      // word boundary
              "[Mm]ark" // the word we want to match
            );

Las aserciones lookbehind positivas de ancho cero y negativas de ancho cero (?=patrón) y (?!patrón) están soportadas con la misma sintaxis que Perl. Las aserciones lookbehind de Perl, las subexpresiones "independientes" y las expresiones condicionales no están soportadas.

Los paréntesis no capturadores también están soportados, con la misma sintaxis (?:pattern).

Consulte QString::split() y QStringList::join() para ver los equivalentes a las funciones split y join de Perl.

Nota: debido a que C++ transforma los \ deben escribirse dos veces en el código, por ejemplo \b debe escribirse \\b.

Ejemplos de código

QRegExp rx("^\\d\\d?$");    // match integers 0 to 99
rx.indexIn("123");          // returns -1 (no match)
rx.indexIn("-6");           // returns -1 (no match)
rx.indexIn("6");            // returns 0 (matched at position 0)

La tercera cadena coincide con'6'. Se trata de una simple regexp de validación para enteros en el rango de 0 a 99.

QRegExp rx("^\\S+$");       // match strings without whitespace
rx.indexIn("Hello world");  // returns -1 (no match)
rx.indexIn("This_is-OK");   // returns 0 (matched at position 0)

La segunda cadena coincide con'This_is-OK'. Hemos utilizado la abreviatura del conjunto de caracteres '\S' (sin espacios en blanco) y las anclas para que coincidan con cadenas que no contienen espacios en blanco.

En el siguiente ejemplo, buscamos cadenas que contengan "mail" o "letter" o "correspondence", pero sólo palabras completas, es decir, no "email".

QRegExp rx("\\b(mail|letter|correspondence)\\b");
rx.indexIn("I sent you an email");     // returns -1 (no match)
rx.indexIn("Please write the letter"); // returns 17

La segunda cadena coincide con "Por favor, escriba la carta". La palabra 'carta' también se captura (debido a los paréntesis). Podemos ver el texto que hemos capturado así:

QString captured = rx.cap(1); // captured == "letter"

Esto capturará el texto del primer conjunto de paréntesis de captura (contando los paréntesis de captura de izquierda a derecha). Los paréntesis se cuentan desde 1 ya que cap(0) es toda la expresión regular coincidente (equivalente a '&' en la mayoría de los motores de expresiones regulares).

QRegExp rx("&(?!amp;)");      // match ampersands but not &
QString line1 = "This & that";
line1.replace(rx, "&");
// line1 == "This & that"
QString line2 = "His & hers & theirs";
line2.replace(rx, "&");
// line2 == "His & hers & theirs"

Aquí hemos pasado la QRegExp a la función replace() de QString para sustituir el texto coincidente por el nuevo texto.

QString str = "One Eric another Eirik, and an Ericsson. "
              "How many Eiriks, Eric?";
QRegExp rx("\\b(Eric|Eirik)\\b"); // match Eric or Eirik
int pos = 0;    // where we are in the string
int count = 0;  // how many Eric and Eirik's we've counted
while (pos >= 0) {
    pos = rx.indexIn(str, pos);
    if (pos >= 0) {
        ++pos;      // move along in str
        ++count;    // count our Eric or Eirik
    }
}

Hemos utilizado la función indexIn() para hacer coincidir repetidamente la regexp en la cadena. Observe que en lugar de avanzar carácter a carácter pos++ podríamos haber escrito pos += rx.matchedLength() para saltarnos la cadena ya coincidente. La cuenta será igual a 3, coincidiendo con 'Un Eric otro Eirik, y un Ericsson. ¿Cuántos Eiriks, Eric?'; no coincide con 'Ericsson' o 'Eiriks' porque no están delimitados por límites no-palabra.

Un uso habitual de las expresiones regulares es dividir líneas de datos delimitadas en los campos que las componen.

str = "The Qt Company Ltd\tqt.io\tFinland";
QString company, web, country;
rx.setPattern("^([^\t]+)\t([^\t]+)\t([^\t]+)$");
if (rx.indexIn(str) != -1) {
    company = rx.cap(1);
    web = rx.cap(2);
    country = rx.cap(3);
}

En este ejemplo, nuestras líneas de entrada tienen el formato nombre de la empresa, dirección web y país. Por desgracia, la expresión regular es bastante larga y poco versátil: el código se romperá si añadimos más campos. Una solución más sencilla y mejor es buscar el separador, '\t' en este caso, y tomar el texto que lo rodea. La función QString::split() puede tomar una cadena separadora o regexp como argumento y dividir una cadena en consecuencia.

QStringList field = str.split("\t");

Aquí campo[0] es la empresa, campo[1] la dirección web y así sucesivamente.

Para imitar la coincidencia de un intérprete de comandos podemos utilizar el modo comodín.

QRegExp rx("*.html");
rx.setPatternSyntax(QRegExp::Wildcard);
rx.exactMatch("index.html");                // returns true
rx.exactMatch("default.htm");               // returns false
rx.exactMatch("readme.txt");                // returns false

Las coincidencias con comodines pueden ser convenientes por su simplicidad, pero cualquier regexp con comodín puede definirse utilizando regexps completos, por ejemplo .*\.html$. Observe que no podemos hacer coincidir los archivos .html y .htm con un comodín a menos que utilicemos *.htm*, que también coincidirá con 'prueba.html.bak'. Una regexp completa nos da la precisión que necesitamos, .*\.html?$.

QRegExp puede hacer coincidir mayúsculas y minúsculas utilizando setCaseSensitivity(), y puede utilizar coincidencias no ávidas, véase setMinimal(). Por defecto, QRegExp utiliza expresiones regulares completas, pero esto puede cambiarse con setPatternSyntax(). La búsqueda puede realizarse hacia delante con indexIn() o hacia atrás con lastIndexIn(). Se puede acceder al texto capturado con capturedTexts(), que devuelve una lista de todas las cadenas capturadas, o con cap(), que devuelve la cadena capturada para el índice dado. La función pos() toma un índice de coincidencia y devuelve la posición en la cadena donde se hizo la coincidencia (o -1 si no hubo coincidencia).

Migración a QRegularExpression

La clase QRegularExpression introducida en Qt 5 implementa expresiones regulares compatibles con Perl y es una gran mejora sobre QRegExp en términos de APIs ofrecidas, sintaxis de patrones soportada y velocidad de ejecución. La mayor diferencia es que QRegularExpression simplemente contiene una expresión regular, y no se modifica cuando se solicita una coincidencia. En su lugar, se devuelve un objeto QRegularExpressionMatch, para comprobar el resultado de una coincidencia y extraer la subcadena capturada. Lo mismo se aplica a las coincidencias globales y a QRegularExpressionMatchIterator.

A continuación se indican otras diferencias.

Sintaxis de patrones diferente

Portar una expresión regular de QRegExp a QRegularExpression puede requerir cambios en el propio patrón.

En determinados casos, QRegExp era demasiado indulgente y aceptaba patrones que simplemente no eran válidos cuando se utilizaba QRegularExpression. Esto es fácil de detectar, porque los objetos QRegularExpression construidos con estos patrones no son válidos (véase QRegularExpression::isValid()).

En otros casos, un patrón portado de QRegExp a QRegularExpression puede cambiar silenciosamente de semántica. Por lo tanto, es necesario revisar los patrones utilizados. Los casos más notables de incompatibilidad silenciosa son:

• Se necesitan llaves para utilizar un escape hexadecimal como \xHHHH con más de 2 dígitos. Un patrón como \x2022 necesita ser portado a \x{2022}, o coincidirá con un espacio (0x20) seguido de la cadena "22". En general, se recomienda encarecidamente utilizar siempre llaves con el escape \x, independientemente del número de dígitos especificados.
• Una cuantificación de 0 a n como {,n} debe pasarse a {0,n} para conservar la semántica. De lo contrario, un patrón como \d{,3} coincidiría con un dígito seguido de la cadena exacta "{,3}".
• QRegExp realiza por defecto la correspondencia con Unicode, mientras que QRegularExpression requiere una opción aparte; para más detalles, véase más abajo.
• c{.} en QRegExp coincide por defecto con todos los caracteres, incluido el carácter de nueva línea. QRegularExpression excluye el carácter de nueva línea por defecto. Para incluir el carácter de nueva línea, active la opción de patrón QRegularExpression::DotMatchesEverythingOption.

Para obtener una visión general de la sintaxis de expresiones regulares que admite QRegularExpression, consulte la página de manual pcrepattern(3), en la que se describe la sintaxis de patrones que admite PCRE (la implementación de referencia de expresiones regulares compatibles con Perl).

Adaptación de QRegExp::exactMatch()

QRegExp::exactMatch() servía para dos propósitos: emparejaba exactamente una expresión regular con una cadena de asunto, e implementaba emparejamientos parciales.

Adaptación de la concordancia exacta de QRegExp

La coincidencia exacta indica si la expresión regular coincide con toda la cadena de asunto. Por ejemplo, las clases coinciden con la cadena de asunto "abc123":

La coincidencia exacta no se refleja en QRegularExpression. Si quiere estar seguro de que la cadena de asunto coincide exactamente con la expresión regular, puede envolver el patrón utilizando la función QRegularExpression::anchoredPattern():

QString p("a .*|pattern");

// re matches exactly the pattern string p
QRegularExpression re(QRegularExpression::anchoredPattern(p));

Adaptación de la concordancia parcial de QRegExp

Cuando se utilizaba QRegExp::exactMatch(), si no se encontraba una coincidencia exacta, se podía averiguar qué parte de la cadena de asunto coincidía con la expresión regular llamando a QRegExp::matchedLength(). Si la longitud devuelta era igual a la longitud de la cadena de asunto, se podía concluir que se había encontrado una coincidencia parcial.

QRegularExpression soporta explícitamente las coincidencias parciales mediante el apropiado QRegularExpression::MatchType.

Coincidencia global

Debido a las limitaciones de la API QRegExp, ha sido imposible implementar correctamente la concordancia global (es decir, como lo hace Perl). En particular, los patrones que pueden coincidir con 0 caracteres (como "a*") son problemáticos.

QRegularExpression::globalMatch() implementa la concordancia global de Perl correctamente, y el iterador devuelto puede utilizarse para examinar cada resultado.

Por ejemplo, si tiene código como

QString subject("the quick fox");

int offset = 0;
QRegExp re("(\\w+)");
while ((offset = re.indexIn(subject, offset)) != -1) {
    offset += re.matchedLength();
    // ...
}

Puedes reescribirlo como:

QString subject("the quick fox");

QRegularExpression re("(\\w+)");
QRegularExpressionMatchIterator i = re.globalMatch(subject);
while (i.hasNext()) {
    QRegularExpressionMatch match = i.next();
    // ...
}

Soporte de propiedades Unicode

Cuando se utiliza QRegExp, las clases de caracteres como \w, \d, etc. coinciden con caracteres con la propiedad Unicode correspondiente: por ejemplo, \d coincide con cualquier carácter con la propiedad Unicode Nd (dígito decimal).

Estas clases de caracteres sólo coinciden por defecto con caracteres ASCII cuando se utiliza QRegularExpression: por ejemplo, \d coincide exactamente con un carácter del rango ASCII 0-9. Es posible cambiar este comportamiento utilizando la opción de patrón QRegularExpression::UseUnicodePropertiesOption.

Coincidencia con comodines

En QRegularExpression no existe una forma directa de hacer coincidencias con comodines. Sin embargo, se proporciona el método QRegularExpression::wildcardToRegularExpression() para traducir patrones glob a una expresión regular compatible con Perl que puede utilizarse con ese fin.

Por ejemplo, si tiene código como

QRegExp wildcard("*.txt");
wildcard.setPatternSyntax(QRegExp::Wildcard);

Puede reescribirlo como:

auto wildcard = QRegularExpression(QRegularExpression::wildcardToRegularExpression("*.txt"));

Tenga en cuenta, sin embargo, que algunos patrones de comodines tipo shell podrían no traducirse a lo que usted espera. El siguiente código de ejemplo se romperá silenciosamente si simplemente se convierte utilizando la función antes mencionada:

const QString fp1("C:/Users/dummy/files/content.txt");
const QString fp2("/home/dummy/files/content.txt");

QRegExp re1("*/files/*");
re1.setPatternSyntax(QRegExp::Wildcard);
re1.exactMatch(fp1); // returns true
re1.exactMatch(fp2); // returns true

// but converted with QRegularExpression::wildcardToRegularExpression()

QRegularExpression re2(QRegularExpression::wildcardToRegularExpression("*/files/*"));
re2.match(fp1).hasMatch(); // returns false
re2.match(fp2).hasMatch(); // returns false

Esto se debe a que, por defecto, la expresión regular devuelta por QRegularExpression::wildcardToRegularExpression() está totalmente anclada. Para obtener una expresión regular que no esté anclada, pase QRegularExpression::UnanchoredWildcardConversion como opciones de conversión:

QRegularExpression re3(QRegularExpression::wildcardToRegularExpression(
                           "*/files/*", QRegularExpression::UnanchoredWildcardConversion));
re3.match(fp1).hasMatch(); // returns true
re3.match(fp2).hasMatch(); // returns true

Coincidencia mínima

QRegExp::setMinimal() implementa la concordancia mínima simplemente invirtiendo la codicia de los cuantificadores (QRegExp no soporta cuantificadores perezosos, como *?, +?, etc.). QRegularExpression en cambio sí soporta cuantificadores codiciosos, perezosos y posesivos. La opción de patrón QRegularExpression::InvertedGreedinessOption puede ser útil para emular los efectos de QRegExp::setMinimal(): si está activada, invierte la codicia de los cuantificadores (los codiciosos se convierten en perezosos y viceversa).

Modos de intercalación

La opción de coincidencia QRegularExpression::AnchorAtOffsetMatchOption puede utilizarse para emular el comportamiento de QRegExp::CaretAtOffset. No hay equivalente para los otros modos de QRegExp::CaretMode.