En esta página

QRegExp Class

La clase QRegExp permite realizar búsquedas de coincidencias mediante expresiones regulares. Más información...

Encabezado: #include <QRegExp>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core5Compat)
target_link_libraries(mytarget PRIVATE Qt6::Core5Compat)
qmake: QT += core5compat

Nota: Todas las funciones de esta clase son reentrantes.

Tipos públicos

enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch }
enum PatternSyntax { RegExp, RegExp2, Wildcard, WildcardUnix, FixedString, W3CXmlSchema11 }

Funciones públicas

QRegExp()
QRegExp(const QString &pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive, QRegExp::PatternSyntax syntax = RegExp)
QRegExp(const QRegExp &rx)
~QRegExp()
QString cap(int nth = 0) const
int captureCount() const
QStringList capturedTexts() const
Qt::CaseSensitivity caseSensitivity() const
int countIn(const QString &str) const
QString errorString() const
bool exactMatch(const QString &str) const
QStringList filterList(const QStringList &stringList) const
int indexIn(const QStringList &list, int from) const
int indexIn(const QString &str, int offset = 0, QRegExp::CaretMode caretMode = CaretAtZero) const
bool isEmpty() const
bool isMinimal() const
bool isValid() const
int lastIndexIn(const QStringList &list, int from) const
int lastIndexIn(const QString &str, int offset = -1, QRegExp::CaretMode caretMode = CaretAtZero) const
int matchedLength() const
QString pattern() const
QRegExp::PatternSyntax patternSyntax() const
int pos(int nth = 0) const
QString removeIn(const QString &str) const
QString replaceIn(const QString &str, const QString &after) const
QStringList replaceIn(const QStringList &stringList, const QString &after) const
void setCaseSensitivity(Qt::CaseSensitivity cs)
void setMinimal(bool minimal)
void setPattern(const QString &pattern)
void setPatternSyntax(QRegExp::PatternSyntax syntax)
QStringList splitString(const QString &str, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const
void swap(QRegExp &other)
operator QVariant() const
bool operator!=(const QRegExp &rx) const
QRegExp &operator=(QRegExp &&other)
QRegExp &operator=(const QRegExp &rx)
bool operator==(const QRegExp &rx) const

Miembros públicos estáticos

QString escape(const QString &str)
size_t qHash(const QRegExp &key, size_t seed = 0)
QDataStream &operator<<(QDataStream &out, const QRegExp &regExp)
QDataStream &operator>>(QDataStream &in, QRegExp &regExp)

Descripción detallada

Esta clase ha quedado obsoleta en Qt 6. Utiliza en su lugar QRegularExpression para todo el código nuevo. Para obtener directrices sobre cómo portar código antiguo de QRegExp a QRegularExpression, consulta Porting to QRegularExpression.

Una expresión regular, o «regexp», es un patrón para buscar subcadenas en un texto. Resulta útil en muchos contextos, por ejemplo:

ValidaciónUna expresión regular puede comprobar si una subcadena cumple determinados criterios, por ejemplo, si es un número entero o si no contiene espacios en blanco.
BúsquedaUna expresión regular ofrece una coincidencia de patrones más potente que la simple coincidencia de subcadenas; por ejemplo, puede encontrar una de las palabras «mail», «letter» o «correspondence», pero ninguna de las palabras «email», «mailman», «mailer», «letterbox», etc.
Búsqueda y sustituciónUna expresión regular puede sustituir todas las apariciones de una subcadena por otra subcadena diferente; por ejemplo, sustituir todas las apariciones de «&» por «&amp;», excepto cuando el símbolo «&» ya vaya seguido de un «amp;».
División de cadenasUna expresión regular puede utilizarse para identificar dónde debe dividirse una cadena, por ejemplo, al dividir cadenas delimitadas por tabulaciones.

Se ofrece 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 se basa en el lenguaje de expresiones regulares de Perl. Es totalmente compatible con Unicode. QRegExp también puede utilizarse en un modo más sencillo, con comodines, similar a la funcionalidad que se encuentra en los shells de comandos. Las reglas sintácticas utilizadas por QRegExp pueden modificarse con ` setPatternSyntax()` (). En concreto, la sintaxis del patrón puede configurarse como ` QRegExp::FixedString`, lo que significa que el patrón que se va a buscar se interpreta como una cadena simple, es decir, los caracteres especiales (por ejemplo, la barra invertida) no se escapan.

Un buen libro sobre expresiones regulares es *Mastering Regular Expressions* (3.ª edición), de Jeffrey E. F. Friedl, ISBN 0-596-52812-4.

Nota: En Qt 5, la nueva clase ` QRegularExpression ` ofrece una implementación de expresiones regulares compatible con Perl y se recomienda utilizarla en lugar de `QRegExp`.

Consideraciones de seguridad

QRegExp no impone ningún límite a los recursos que puede consumir un patrón, y el tamaño de sus búferes internos puede provocar un desbordamiento. Por lo tanto, un patrón relativamente pequeño, si se diseña de forma específica, puede agotar la memoria disponible, provocar un desbordamiento de la pila o corromper la memoria. Esto ocurre mientras se compila el patrón, es decir, tan pronto como se asigna el patrón, y no requiere que se coincida con ningún texto. Lo mismo se aplica a los patrones de ` wildcard `, que se traducen internamente a expresiones regulares.

Utiliza QRegExp únicamente con patrones procedentes de una fuente fiable. Es preferible utilizar « QRegularExpression » en su lugar, ya que limita los recursos que puede consumir una coincidencia.

Introducción

Las expresiones regulares se construyen a partir de expresiones, cuantificadores y aserciones. La expresión más sencilla es un carácter, por ejemplo, x o 5. Una expresión también puede ser un conjunto de caracteres 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 deben coincidir. x{1,1} significa que debe coincidir una y solo una «x». x{1,5} significa que debe coincidir una secuencia de caracteres «x» que contenga al menos una «x», pero no más de cinco.

Ten en cuenta que, en general, las expresiones regulares no se pueden utilizar para comprobar si los corchetes o las etiquetas están equilibrados. Por ejemplo, se puede escribir una expresión regular para que coincida con una etiqueta HTML de apertura <b> y su etiqueta de cierre </b>, si las etiquetas <b> no están anidadas; pero si las etiquetas <b> están anidadas, esa misma expresión regular coincidirá con una etiqueta de apertura <b> con la etiqueta de cierre incorrecta </b>. Para el fragmento <b>bold <b>bolder</b></b>, el primer <b> coincidiría con el primer </b>, lo cual no es correcto. Sin embargo, es posible escribir una expresión regular que coincida correctamente con corchetes o etiquetas anidadas, pero solo si el número de niveles de anidación es fijo y conocido. Si el número de niveles de anidación no es fijo ni conocido, es imposible escribir una expresión regular que no falle.

Supongamos que queremos una expresión regular que coincida con números enteros del 0 al 99. Se requiere al menos un dígito, por lo que empezamos con la expresión [0-9]{1,1}, que coincide con un único dígito exactamente una vez. Esta expresión regular coincide con números enteros del 0 al 9. Para encontrar números enteros hasta el 99, hay que aumentar el número máximo de ocurrencias a 2, de modo que la expresión regular pasa a ser [0-9]{1,2}. Esta expresión regular cumple el requisito original de encontrar números enteros del 0 al 99, pero también encontrará números enteros que aparezcan en medio de cadenas. Si queremos que el número entero coincidente sea toda la cadena, debemos utilizar los caracteres de anclaje ^ (símbolo de intercalación) y $ (signo de dólar). Cuando ^ es el primer carácter de una expresión regular, significa que la expresión debe coincidir desde el principio de la cadena. Cuando $ es el último carácter de la expresión regular, significa que la expresión debe coincidir hasta el final de la cadena. La expresión regular pasa a ser ^[0-9]{1,2}$. Ten en cuenta que los caracteres de anclaje, como ^ y $, no coinciden con caracteres, sino con posiciones dentro de la cadena.

Si has visto expresiones regulares descritas en otros lugares, es posible que tuvieran un aspecto diferente al 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 coincidir exactamente con una aparición, {1,1}, puede sustituirse por la propia expresión; es decir, x{1,1} es lo mismo que x. Así pues, 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, busca un dígito, seguido inmediatamente de 0 o 1 dígitos. En la práctica, se escribiría como ^\d\d ?$. El símbolo ? es una forma abreviada del cuantificador {0,1}, es decir, 0 o 1 ocurrencias. El símbolo ? hace que una expresión sea opcional. La expresión regular ^\d\d ?$ significa : desde el principio de la cadena, busca un dígito, seguido inmediatamente de 0 o 1 dígitos más, seguido inmediatamente del final de la cadena.

Para escribir una expresión regular que coincida con una de las palabras «mail» , «letter» o «correspondence», pero que no coincida con palabras que contengan estas palabras, por ejemplo, «email», «mailman», «mailer» y «letterbox», empieza con una expresión regular que coincida con «mail». Expresada de forma completa, la expresión regular es m{1,1}a{1,1}i{1,1}l{1,1}, pero como una expresión de caracteres se cuantifica automáticamente con {1,1}, podemos simplificar la expresión regular a «mail», es decir, una «m» seguida de una «a», seguida de una «i» y seguida de una «l». Ahora podemos utilizar la barra vertical |, que significa «o», para incluir las otras dos palabras, de modo que nuestra expresión regular para encontrar cualquiera de las tres palabras queda así: mail|letter|correspondence. Busca «mail» , «letter» o «correspondence». Aunque esta expresión regular coincidirá con una de las tres palabras que queremos encontrar, también coincidirá con palabras que no queremos que coincidan, por ejemplo, «email». Para evitar que la expresión regular coincida con palabras no deseadas, debemos indicarle que comience y termine la coincidencia en los límites de las palabras. En primer lugar, encerramos nuestra expresión regular entre paréntesis: (mail|letter|correspondence). Los paréntesis agrupan expresiones e identifican una parte de la expresión regular que deseamos « capture ». Encerrar la expresión entre paréntesis nos permite utilizarla como componente en expresiones regulares más complejas. También nos permite comprobar cuál de las tres palabras se ha coincido realmente. Para forzar que la coincidencia comience y termine en los límites de las palabras, encerramos la expresión regular en \b afirmaciones de límite de palabra: \b(mail|letter|correspondence)\b. Ahora, la expresión regular significa: Coincidir con un límite de palabra, seguido de la expresión regular entre paréntesis, seguido de un límite de palabra. La \b afirmación coincide con una posición en la expresión regular, no con un carácter. Un límite de palabra es cualquier carácter que no forme parte de una palabra, por ejemplo, un espacio, un salto de línea o el principio o el final de una cadena.

Si queremos sustituir los caracteres «&» por la entidad HTML «&amp;», la expresión regular que debemos buscar es simplemente «&». Pero esta expresión también coincidirá con los caracteres «&» que ya se hayan convertido en entidades HTML. Queremos sustituir únicamente los signos «&» que no vayan seguidos de «amp;». Para ello, necesitamos la aserción de avance negativo (?!__). La expresión regular se puede escribir entonces como &(?!amp;), es decir, coincide con un signo «&» 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 que se coincidan palabras que contengan cualquiera de los dos nombres, p. ej., «Ericsson». Ten en cuenta que la segunda expresión regular coincide con más variantes ortográficas de las que queremos: «Eric», «Erik», «Eiric» y «Eirik».

Algunos de los ejemplos mencionados anteriormente se han implementado en la sección « code examples ».

Caracteres y abreviaturas para conjuntos de caracteres

ElementoSignificado
cUn carácter representa a sí mismo, a menos que tenga un significado especial en expresiones regulares. Por ejemplo, c coincide con el carácter c.
\cUn carácter que va seguido de una barra invertida coincide con el propio carácter, salvo en los casos que se especifican a continuación. Por ejemplo, para hacer coincidir un símbolo de intercalación literal al principio de una cadena, escribe \^.
\aCoincide con el símbolo de campana ASCII (BEL, 0x07).
\fCoincide con el carácter de avance de página ASCII (FF, 0x0C).
\nCoincide con el salto de línea ASCII (LF, 0x0A, salto de línea de Unix).
\rCoincide con el retorno de carro ASCII (CR, 0x0D).
\tCoincide con la tabulación horizontal ASCII (HT, 0x09).
\vCoincide con la tabulación vertical ASCII (VT, 0x0B).
\xhhhhCoincide con el carácter Unicode correspondiente al número hexadecimal hhhh (entre 0x0000 y 0xFFFF).
\0ooo (es decir, \zero ooo)coincide con el carácter ASCII/Latin1 correspondiente al número octal ooo (entre 0 y 0377).
. (punto)Coincide con cualquier carácter (incluido el salto de línea).
\dCoincide con un dígito (QChar::isDigit()).
\DCoincide con un carácter que no sea un dígito.
\sCoincide con un carácter de espacio en blanco (QChar::isSpace()).
\SCoincide con un carácter que no sea un espacio en blanco.
\wCoincide con un carácter de palabra (QChar::isLetterOrNumber(), QChar::isMark() o «_»).
\WCoincide con un carácter que no sea de palabra.
\nLa n-ésima referencia hacia atrás, p. ej., \1, \2, etc.

Nota: El compilador de C++ transforma las barras invertidas en las cadenas. Para incluir una \ en una expresión regular, escríbela dos veces, es decir, \\. Para hacer coincidir el propio carácter de barra invertida, escríbela cuatro veces, es decir, \\\\.

Conjuntos de caracteres

Los corchetes significan que se busca cualquier carácter contenido entre ellos. Las abreviaturas de conjuntos de caracteres descritas anteriormente pueden aparecer en un conjunto de caracteres entre corchetes. Salvo las abreviaturas de conjuntos de caracteres y las dos excepciones siguientes, los caracteres no tienen ningún significado especial entre corchetes.

^El símbolo de intercalación (^) niega el conjunto de caracteres si aparece como primer carácter (es decir, inmediatamente después del corchete de apertura). [abc] coincide con «a», «b» o «c», pero [^abc] coincide con cualquier cosa excepto «a», «b» o «c».
-El guión indica un rango de caracteres. [W-Z] coincide con «W», «X», «Y» o «Z».

El uso de las abreviaturas de conjuntos de caracteres predefinidas resulta más portátil que el uso de rangos de caracteres en diferentes plataformas e idiomas. Por ejemplo, [0-9] coincide con un dígito en los alfabetos occidentales, pero \d coincide con un dígito en 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 como {1,1}, es decir, debe aparecer exactamente una vez. En la siguiente lista, E significa «expresión». Una expresión es un carácter, una abreviatura de un conjunto de caracteres, un conjunto de caracteres entre corchetes o una expresión entre paréntesis.

E?Coincide con cero o una aparición de E. Este cuantificador significa que la expresión anterior es opcional, ya que coincidirá tanto si se encuentra la expresión como si no. E? es lo mismo que E{0,1}. Por ejemplo, «dents?» coincide con «dent» o «dents».
E+Coincide con una o más apariciones de E. E+ es lo mismo que E{1,}. Por ejemplo, 0+ coincide con «0», «00», «000», etc.
E*Coincide con cero o más apariciones de E. Es lo mismo que E{0,}. El cuantificador * se utiliza a menudo por error cuando se debería usar +. Por ejemplo, si se utiliza «\s*$» en una expresión para buscar cadenas que terminen en un espacio en blanco, coincidirá con todas las cadenas, ya que «\s*$» significa «Coincide con cero o más espacios en blanco seguidos del final de la cadena». La expresión regular correcta para buscar cadenas que tengan al menos un carácter de espacio en blanco al final es «\s+$».
E{n}Coincide exactamente con n apariciones de E. E{n} equivale a repetir E n veces. Por ejemplo, x{5} es lo mismo que xxxxx. También es lo mismo que E{n,n}, p. ej., x{5,5}.
E{n,}Coincide con al menos n apariciones de E.
E{,m}Coincide con un máximo de m apariciones de E. E{,m} equivale a E{0,m}.
E{n,m}Coincide con al menos n y como máximo m apariciones de E.

Para aplicar un cuantificador a más caracteres que el inmediatamente anterior, utiliza paréntesis para agrupar caracteres en una expresión. Por ejemplo, «tag+» coincide con una «t» seguida de una «a» y 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 puedan. Por ejemplo, 0+ coincide con el primer cero que encuentre y con todos los ceros consecutivos que haya después de ese primer cero. Si se aplica a «20005», coincide con«20005». Los cuantificadores pueden configurarse para que no sean «glotones»; 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|letter|correspondence» que coincide con una cadena, sabemos que ha coincidido una de las palabras, pero no sabemos cuál. El uso de paréntesis nos permite «capturar» todo lo que coincida dentro de sus límites, por lo que si utilizamos (mail|letter|correspondence) y comparamos esta expresión regular con la cadena «I sent you some email», 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 expresión regular. Para hacer referencia al texto capturado utilizamos referencias hacia atrás, que se indexan a partir del 1, al igual que en cap(). Por ejemplo, podríamos buscar palabras duplicadas en una cadena utilizando \b(\w+)\W+\1\b , lo que significa buscar un límite de palabra seguido de uno o más caracteres de palabra, seguidos de uno o más caracteres que no sean de palabra, seguidos del mismo texto que la primera expresión entre paréntesis, y finalmente un límite de palabra.

Si queremos utilizar los paréntesis únicamente para agrupar y no para capturar, podemos usar la sintaxis sin captura, p. ej., (?:green|blue). Los paréntesis sin captura comienzan por «(?:» y terminan por «)». En este ejemplo, buscamos coincidencia con «green» o «blue», pero no capturamos la coincidencia, por lo que solo sabemos si se ha producido una coincidencia o no, pero no qué color se ha encontrado realmente. El uso de paréntesis no capturantes es más eficiente que el de paréntesis capturantes, ya que el motor de expresiones regulares tiene que realizar menos operaciones de gestión.

Tanto los paréntesis de captura como los de no captura pueden anidarse.

Por razones históricas, los cuantificadores (p. ej., *) que se aplican a los paréntesis de captura son más «codiciosos» que otros cuantificadores. Por ejemplo, a*(a*) coincidirá con «aaa» si cap(1) == «aaa». Este comportamiento difiere del que muestran otros motores de expresiones regulares (en particular, Perl). Para obtener un comportamiento de captura más intuitivo, especifica QRegExp::RegExp2 en el constructor de QRegExp o llama a setPatternSyntax(QRegExp::RegExp2).

Cuando no se puede determinar de antemano el número de coincidencias, una forma habitual de proceder 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 una afirmación sobre el texto en el punto en el que aparecen en la expresión regular, pero no coinciden con ningún carácter. En la siguiente lista, «E» representa cualquier expresión.

^El símbolo de intercalación (^) indica el inicio de la cadena. Si deseas que coincida el carácter literal « ^ », debes escaparlo escribiendo « \\^ ». Por ejemplo, «^#include» solo coincidirá con cadenas que empiecen por los caracteres «#include». (Cuando el símbolo de intercalación es el primer carácter de un conjunto de caracteres, tiene un significado especial; consulta Sets of Characters.)
$El signo de dólar indica el final de la cadena. Por ejemplo, «\d\s *$» coincidirá con cadenas que terminen en un dígito, seguido opcionalmente de un espacio en blanco. Si deseas que coincida con el literal « $ », debes escapar el carácter escribiendo « \\$ ».
\bUn límite de palabra. Por ejemplo, la expresión regular \bOK\b significa que se busca, inmediatamente después de un límite de palabra (p. ej., el inicio de la cadena o un espacio en blanco), la letra «O», seguida de la letra «K», inmediatamente antes de otro límite de palabra (p. ej., el final de la cadena o un espacio en blanco). Pero ten en cuenta que la aserción no coincide realmente con ningún espacio en blanco, por lo que si escribimos (\bOK\b ) y obtenemos una coincidencia, esta solo contendrá «OK», incluso si la cadena es «It's OK now».
\BUn límite que no sea de palabra. Esta afirmación es cierta siempre que \b sea falsa. Por ejemplo, si buscáramos \Bon\B en «Left on», la coincidencia fallaría (el espacio y el final de la cadena no son límites no de palabra), pero coincidiría en «tonne».
(?=E)Avance positivo. Esta aserción es verdadera si la expresión coincide en este punto de la expresión regular. Por ejemplo, const(?=\s+char) coincide con «const» siempre que vaya seguido de «char», como en «static const char *». (Compárese con const\s+char, que coincide con «static const char *».)
(?!E)Búsqueda anticipada negativa. Esta aserción es verdadera si la expresión no coincide en este punto de la expresión regular. Por ejemplo, const(?!\s+char) coincide con «const» excepto cuando va seguido de «char».

Coincidencia con comodines

La mayoría de los intérpretes de comandos, como bash o cmd.exe, admiten el «globbing de archivos», es decir, la capacidad de identificar un grupo de archivos mediante comodines. La función setPatternSyntax() se utiliza para alternar entre el modo de expresiones regulares y el de comodines. La coincidencia con comodines es mucho más sencilla que las expresiones regulares completas y solo tiene cuatro características:

cCualquier carácter representa a sí mismo, salvo los que se mencionan a continuación. Por lo tanto, c coincide con el carácter c.
?Coincide con cualquier carácter único. Es equivalente a «.» en las expresiones regulares completas.
*Coincide con cero o más caracteres cualesquiera. Es equivalente a «.*» en expresiones regulares completas.
[...]Los conjuntos de caracteres se pueden representar entre corchetes, al igual que en las expresiones regulares completas. Dentro de la clase de caracteres, al igual que fuera de ella, la barra invertida no tiene ningún significado especial.

En el modo «Wildcard», los caracteres comodín no se pueden escapar. En el modo « WildcardUnix », el carácter «\» escapa el comodín.

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

Para comprobar si una cadena cumple una expresión con comodines, utiliza 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 compatibles con Perl también lo son con QRegExp; consulta characters and abbreviations for sets of characters.

En QRegExp, salvo dentro de las clases de caracteres, « ^ » siempre indica el inicio de la cadena, por lo que los símbolos de intercalación deben escaparse siempre, a menos que se utilicen con ese fin. En Perl, el significado del símbolo de intercalación varía automáticamente en función de dónde aparezca, por lo que rara vez es necesario escaparlo. Lo mismo se aplica a « $ », que en QRegExp siempre indica el final de la cadena.

Los cuantificadores de QRegExp son los mismos que los cuantificadores «glotones» de Perl (pero véase el carácter note above). La coincidencia «no glotona» no se puede aplicar a cuantificadores individuales, pero sí a todos los cuantificadores del patrón. Por ejemplo, para que coincida con la expresión regular de Perl ro+?m se requiere:

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

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

La opción « /g » de Perl se puede emular utilizando « loop ».

En QRegExp , «.» coincide con cualquier carácter, por lo que todas las expresiones regulares de QRegExp tienen el equivalente a la opción « /s » de Perl. QRegExp no tiene un equivalente a la opción « /m » de Perl, pero esto se puede emular de diversas formas; por ejemplo, dividiendo la entrada en líneas o mediante un bucle con una expresión regular que busque saltos de línea.

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

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

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

No se admite la sintaxis ampliada de « /x » de Perl, ni las directivas (por ejemplo, (?i)), ni los comentarios de expresiones regulares (por ejemplo, (?#comment)). Por otro lado, se pueden utilizar las reglas de C++ para cadenas literales a fin de lograr lo mismo:

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

Se admiten tanto las aserciones de anticipación positiva de ancho cero (?=patrón) como las de anticipación negativa de ancho cero (?!patrón) con la misma sintaxis que en Perl. No se admiten las aserciones de retrocesión de Perl, las subexpresiones «independientes» ni las expresiones condicionales.

También se admiten los paréntesis sin captura, con la misma sintaxis (?:patrón).

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

Nota: dado que C++ transforma las barras invertidas (\), estas deben escribirse dos veces en el código; por ejemplo: \b debe escribirse como \\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 expresión regular sencilla para validar números enteros comprendidos entre 0 y 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) y los anclajes para buscar cadenas que no contengan espacios.

En el siguiente ejemplo, buscamos cadenas que contengan «mail», «letter» o «correspondence», pero solo se tienen en cuenta las 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, escribe la carta». La palabra «carta» también se captura (gracias a los paréntesis). Podemos ver qué texto hemos capturado de esta forma:

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

Esto capturará el texto del primer par de paréntesis de captura (contando los paréntesis de apertura de izquierda a derecha). Los paréntesis se cuentan a partir de 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 &amp;
QString line1 = "This & that";
line1.replace(rx, "&amp;");
// line1 == "This &amp; that"
QString line2 = "His &amp; hers & theirs";
line2.replace(rx, "&amp;");
// line2 == "His &amp; hers &amp; theirs"

Aquí hemos pasado el QRegExp a la función replace() de QString para sustituir el texto coincidente por un 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 buscar repetidamente la expresión regular en la cadena. Ten en cuenta que, en lugar de avanzar un carácter cada vez ( pos++ ), podríamos haber escrito pos += rx.matchedLength() para saltarnos la cadena ya encontrada. El recuento será igual a 3, al coincidir con «One Eric another Eirik, and an Ericsson. ¿Cuántos Eiriks, Eric?»; no coincide con «Ericsson» ni con «Eiriks» porque no están delimitados por límites entre palabras.

Un uso habitual de las expresiones regulares es dividir líneas de datos delimitados en sus campos componentes.

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 dejará de funcionar si añadimos más campos. Una solución más sencilla y mejor consiste en buscar el separador —en este caso, «\t »— y extraer el texto que lo rodea. La función ` QString::split()` puede tomar como argumento una cadena de separador o una expresión regular y dividir la cadena en consecuencia.

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

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

Para imitar la coincidencia de un shell, podemos utilizar el modo de comodines.

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

La coincidencia con comodines puede resultar práctica por su sencillez, pero cualquier expresión regular con comodines se puede definir utilizando expresiones regulares completas, por ejemplo, .*\.html$. Ten en cuenta que no podemos encontrar tanto los archivos .html como los .htm con un comodín, a menos que utilicemos *.htm*, lo que también encontraría «test.html.bak». Una expresión regular completa nos proporciona la precisión que necesitamos: .*\.html?$.

QRegExp puede realizar coincidencias sin distinguir entre mayúsculas y minúsculas utilizando setCaseSensitivity(), y puede emplear la coincidencia no codiciosa; véase setMinimal(). Por defecto, QRegExp utiliza expresiones regulares completas, pero esto se puede cambiar con setPatternSyntax(). La búsqueda se puede realizar hacia adelante con indexIn() o hacia atrás con lastIndexIn(). Se puede acceder al texto capturado mediante capturedTexts(), que devuelve una lista de todas las cadenas capturadas, o mediante cap(), que devuelve la cadena capturada correspondiente al índice dado. La función pos() toma un índice de coincidencia y devuelve la posición en la cadena donde se produjo la coincidencia (o -1 si no hubo coincidencia).

Portación a QRegularExpression

La clase ` QRegularExpression `, introducida en Qt 5, implementa expresiones regulares compatibles con Perl y supone una gran mejora con respecto a `QRegExp` en cuanto a las API ofrecidas, la sintaxis de patrones admitida y la 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 la coincidencia y extraer la subcadena capturada. Lo mismo se aplica a la coincidencia global y a ` QRegularExpressionMatchIterator`.

A continuación se describen otras diferencias.

Nota: ` QRegularExpression ` no admite todas las características disponibles en las expresiones regulares compatibles con Perl. La más notable es el hecho de que no se admiten nombres duplicados para los grupos de captura, y su uso puede dar lugar a un comportamiento indefinido. Esto podría cambiar en una futura versión de Qt.

Sintaxis diferente de los patrones

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

En casos concretos, QRegExp era demasiado permisivo y aceptaba patrones que simplemente no son válidos al utilizar QRegularExpression. Estos son fáciles de detectar, ya que los objetos QRegularExpression creados con estos patrones no son válidos (véase QRegularExpression::isValid()).

En otros casos, un patrón portado de QRegExp a QRegularExpression puede cambiar la semántica de forma silenciosa. Por lo tanto, es necesario revisar los patrones utilizados. Los casos más destacados 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 debe portarse a \x{2022}, o de lo contrario 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 adaptarse 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, una coincidencia compatible con Unicode, mientras que QRegularExpression requiere una opción específica; consulta más abajo para obtener más detalles.
  • c{.} en QRegExp coincide, por defecto, con todos los caracteres, incluido el carácter de salto de línea. QRegularExpression excluye el carácter de salto de línea por defecto. Para incluir el carácter de salto de línea, establece la opción de patrón « QRegularExpression::DotMatchesEverythingOption ».

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

Portación desde QRegExp::exactMatch()

QRegExp::exactMatch() tenía dos funciones: comparaba exactamente una expresión regular con una cadena de texto y permitía la coincidencia parcial.

Portación de la coincidencia exacta de QRegExp

La coincidencia exacta indica si la expresión regular coincide con toda la cadena objeto. Por ejemplo, las clases devuelven los siguientes resultados con la cadena objeto « "abc123" »:

QRegExp::exactMatch()QRegularExpressionMatch::hasMatch()
"\\d+"falseverdadero
"[a-z]+\\d+"verdaderoverdadero

La coincidencia exacta no se refleja en QRegularExpression. Si quieres asegurarte de que la cadena en cuestión coincide exactamente con la expresión regular, puedes 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));
Portabilidad desde la coincidencia parcial de QRegExp

Al utilizar QRegExp::exactMatch(), si no se encuentra una coincidencia exacta, aún es posible averiguar qué parte de la cadena de búsqueda ha coincidido con la expresión regular llamando a QRegExp::matchedLength(). Si la longitud devuelta es igual a la longitud de la cadena de búsqueda, se puede concluir que se ha encontrado una coincidencia parcial.

QRegularExpression admite la coincidencia parcial de forma explícita mediante el método adecuado QRegularExpression::MatchType.

Coincidencia global

Debido a las limitaciones de la API de QRegExp, resultó imposible implementar correctamente la coincidencia global (es decir, tal y como lo hace Perl). En concreto, los patrones que pueden coincidir con 0 caracteres (como "a*") plantean problemas.

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

Por ejemplo, si tienes un código como este:

QString subject("the quick fox");

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

Puedes reescribirlo así:

QString subject("the quick fox");

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

Al utilizar QRegExp, las clases de caracteres como \w, \d, etc., coinciden con caracteres que tienen la propiedad Unicode correspondiente: por ejemplo, \d coincide con cualquier carácter que tenga la propiedad Unicode « Nd » (dígito decimal).

Esas clases de caracteres solo coinciden con caracteres ASCII de forma predeterminada 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

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

Por ejemplo, si tienes un código como este:

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

Puedes reescribirlo así:

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

Ten en cuenta, sin embargo, que es posible que algunos patrones comodín similares a los del shell no se traduzcan tal y como esperas. El siguiente código de ejemplo dejará de funcionar sin avisar si se convierte simplemente utilizando la función mencionada anteriormente:

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, pasa 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() implementaba la coincidencia mínima simplemente invirtiendo la avidez de los cuantificadores (QRegExp no admitía cuantificadores perezosos, como *?, +?, etc.). En cambio, QRegularExpression sí admite cuantificadores ávidos, perezosos y posesivos. La opción de patrón « QRegularExpression::InvertedGreedinessOption » puede resultar útil para emular los efectos de « QRegExp::setMinimal » (): si se activa, invierte la avidez de los cuantificadores (los avidos se vuelven perezosos y viceversa).

Modos de careta

La opción de coincidencia « QRegularExpression::AnchorAtOffsetMatchOption » se puede utilizar para emular el comportamiento de « QRegExp::CaretAtOffset ». No existe ningún equivalente para los demás modos de « QRegExp::CaretMode ».

Véase también « QString », « QStringList » y « QSortFilterProxyModel ».

Documentación sobre tipos de miembros

enum QRegExp::CaretMode

La enumeración CaretMode define los diferentes significados del símbolo de intercalación (^) en una expresión regular. Los valores posibles son:

ConstanteValorDescripción
QRegExp::CaretAtZero0El símbolo de intercalación corresponde al índice 0 en la cadena buscada.
QRegExp::CaretAtOffset1El símbolo «^» corresponde al desplazamiento inicial de la búsqueda.
QRegExp::CaretWontMatch2El símbolo de inserción nunca coincide.

enum QRegExp::PatternSyntax

La sintaxis utilizada para interpretar el significado del patrón.

ConstanteValorDescripción
QRegExp::RegExp0Una sintaxis de coincidencia de patrones muy completa, similar a la de Perl. Es la opción predeterminada.
QRegExp::RegExp23Similar a RegExp, pero con « greedy quantifiers ». (Introducido en Qt 4.2.)
QRegExp::Wildcard1Proporciona una sintaxis sencilla de coincidencia de patrones similar a la utilizada por los shells (interpretadores de comandos) para la «expansión de archivos». Véase QRegExp wildcard matching.
QRegExp::WildcardUnix4Es similar a «Wildcard», pero con el comportamiento de un shell de Unix. Los caracteres comodín se pueden escapar con el carácter «\».
QRegExp::FixedString2El patrón es una cadena fija. Esto equivale a utilizar el patrón RegExp en una cadena en la que todos los metacaracteres se escapan mediante escape().
QRegExp::W3CXmlSchema115El patrón es una expresión regular tal y como se define en la especificación W3C XML Schema 1.1.

Véase también ` setPatternSyntax()`.

Documentación de funciones de miembro

QRegExp::QRegExp()

Crea una expresión regular vacía.

Véase también isValid() y errorString().

[explicit] QRegExp::QRegExp(const QString &pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive, QRegExp::PatternSyntax syntax = RegExp)

Crea un objeto de expresión regular a partir de la cadena pattern proporcionada. El patrón debe especificarse utilizando la notación de comodines si syntax es Wildcard; el valor por defecto es RegExp. El patrón distingue entre mayúsculas y minúsculas, a menos que cs sea Qt::CaseInsensitive. La coincidencia es «codiciosa» (máxima), pero puede modificarse llamando a setMinimal().

Véase también setPattern(), setCaseSensitivity() y setPatternSyntax().

QRegExp::QRegExp(const QRegExp &rx)

Crea una expresión regular como copia de rx.

Véase también operator=().

[noexcept] QRegExp::~QRegExp()

Elimina la expresión regular y borra sus datos internos.

QString QRegExp::cap(int nth = 0) const

Devuelve el texto capturado por la subexpresión ` nth `. La coincidencia completa tiene el índice 0 y las subexpresiones entre paréntesis tienen índices que comienzan a partir del 1 (excluyendo los paréntesis que no capturan).

QRegExp rxlen("(\\d+)(?:\\s*)(cm|inch)");
int pos = rxlen.indexIn("Length: 189cm");
if (pos > -1) {
    QString value = rxlen.cap(1); // "189"
    QString unit = rxlen.cap(2);  // "cm"
    // ...
}

El orden de los elementos coincidentes de cap() es el siguiente. El primer elemento, cap(0), es la cadena coincidente completa. Cada elemento posterior se corresponde con el siguiente paréntesis izquierdo de captura. Así, cap(1) es el texto del primer paréntesis de captura, cap(2) es el texto del segundo, y así sucesivamente.

Véase también capturedTexts() y pos().

int QRegExp::captureCount() const

Devuelve el número de capturas que contiene la expresión regular.

QStringList QRegExp::capturedTexts() const

Devuelve una lista con las cadenas de texto capturadas.

La primera cadena de la lista es la cadena completa que ha coincidido. Cada elemento posterior de la lista contiene una cadena que ha coincidido con una subexpresión (de captura) de la expresión regular.

Por ejemplo:

QRegExp rx("(\\d+)(\\s*)(cm|inch(es)?)");
int pos = rx.indexIn("Length: 36 inches");
QStringList list = rx.capturedTexts();
// list is now ("36 inches", "36", " ", "inches", "es")

El ejemplo anterior también captura elementos que pueden estar presentes pero que no nos interesan. Este problema se puede resolver utilizando paréntesis no capturantes:

QRegExp rx("(\\d+)(?:\\s*)(cm|inch(?:es)?)");
int pos = rx.indexIn("Length: 36 inches");
QStringList list = rx.capturedTexts();
// list is now ("36 inches", "36", "inches")

Ten en cuenta que, si quieres iterar sobre la lista, debes hacerlo sobre una copia, p. ej.

QStringList list = rx.capturedTexts();
QStringList::iterator it = list.begin();
while (it != list.end()) {
    myProcessing(*it);
    ++it;
}

Algunas expresiones regulares pueden coincidir un número indeterminado de veces. Por ejemplo, si la cadena de entrada es «Offsets: 12 14 99 231 7» y la expresión regular, rx, es (\d+), esperaríamos obtener una lista de todos los números coincidentes. Sin embargo, tras llamar a ` rx.indexIn(str)`, `capturedTexts()` devolverá la lista («12», «12»), es decir, que la coincidencia completa fue «12» y la primera subexpresión coincidente fue «12». El enfoque correcto es utilizar ` cap()` en un ` loop`.

El orden de los elementos en la lista de cadenas es el siguiente. El primer elemento es la cadena completa que coincide. Cada elemento posterior corresponde al siguiente paréntesis izquierdo de captura. Por lo tanto, `capturedTexts()`[1] es el texto del primer paréntesis de captura, `capturedTexts()`[2] es el texto del segundo, y así sucesivamente (lo que se corresponde con $1, $2, etc., en otros lenguajes de expresiones regulares).

Véanse también cap() y pos().

Qt::CaseSensitivity QRegExp::caseSensitivity() const

Devuelve « Qt::CaseSensitive » si la expresión regular coincide (distinguiendo entre mayúsculas y minúsculas); en caso contrario, devuelve « Qt::CaseInsensitive ».

Véase también setCaseSensitivity(), patternSyntax(), pattern() y isMinimal().

int QRegExp::countIn(const QString &str) const

Devuelve el número de veces que esta expresión regular coincide en str.

Véase también indexIn(), lastIndexIn() y replaceIn().

QString QRegExp::errorString() const

Devuelve una cadena de texto que explica por qué un patrón de expresión regular no es válido; en caso contrario, devuelve «no se ha producido ningún error».

Véase también isValid().

[static] QString QRegExp::escape(const QString &str)

Devuelve la cadena « str », en la que todos los caracteres especiales de expresiones regulares aparecen precedidos de una barra invertida. Los caracteres especiales son $, (,), *, +, ., ?, [, ,], ^, {, | y }.

Ejemplo:

s1 = QRegExp::escape("bingo");   // s1 == "bingo"
s2 = QRegExp::escape("f(x)");    // s2 == "f\\(x\\)"

Esta función resulta útil para construir patrones de expresiones regulares de forma dinámica:

QRegExp rx("(" + QRegExp::escape(name) +
           "|" + QRegExp::escape(alias) + ")");

Véase también setPatternSyntax().

bool QRegExp::exactMatch(const QString &str) const

Devuelve ` true ` si esta expresión regular coincide exactamente con ` str `; en caso contrario, devuelve ` false`. Se puede determinar qué parte de la cadena ha coincidido llamando a ` matchedLength()`.

Para una cadena de expresión regular R dada, exactMatch("R") es equivalente a indexIn("^R$"), ya que exactMatch() encierra efectivamente la expresión regular entre los anclajes de inicio y fin de cadena, salvo que establece matchedLength() de forma diferente.

Por ejemplo, si la expresión regular es «blue», entonces exactMatch() devuelve « true » solo para la entrada « blue ». Para las entradas « bluebell », « blutak » y « lightblue », exactMatch() devuelve « false » y « matchedLength()» devolverá 4, 3 y 0, respectivamente.

Aunque es de tipo const, esta función establece matchedLength(), capturedTexts() y pos().

Véanse también indexIn() y lastIndexIn().

QStringList QRegExp::filterList(const QStringList &stringList) const

Devuelve una lista de todas las cadenas que coinciden con esta expresión regular en stringList.

int QRegExp::indexIn(const QStringList &list, int from) const

Devuelve la posición en el índice de la primera coincidencia exacta de esta expresión regular en list, buscando hacia adelante a partir de la posición en el índice from. Devuelve -1 si no se ha encontrado ninguna coincidencia.

Véase también lastIndexIn() y exactMatch().

int QRegExp::indexIn(const QString &str, int offset = 0, QRegExp::CaretMode caretMode = CaretAtZero) const

Intenta encontrar una coincidencia en str a partir de la posición offset (0 por defecto). Si offset es -1, la búsqueda comienza en el último carácter; si es -2, en el penúltimo carácter; y así sucesivamente.

Devuelve la posición de la primera coincidencia, o -1 si no se ha encontrado ninguna.

El parámetro « caretMode » se puede utilizar para indicar si «^» debe coincidir en el índice 0 o en « offset ».

Quizá prefieras utilizar ` QString::indexOf()`, ` QString::contains()` o incluso ` QStringList::filter()`. Para sustituir las coincidencias, utiliza ` QString::replace()`.

Ejemplo:

QString str = "offsets: 1.23 .50 71.00 6.00";
QRegExp rx("\\d*\\.\\d+");    // primitive floating point matching
int count = 0;
int pos = 0;
while ((pos = rx.indexIn(str, pos)) != -1) {
    ++count;
    pos += rx.matchedLength();
}
// pos will be 9, 14, 18 and finally 24; count will end up as 4

Aunque es una constante, esta función establece matchedLength(), capturedTexts() y pos().

Si el valor de « QRegExp » es una expresión comodín (véase setPatternSyntax()) y se desea comparar una cadena con la expresión comodín completa, utilice exactMatch() en lugar de esta función.

Véanse también lastIndexIn() y exactMatch().

bool QRegExp::isEmpty() const

Devuelve « true » si la cadena de patrón está vacía; en caso contrario, devuelve «false».

Si se llama a ` exactMatch()` con un patrón vacío sobre una cadena vacía, devolverá `true`; en caso contrario, devolverá ` false `, ya que opera sobre toda la cadena. Si se llama a ` indexIn()` con un patrón vacío sobre cualquier cadena, devolverá el desplazamiento inicial (0 por defecto), ya que el patrón vacío coincide con el «espacio en blanco» al principio de la cadena. En este caso, la longitud de la coincidencia devuelta por ` matchedLength()` será 0.

Véase QString::isEmpty().

bool QRegExp::isMinimal() const

Devuelve « true » si la coincidencia mínima (no codiciosa) está habilitada; en caso contrario, devuelve « false ».

Véase también caseSensitivity() y setMinimal().

bool QRegExp::isValid() const

Devuelve ` true ` si la expresión regular es válida; en caso contrario, devuelve `false`. Una expresión regular no válida nunca encuentra coincidencias.

El patrón [a-z] es un ejemplo de patrón no válido, ya que le falta un corchete de cierre.

Ten en cuenta que la validez de una expresión regular también puede depender de la configuración del indicador de comodín; por ejemplo, *.html es una expresión regular con comodín válida, pero una expresión regular completa inválida.

Véase también errorString().

int QRegExp::lastIndexIn(const QStringList &list, int from) const

Devuelve la posición en el índice de la última coincidencia exacta de esta expresión regular en list, buscando hacia atrás a partir de la posición en el índice from. Si from es -1 (valor por defecto), la búsqueda comienza en el último elemento. Devuelve -1 si no se ha encontrado ningún elemento que coincida.

Véase también QRegExp::exactMatch().

int QRegExp::lastIndexIn(const QString &str, int offset = -1, QRegExp::CaretMode caretMode = CaretAtZero) const

Intenta encontrar una coincidencia hacia atrás en « str » a partir de la posición « offset ». Si « offset » es -1 (el valor por defecto), la búsqueda comienza en el último carácter; si es -2, en el penúltimo carácter; y así sucesivamente.

Devuelve la posición de la primera coincidencia, o -1 si no se ha encontrado ninguna.

El parámetro caretMode puede utilizarse para indicar si ^ debe coincidir en el índice 0 o en offset.

Aunque es const, esta función establece matchedLength(), capturedTexts() y pos().

Advertencia: la búsqueda hacia atrás es mucho más lenta que la búsqueda hacia adelante.

Véanse también indexIn() y exactMatch().

int QRegExp::matchedLength() const

Devuelve la longitud de la última cadena encontrada, o -1 si no se ha encontrado ninguna coincidencia.

Véanse también exactMatch(), indexIn() y lastIndexIn().

QString QRegExp::pattern() const

Devuelve la cadena de patrón de la expresión regular. El patrón puede tener sintaxis de expresión regular o sintaxis de comodines, dependiendo de patternSyntax().

Véase también setPattern(), patternSyntax() y caseSensitivity().

QRegExp::PatternSyntax QRegExp::patternSyntax() const

Devuelve la sintaxis utilizada por la expresión regular. El valor por defecto es QRegExp::RegExp.

Véase también setPatternSyntax(), pattern() y caseSensitivity().

int QRegExp::pos(int nth = 0) const

Devuelve la posición del texto capturado por « nth » en la cadena buscada. Si « nth » es 0 (valor por defecto), «pos()» devuelve la posición de toda la coincidencia.

Ejemplo:

QRegExp rx("/([a-z]+)/([a-z]+)");
rx.indexIn("Output /dev/null");   // returns 7 (position of /dev/null)
rx.pos(0);                        // returns 7 (position of /dev/null)
rx.pos(1);                        // returns 8 (position of dev)
rx.pos(2);                        // returns 12 (position of null)

En el caso de coincidencias de longitud cero, pos() siempre devuelve -1. (Por ejemplo, si cap(4) devolviera una cadena vacía, pos(4) devolvería -1.) Esta es una característica de la implementación.

Véase también cap() y capturedTexts().

QString QRegExp::removeIn(const QString &str) const

Elimina todas las apariciones de esta expresión regular str y devuelve el resultado

Hace lo mismo que replaceIn(str, QString()).

Véase también indexIn(), lastIndexIn() y replaceIn().

QString QRegExp::replaceIn(const QString &str, const QString &after) const

Sustituye todas las apariciones de esta expresión regular en str por after y devuelve el resultado.

En el caso de las expresiones regulares que contengan capturing parentheses, las apariciones de \1, \2, ..., en after se sustituyen por rx.cap(1), cap(2), ...

Véase también indexIn(), lastIndexIn() y QRegExp::cap().

QStringList QRegExp::replaceIn(const QStringList &stringList, const QString &after) const

Sustituye cada aparición de esta expresión regular, en cada una de las entradas de stringList, por after. Devuelve una referencia a la lista de cadenas.

void QRegExp::setCaseSensitivity(Qt::CaseSensitivity cs)

Establece la coincidencia con distinción entre mayúsculas y minúsculas en cs.

Si cs es Qt::CaseSensitive, \.txt$ coincide con readme.txt, pero no con README.TXT.

Véase también caseSensitivity(), setPatternSyntax(), setPattern() y setMinimal().

void QRegExp::setMinimal(bool minimal)

Activa o desactiva la coincidencia mínima. Si minimal es falso, la coincidencia es «codiciosa» (máxima), que es el valor por defecto.

Por ejemplo, supongamos que tenemos la cadena de entrada «We must be <b>bold</b>, very <b>bold</b>!» y el patrón <b>.*</b>. Con la coincidencia codiciosa (máxima) por defecto, la coincidencia es «We must be <b>bold</b>, very <b>bold</b>!». Pero con la coincidencia mínima (no «glotona»), la primera coincidencia es: «We must be <b>bold</b>, very <b>bold</b>!» y la segunda coincidencia es «We must be <b>bold</b>, very <b>bold</b>!». En la práctica, podríamos utilizar en su lugar el patrón <b>[^<]*</b>, aunque esto seguirá fallando con las etiquetas anidadas.

Véase también isMinimal() y setCaseSensitivity().

void QRegExp::setPattern(const QString &pattern)

Establece la cadena de patrón en pattern. Las opciones de distinción entre mayúsculas y minúsculas, caracteres comodín y coincidencia mínima no se modifican.

Véanse también pattern(), setPatternSyntax() y setCaseSensitivity().

void QRegExp::setPatternSyntax(QRegExp::PatternSyntax syntax)

Establece el modo de sintaxis para la expresión regular. El valor por defecto es « QRegExp::RegExp ».

Al establecer « syntax » en « QRegExp::Wildcard », se habilita el modo de coincidencia simple similar al del shell ( QRegExp wildcard matching). Por ejemplo, «r*.txt» coincide con la cadena « readme.txt » en modo comodín, pero no coincide con « readme ».

Si se establece syntax en QRegExp::FixedString, el patrón se interpreta como una cadena simple. En ese caso, no es necesario escapar los caracteres especiales (por ejemplo, la barra invertida).

Véase también patternSyntax(), setPattern(), setCaseSensitivity() y escape().

QStringList QRegExp::splitString(const QString &str, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const

Divide str en subcadenas cada vez que esta expresión regular coincida, y devuelve la lista de dichas cadenas. Si esta expresión regular no coincide en ningún punto de la cadena, split() devuelve una lista de un solo elemento que contiene str.

Si behavior se establece en Qt::KeepEmptyParts, los campos vacíos se incluyen en la lista resultante.

Véanse también QStringList::join() y QString::split().

[noexcept] void QRegExp::swap(QRegExp &other)

Sustituye la expresión regular « other » por esta expresión regular. Esta operación es muy rápida y nunca falla.

QRegExp::operator QVariant() const

Devuelve la expresión regular como un QVariant

bool QRegExp::operator!=(const QRegExp &rx) const

Devuelve « true » si esta expresión regular no es igual a « rx »; en caso contrario, devuelve « false ».

Véase también operator==().

[noexcept] QRegExp &QRegExp::operator=(QRegExp &&other)

Asigna « other » a esta instancia de « QRegExp ». .

QRegExp &QRegExp::operator=(const QRegExp &rx)

Copia la expresión regular rx y devuelve una referencia a la copia. También se copian las opciones de distinción entre mayúsculas y minúsculas, comodines y coincidencia mínima.

bool QRegExp::operator==(const QRegExp &rx) const

Devuelve « true » si esta expresión regular es igual a « rx »; en caso contrario, devuelve « false ».

Dos objetos ` QRegExp ` son iguales si tienen las mismas cadenas de patrón y la misma configuración en cuanto a distinción entre mayúsculas y minúsculas, comodines y coincidencia mínima.

Elementos no miembros relacionados

[noexcept] size_t qHash(const QRegExp &key, size_t seed = 0)

Devuelve el valor hash de « key », utilizando « seed » como semilla para el cálculo.

QDataStream &operator<<(QDataStream &out, const QRegExp &regExp)

Escribe la expresión regular « regExp » en el flujo « out ».

Véase también «Serialización detipos de datos de Qt».

QDataStream &operator>>(QDataStream &in, QRegExp &regExp)

Lee una expresión regular del flujo in y la guarda en regExp.

Véase también «Serialización detipos de datos de Qt».

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.