QRegExp Class

Detaillierte Beschreibung

Diese Klasse ist in Qt 6 veraltet. Bitte verwenden Sie stattdessen QRegularExpression für allen neuen Code. Richtlinien für die Portierung von altem Code von QRegExp auf QRegularExpression finden Sie unter {Porting to QRegularExpression}

Ein regulärer Ausdruck, oder "regexp", ist ein Muster für den Abgleich von Teilstrings in einem Text. Dies ist in vielen Kontexten nützlich, z.B.,

Es folgt eine kurze Einführung in Regexps, eine Beschreibung der Regexp-Sprache von Qt, einige Beispiele und die Dokumentation der Funktion selbst. QRegExp ist der Regexp-Sprache von Perl nachempfunden. Sie unterstützt Unicode vollständig. QRegExp kann auch in einem einfacheren Wildcard-Modus verwendet werden, der der Funktionalität von Befehlsshells ähnlich ist. Die von QRegExp verwendeten Syntaxregeln können mit setPatternSyntax() geändert werden. Insbesondere kann die Mustersyntax auf QRegExp::FixedString gesetzt werden, was bedeutet, dass das zu übereinstimmende Muster als einfache Zeichenkette interpretiert wird, d.h. Sonderzeichen (z.B. Backslash) werden nicht escaped.

Ein guter Text über Regexps ist Mastering Regular Expressions (Third Edition) von Jeffrey E. F. Friedl, ISBN 0-596-52812-4.

Einführung

Regexps sind aus Ausdrücken, Quantifizierern und Assertions aufgebaut. Der einfachste Ausdruck ist ein Zeichen, z.B. x oder 5. Ein Ausdruck kann auch aus einer Reihe von Zeichen bestehen, die in eckige Klammern eingeschlossen sind. [ABCD] passt auf ein A oder ein B oder ein C oder ein D. Wir können denselben Ausdruck als [A-D] schreiben, und ein Ausdruck, der auf jeden Großbuchstaben des englischen Alphabets passt, wird als [A-Z] geschrieben.

Ein Quantifizierer gibt die Anzahl der Vorkommen eines Ausdrucks an, die übereinstimmen müssen. x{1,1} bedeutet, dass nur ein einziges x übereinstimmt. x{1,5} bedeutet, dass eine Folge von x Zeichen übereinstimmt, die mindestens ein x aber nicht mehr als fünf enthält.

Beachten Sie, dass regexps im Allgemeinen nicht verwendet werden können, um auf ausgeglichene Klammern oder Tags zu prüfen. Beispielsweise kann ein Regexp so geschrieben werden, dass er mit einem öffnenden html <b> und seinem schließenden </b> übereinstimmt, wenn die <b> Tags nicht verschachtelt sind, aber wenn die <b> Tags verschachtelt sind, wird derselbe Regexp mit einem öffnenden <b> Tag und dem falschen schließenden </b> übereinstimmen. Bei dem Fragment <b>bold <b>bolder</b></b> würde das erste <b> mit dem ersten </b> übereinstimmen, was nicht korrekt ist. Es ist jedoch möglich, einen regexp zu schreiben, der verschachtelte Klammern oder Tags korrekt zuordnet, aber nur, wenn die Anzahl der Verschachtelungsebenen feststeht und bekannt ist. Wenn die Anzahl der Verschachtelungsebenen nicht feststeht und bekannt ist, ist es unmöglich, eine Regexp zu schreiben, die nicht fehlschlägt.

Angenommen, wir wollen eine Regexp schreiben, die auf ganze Zahlen im Bereich von 0 bis 99 passt, wobei mindestens eine Ziffer erforderlich ist. Wir beginnen also mit dem Ausdruck [0-9]{1,1}, der genau einmal auf eine einzelne Ziffer passt. Diese Regexp stimmt mit ganzen Zahlen im Bereich von 0 bis 9 überein. Um ganze Zahlen bis 99 zu finden, erhöhen Sie die maximale Anzahl der Vorkommen auf 2, so dass die Regexp zu [0-9]{1,2} wird. Diese Regexp erfüllt die ursprüngliche Anforderung, ganze Zahlen von 0 bis 99 zu finden, aber sie findet auch ganze Zahlen, die in der Mitte von Zeichenketten vorkommen. Wenn die ganze Zeichenkette abgeglichen werden soll, müssen die Ankerzeichen ^ (Caret) und $ (Dollar) verwendet werden. Wenn ^ das erste Zeichen in einer Regexp ist, bedeutet dies, dass die Regexp vom Anfang der Zeichenkette an passen muss. Wenn $ das letzte Zeichen der Regexp ist, bedeutet dies, dass die Regexp bis zum Ende der Zeichenfolge übereinstimmen muss. Die Regexp wird zu ^ [0-9]{1,2}$. Beachten Sie, dass Behauptungen, z. B. ^ und $, nicht auf Zeichen, sondern auf Stellen in der Zeichenkette passen.

Wenn Sie Regexps an anderer Stelle beschrieben gesehen haben, sehen sie vielleicht anders aus als die hier gezeigten. Das liegt daran, dass einige Zeichengruppen und einige Quantifizierer so häufig vorkommen, dass sie durch spezielle Symbole dargestellt werden. [0-9] kann durch das Symbol \d ersetzt werden. Der Quantifizierer für genau ein Vorkommen, {1,1}, kann durch den Ausdruck selbst ersetzt werden, d. h. x{1,1} ist dasselbe wie x. Unser 0-99-Matcher könnte also als ^\d{1 ,2}$ geschrieben werden. Er kann auch als ^\d\d{0 ,1}$ geschrieben werden, d.h. am Anfang der Zeichenkette wird eine Ziffer abgeglichen, unmittelbar gefolgt von 0 oder 1 Ziffern. In der Praxis würde es als ^\d\d ?$ geschrieben werden. Das ? ist eine Abkürzung für den Quantifizierer {0,1}, d. h. 0 oder 1 Vorkommen. ? macht einen Ausdruck optional. Die Regexp ^\d\d ?$ bedeutet, dass am Anfang der Zeichenfolge eine Ziffer übereinstimmt, unmittelbar gefolgt von 0 oder 1 weiteren Ziffer, unmittelbar gefolgt vom Ende der Zeichenfolge.

Um eine Regexp zu schreiben, die auf eines der Wörter "mail" oder "letter" oder "correspondence" passt, aber nicht auf Wörter, die diese Wörter enthalten, z. B. "email", "mailman", "mailer" und "letterbox", beginnen Sie mit einer Regexp, die auf "mail" passt. Vollständig ausgedrückt lautet die Regexp m{1,1}a{1,1}i{1,1}l{1,1}, aber da ein Zeichenausdruck automatisch durch {1,1} quantifiziert wird, können wir die Regexp zu mail vereinfachen, d. h. ein 'm' gefolgt von einem 'a' gefolgt von einem 'i' gefolgt von einem 'l'. Nun können wir den vertikalen Balken |, der für oder steht, verwenden, um die beiden anderen Wörter einzuschließen, so dass unsere Regexp für die Übereinstimmung mit einem der drei Wörter zu mail|letter|correspondence wird. Passt auf 'mail' oder 'letter' oder 'correspondence'. Diese Regexp stimmt zwar mit einem der drei gewünschten Wörter überein, aber sie stimmt auch mit Wörtern überein, die nicht übereinstimmen sollen, z. B. "E-Mail". Um zu verhindern, dass die Regexp mit unerwünschten Wörtern übereinstimmt, müssen wir ihr sagen, dass sie die Übereinstimmung an Wortgrenzen beginnen und beenden soll. Zuerst schließen wir unsere Regexp in Klammern ein, (mail|letter|correspondence). Klammern fassen Ausdrücke zusammen und kennzeichnen einen Teil des Regexp, den wir capture möchten. Wenn wir den Ausdruck in Klammern setzen, können wir ihn als Komponente in komplexeren Regexps verwenden. Außerdem können wir so untersuchen, welches der drei Wörter tatsächlich übereinstimmt. Um zu erzwingen, dass die Übereinstimmung an Wortgrenzen beginnt und endet, schließen wir die Regexp in \b-Wortgrenzen-Assertionen ein: \b (mail|brief|korrespondenz)\b. Jetzt bedeutet die Regexp: Übereinstimmung mit einer Wortgrenze, gefolgt von der Regexp in Klammern, gefolgt von einer Wortgrenze. Die Behauptung \b entspricht einer Position in der Regexp, nicht einem Zeichen. Eine Wortgrenze ist ein beliebiges Nicht-Wortzeichen, z. B. ein Leerzeichen, ein Zeilenumbruch oder der Anfang oder das Ende einer Zeichenfolge.

Wenn wir kaufmännische Und-Zeichen durch die HTML-Entität & ersetzen wollen , ist die Regexp, die passen soll, einfach &. Diese Regexp findet jedoch auch Ampersands, die bereits in HTML-Entities umgewandelt wurden. Wir wollen nur die Ampersands ersetzen, die nicht bereits von amp; gefolgt sind. Dazu benötigen wir die negative Vorausschau-Assertion (?!__). Die Regexp kann dann als &(?!amp;) geschrieben werden, d.h. ein kaufmännisches Und-Zeichen, das nicht von amp; gefolgt wird, muss gefunden werden.

Wenn wir alle Vorkommen von 'Eric' und 'Eirik' in einer Zeichenkette zählen wollen, sind zwei gültige Lösungen \b (Eric|Eirik)\b und \bEi ?ri[ck]\b. Die Wortgrenzenbehauptung '\b' ist erforderlich, um zu vermeiden, dass Wörter übereinstimmen, die beide Namen enthalten, z. B. 'Ericsson'. Beachten Sie, dass die zweite Regexp mit mehr Schreibweisen übereinstimmt, als wir wollen: 'Eric', 'Erik', 'Eiric' und 'Eirik'.

Einige der oben besprochenen Beispiele sind im Abschnitt code examples implementiert.

Zeichen und Abkürzungen für Zeichensätze

Hinweis: Der C++-Compiler wandelt Backslashes in Zeichenketten um. Um ein \ in einen Regexp einzuschließen, geben Sie es zweimal ein, d. h. \\. Um das Backslash-Zeichen selbst zu finden, geben Sie es viermal ein, z. B. \\\\.

Gruppen von Zeichen

Eckige Klammern bedeuten, dass jedes in den eckigen Klammern enthaltene Zeichen übereinstimmt. Die oben beschriebenen Zeichensatzabkürzungen können in einem Zeichensatz in eckigen Klammern erscheinen. Abgesehen von den Zeichensatzabkürzungen und den beiden folgenden Ausnahmen haben Zeichen in eckigen Klammern keine besondere Bedeutung.

Die Verwendung der vordefinierten Zeichensatzabkürzungen ist plattform- und sprachenunabhängiger als die Verwendung von Zeichenbereichen. Zum Beispiel entspricht [0-9] einer Ziffer in westlichen Alphabeten, aber \d entspricht einer Ziffer in jedem Alphabet.

Hinweis: In anderen Regexp-Dokumentationen werden Zeichensätze oft als "Zeichenklassen" bezeichnet.

Quantoren

Standardmäßig wird ein Ausdruck automatisch durch {1,1} quantifiziert, d.h. er sollte genau einmal vorkommen. In der folgenden Liste steht E für Ausdruck. Ein Ausdruck ist ein Zeichen oder eine Abkürzung für eine Reihe von Zeichen oder eine Reihe von Zeichen in eckigen Klammern oder ein Ausdruck in Klammern.

Um einen Quantifizierer auf mehr als nur das vorangehende Zeichen anzuwenden, verwenden Sie Klammern, um Zeichen in einem Ausdruck zusammenzufassen. Zum Beispiel passt tag+ auf ein 't' gefolgt von einem 'a' gefolgt von mindestens einem 'g', während (tag)+ auf mindestens ein Vorkommen von 'tag' passt.

Hinweis: Quantifizierer sind normalerweise "gierig". Sie passen immer auf so viel Text wie möglich. Zum Beispiel passt 0+ auf die erste gefundene Null und alle nachfolgenden Nullen nach der ersten Null. Angewandt auf "20005" entspricht es "20005". Quantifizierer können nicht-gierig gemacht werden, siehe setMinimal().

Erfassen von Text

Mit Hilfe von Klammern können wir Elemente gruppieren, um sie zu quantifizieren und zu erfassen. Wenn zum Beispiel der Ausdruck mail|letter|correspondence auf eine Zeichenfolge passt, wissen wir, dass eines der Wörter passt, aber nicht welches. Wenn wir also (mail|letter|correspondence) verwenden und diesen Regexp mit der Zeichenkette "I sent you some email" abgleichen, können wir die Funktionen cap() oder capturedTexts() verwenden, um die übereinstimmenden Zeichen zu extrahieren, in diesem Fall "mail".

Wir können den erfassten Text innerhalb der Regexp selbst verwenden. Um auf den erfassten Text zu verweisen, verwenden wir Rückverweise, die von 1 an indiziert werden, genau wie bei cap(). Wir könnten zum Beispiel nach doppelten Wörtern in einer Zeichenkette suchen, indem wir \b (\w+)\W+\1\b verwenden, was bedeutet, dass eine Wortgrenze, gefolgt von einem oder mehreren Wortzeichen, gefolgt von einem oder mehreren Nicht-Wortzeichen, gefolgt von demselben Text wie der erste geklammerte Ausdruck, gefolgt von einer Wortgrenze, übereinstimmt.

Wenn wir Klammern nur zur Gruppierung und nicht zur Erfassung verwenden wollen, können wir die nicht-erfassende Syntax verwenden, z. B. (?:green|blue). Nicht-erfassende Klammern beginnen mit '(?:' und enden mit ')'. In diesem Beispiel stimmen wir entweder mit "grün" oder "blau" überein, aber wir erfassen die Übereinstimmung nicht, so dass wir nur wissen, ob wir übereinstimmen oder nicht, aber nicht, welche Farbe wir tatsächlich gefunden haben. Die Verwendung von nicht erfassenden Klammern ist effizienter als die Verwendung von erfassenden Klammern, da die Regexp-Engine weniger Buchhaltungsarbeit leisten muss.

Sowohl erfassende als auch nicht erfassende Klammern können verschachtelt werden.

Aus historischen Gründen sind Quantoren (z. B. *), die sich auf schließende Klammern beziehen, "gieriger" als andere Quantoren. Zum Beispiel passt a*(a*) auf "aaa" mit cap(1) == "aaa". Dieses Verhalten unterscheidet sich von dem anderer Regexp-Engines (vor allem Perl). Um ein intuitiveres Erfassungsverhalten zu erhalten, geben Sie QRegExp::RegExp2 an den QRegExp-Konstruktor an oder rufen Sie setPatternSyntax(QRegExp::RegExp2) auf.

Wenn die Anzahl der Übereinstimmungen nicht im Voraus bestimmt werden kann, ist es eine übliche Redewendung, cap() in einer Schleife zu verwenden. Zum Beispiel:

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"]

Behauptungen

Behauptungen machen eine Aussage über den Text an der Stelle, an der sie in der Regexp vorkommen, aber sie stimmen nicht mit irgendwelchen Zeichen überein. In der folgenden Liste steht E für einen beliebigen Ausdruck.

Platzhalterübereinstimmung

Die meisten Befehlsshells wie bash oder cmd.exe unterstützen "file globbing", die Möglichkeit, eine Gruppe von Dateien mit Hilfe von Platzhaltern zu identifizieren. Die Funktion setPatternSyntax() wird verwendet, um zwischen Regexp- und Wildcard-Modus zu wechseln. Der Wildcard-Abgleich ist viel einfacher als vollständige Regexps und hat nur vier Funktionen:

Im Modus Wildcard können die Platzhalterzeichen nicht escaped werden. Im Modus WildcardUnix wird der Platzhalter durch das Zeichen '\' umgangen.

Wenn wir zum Beispiel im Wildcard-Modus sind und Zeichenketten haben, die Dateinamen enthalten, könnten wir HTML-Dateien mit *.html identifizieren. Dies entspricht null oder mehr Zeichen gefolgt von einem Punkt, gefolgt von 'h', 't', 'm' und 'l'.

Um eine Zeichenfolge auf einen Platzhalterausdruck zu prüfen, verwenden Sie exactMatch(). Zum Beispiel:

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

Hinweise für Perl-Benutzer

Die meisten der von Perl unterstützten Zeichenklassenabkürzungen werden von QRegExp unterstützt, siehe characters and abbreviations for sets of characters.

In QRegExp, außer innerhalb von Zeichenklassen, bedeutet ^ immer den Anfang der Zeichenkette, daher müssen Carets immer escaped werden, es sei denn, sie werden zu diesem Zweck verwendet. In Perl ändert sich die Bedeutung von caret automatisch, je nachdem, wo es vorkommt, so dass es selten notwendig ist, es zu escapen. Das gleiche gilt für $, das in QRegExp immer das Ende der Zeichenkette bedeutet.

Die Quantoren von QRegExp sind die gleichen wie die greedy-Quantoren von Perl (siehe aber note above). Non-Greedy-Matching kann nicht auf einzelne Quantoren angewendet werden, wohl aber auf alle Quantoren im Muster. Zum Beispiel erfordert die Übereinstimmung mit der Perl-Regexp ro+?m:

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

Die Entsprechung der Perl-Option /i ist setCaseSensitivity(Qt::CaseInsensitive).

Die Option /g von Perl kann mit loop emuliert werden.

In QRegExp passt . auf jedes beliebige Zeichen, daher haben alle QRegExp-Regexps das Äquivalent zu Perls Option /s. QRegExp hat kein Äquivalent zu Perls /m Option, aber diese kann auf verschiedene Arten emuliert werden, z.B. durch Aufteilung der Eingabe in Zeilen oder durch eine Schleife mit einer Regexp, die nach Zeilenumbrüchen sucht.

Da QRegExp stringorientiert ist, gibt es keine \A-, \Z- oder \z-Assertions. Die \G-Assertion wird nicht unterstützt, kann aber in einer Schleife emuliert werden.

Das $& von Perl ist cap(0) oder capturedTexts()[0]. Es gibt keine QRegExp-Äquivalente für $`, $' oder $+. Perls Capturing-Variablen, $1, $2, ... entsprechen cap(1) oder capturedTexts()[1], cap(2) oder capturedTexts()[2], usw.

Um ein Muster zu ersetzen, verwenden Sie QString::replace().

Die erweiterte /x -Syntax von Perl wird nicht unterstützt, ebenso wenig wie Direktiven, z. B. (?i), oder Regexp-Kommentare, z. B. (?#comment). Andererseits können die Regeln von C++ für literale Zeichenketten verwendet werden, um das Gleiche zu erreichen:

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

Sowohl positive als auch negative Lookahead-Assertions mit Null-Breite (?=pattern) und (?!pattern) werden mit der gleichen Syntax wie in Perl unterstützt. Die Lookbehind-Assertions von Perl, "unabhängige" Unterausdrücke und bedingte Ausdrücke werden nicht unterstützt.

Nicht-einfangende Klammern werden ebenfalls unterstützt, mit der gleichen (?:pattern) Syntax.

Siehe QString::split() und QStringList::join() für Äquivalente zu Perls Split- und Join-Funktionen.

Hinweis: Da C++ \'s transformiert, müssen sie im Code zweimal geschrieben werden, z.B. muss \b geschrieben werden.

Code-Beispiele

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)

Die dritte Zeichenfolge entspricht'6'. Dies ist eine einfache Validierungs-Regexp für ganze Zahlen im Bereich von 0 bis 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)

Die zweite Zeichenfolge entspricht"This_is-OK". Wir haben die Zeichensatzabkürzung "\S" (ohne Leerzeichen) und die Anker verwendet, um Zeichenfolgen zu finden, die keine Leerzeichen enthalten.

Im folgenden Beispiel passen wir auf Zeichenfolgen, die "mail" oder "letter" oder "correspondence" enthalten, aber nur auf ganze Wörter, d. h. nicht auf "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

Die zweite Zeichenfolge entspricht "Bitte schreiben Sie den Brief". Das Wort "Brief" wird ebenfalls erfasst (wegen der Klammern). So können wir sehen, welchen Text wir erfasst haben:

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

Dies erfasst den Text aus dem ersten Satz von Erfassungsklammern (wobei die Erfassungsklammern von links nach rechts gezählt werden). Die Klammern werden von 1 an gezählt, da cap(0) der gesamte übereinstimmende Regexp ist (gleichbedeutend mit '&' in den meisten Regexp-Engines).

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"

Hier haben wir die QRegExp an die Funktion replace() von QString übergeben, um den übereinstimmenden Text durch neuen Text zu ersetzen.

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
    }
}

Wir haben die Funktion indexIn() verwendet, um die Regexp in der Zeichenkette wiederholt abzugleichen. Beachten Sie, dass wir anstelle von pos++ auch pos += rx.matchedLength() hätten schreiben können, um die bereits übereinstimmende Zeichenkette zu überspringen, anstatt jeweils um ein Zeichen weiterzugehen. Die Zählung wird 3 ergeben, d.h. "Ein Eric, ein weiterer Eirik und ein Ericsson. Wie viele Eiriks, Eric?'; er passt nicht auf 'Ericsson' oder 'Eiriks', weil sie nicht durch Nicht-Wortgrenzen begrenzt sind.

Eine häufige Verwendung von Regexps ist die Aufteilung von Zeilen mit abgegrenzten Daten in ihre einzelnen Felder.

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);
}

In diesem Beispiel haben unsere Eingabezeilen das Format Firmenname, Webadresse und Land. Leider ist die Regexp ziemlich lang und nicht sehr vielseitig - der Code bricht ab, wenn wir weitere Felder hinzufügen. Eine einfachere und bessere Lösung ist die Suche nach dem Trennzeichen, in diesem Fall '\t', und die Übernahme des umgebenden Textes. Die Funktion QString::split() kann eine Trennzeichenfolge oder einen Regexp als Argument verwenden und eine Zeichenfolge entsprechend aufteilen.

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

Hier ist feld[0] das Unternehmen, feld[1] die Webadresse und so weiter.

Um das Matching einer Shell zu imitieren, können wir den Wildcard-Modus verwenden.

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

Wildcard-Matching kann wegen seiner Einfachheit praktisch sein, aber jeder Wildcard-Regexp kann mit vollständigen Regexps definiert werden, z. B. .*\.html$. Beachten Sie, dass wir mit einem Platzhalter nicht sowohl die Dateien .html als auch .htm abgleichen können, es sei denn, wir verwenden *.htm*, was auch mit "test.html.bak" übereinstimmen würde. Eine vollständige Regexp gibt uns die Präzision, die wir brauchen: .*\.html?$.

QRegExp kann Groß- und Kleinschreibung ignorieren ( setCaseSensitivity()), und es kann auch nicht-gierige Übereinstimmungen verwenden (siehe setMinimal()). Standardmäßig verwendet QRegExp vollständige Regexps, aber das kann mit setPatternSyntax() geändert werden. Die Suche kann vorwärts mit indexIn() oder rückwärts mit lastIndexIn() durchgeführt werden. Auf den erfassten Text kann mit capturedTexts() zugegriffen werden, das eine Liste aller erfassten Zeichenketten zurückgibt, oder mit cap(), das die erfasste Zeichenkette für den angegebenen Index zurückgibt. Die Funktion pos() nimmt einen Trefferindex und gibt die Position in der Zeichenkette zurück, an der der Treffer erzielt wurde (oder -1, wenn es keinen Treffer gab).

Portierung auf QRegularExpression

Die in Qt 5 eingeführte Klasse QRegularExpression implementiert Perl-kompatible reguläre Ausdrücke und ist eine große Verbesserung gegenüber QRegExp in Bezug auf die angebotenen APIs, die unterstützte Mustersyntax und die Ausführungsgeschwindigkeit. Der größte Unterschied besteht darin, dass QRegularExpression einfach einen regulären Ausdruck enthält, der nicht verändert wird, wenn eine Übereinstimmung angefordert wird. Stattdessen wird ein QRegularExpressionMatch Objekt zurückgegeben, um das Ergebnis einer Übereinstimmung zu überprüfen und die erfasste Teilzeichenkette zu extrahieren. Das Gleiche gilt für den globalen Abgleich und QRegularExpressionMatchIterator.

Weitere Unterschiede werden im Folgenden erläutert.

Unterschiedliche Mustersyntax

Das Portieren eines regulären Ausdrucks von QRegExp nach QRegularExpression kann Änderungen am Muster selbst erfordern.

In bestimmten Szenarien war QRegExp zu nachsichtig und akzeptierte Muster, die bei Verwendung von QRegularExpression einfach ungültig sind. Diese sind leicht zu erkennen, da die mit diesen Mustern erstellten QRegularExpression Objekte nicht gültig sind (siehe QRegularExpression::isValid()).

In anderen Fällen kann ein Muster, das von QRegExp auf QRegularExpression portiert wurde, die Semantik stillschweigend ändern. Daher ist es notwendig, die verwendeten Muster zu überprüfen. Die bemerkenswertesten Fälle von stiller Inkompatibilität sind:

• Geschweifte Klammern sind erforderlich, um einen hexadezimalen Escape wie \xHHHH mit mehr als 2 Ziffern zu verwenden. Ein Muster wie \x2022 muss auf \x{2022} portiert werden, oder es passt auf ein Leerzeichen (0x20) gefolgt von der Zeichenkette "22". Im Allgemeinen ist es sehr empfehlenswert, immer geschweifte Klammern mit dem \x Escape zu verwenden, unabhängig von der Anzahl der angegebenen Ziffern.
• Eine 0-zu-n-Quantifizierung wie {,n} muss auf {0,n} portiert werden, um die Semantik zu erhalten. Andernfalls würde ein Muster wie \d{,3} mit einer Ziffer übereinstimmen, gefolgt von der exakten Zeichenkette "{,3}".
• QRegExp führt standardmäßig eine Unicode-konforme Anpassung durch, während QRegularExpression eine separate Option erfordert; siehe unten für weitere Details.
• c{.} in QRegExp passt standardmäßig auf alle Zeichen, auch auf den Zeilenumbruch. QRegularExpression schließt den Zeilenumbruch standardmäßig aus. Um den Zeilenumbruch einzuschließen, setzen Sie die Option QRegularExpression::DotMatchesEverythingOption pattern.

Einen Überblick über die von QRegularExpression unterstützte Syntax regulärer Ausdrücke finden Sie in der Man Page pcrepattern(3), die die von PCRE (der Referenzimplementierung von Perl-kompatiblen regulären Ausdrücken) unterstützte Mustersyntax beschreibt.

Portierung von QRegExp::exactMatch()

QRegExp::exactMatch() diente zwei Zwecken: Sie glich einen regulären Ausdruck exakt mit einer Zeichenkette ab und implementierte eine teilweise Übereinstimmung.

Portierung von QRegExp's Exact Matching

Der exakte Abgleich gibt an, ob der reguläre Ausdruck mit der gesamten Zeichenkette übereinstimmt. Die Klassen ergeben zum Beispiel die Zeichenkette "abc123":

Eine exakte Übereinstimmung wird in QRegularExpression nicht wiedergegeben. Wenn Sie sicher sein wollen, dass die Betreffzeichenkette genau mit dem regulären Ausdruck übereinstimmt, können Sie das Muster mit der Funktion QRegularExpression::anchoredPattern() einschließen:

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

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

Portierung von QRegExp's partiellem Matching

Wenn bei der Verwendung von QRegExp::exactMatch() keine exakte Übereinstimmung gefunden wurde, konnte man durch den Aufruf von QRegExp::matchedLength() immer noch herausfinden, wie viel der Betreffzeichenkette mit dem regulären Ausdruck übereinstimmte. Wenn die zurückgegebene Länge gleich der Länge der Zeichenkette war, konnte man daraus schließen, dass eine teilweise Übereinstimmung gefunden wurde.

QRegularExpression unterstützt partielle Übereinstimmungen explizit durch die entsprechende QRegularExpression::MatchType.

Globaler Abgleich

Aufgrund der Beschränkungen der QRegExp-API war es nicht möglich, globale Übereinstimmungen korrekt zu implementieren (also so, wie es Perl tut). Insbesondere Muster, die mit 0 Zeichen übereinstimmen können (wie "a*"), sind problematisch.

QRegularExpression::globalMatch() implementiert den globalen Abgleich in Perl korrekt, und der zurückgegebene Iterator kann verwendet werden, um jedes Ergebnis zu untersuchen.

Wenn Sie zum Beispiel einen Code wie:

QString subject("the quick fox");

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

Sie können ihn umschreiben als:

QString subject("the quick fox");

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

Unterstützung von Unicode-Eigenschaften

Bei der Verwendung von QRegExp passen Zeichenklassen wie \w, \d usw. auf Zeichen mit der entsprechenden Unicode-Eigenschaft: \d passt zum Beispiel auf jedes Zeichen mit der Unicode-Eigenschaft Nd (Dezimalziffer).

Diese Zeichenklassen passen standardmäßig nur auf ASCII-Zeichen, wenn QRegularExpression verwendet wird: \d passt beispielsweise genau auf ein Zeichen im 0-9 ASCII-Bereich. Es ist möglich, dieses Verhalten mit der Option QRegularExpression::UseUnicodePropertiesOption pattern zu ändern.

Wildcard-Abgleich

Es gibt keine direkte Möglichkeit, Wildcard-Matches in QRegularExpression durchzuführen. QRegularExpression::wildcardToRegularExpression() bietet jedoch die Möglichkeit, glob-Muster in einen Perl-kompatiblen regulären Ausdruck zu übersetzen, der für diesen Zweck verwendet werden kann.

Wenn Sie zum Beispiel Code haben wie:

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

Sie können ihn umschreiben als:

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

Bitte beachten Sie jedoch, dass einige Shell-ähnliche Wildcard-Muster möglicherweise nicht so übersetzt werden, wie Sie es erwarten. Der folgende Beispielcode bricht stillschweigend ab, wenn er einfach mit der oben erwähnten Funktion umgewandelt wird:

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

Das liegt daran, dass der reguläre Ausdruck, der von QRegularExpression::wildcardToRegularExpression() zurückgegeben wird, standardmäßig vollständig verankert ist. Um einen regulären Ausdruck zu erhalten, der nicht verankert ist, übergeben Sie QRegularExpression::UnanchoredWildcardConversion als Konvertierungsoptionen:

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

Minimale Übereinstimmung

QRegExp::setMinimal() implementierte die minimale Übereinstimmung, indem es einfach die Gierigkeit der Quantoren umkehrte (QRegExp unterstützte keine faulen Quantoren, wie *?, +?, usw.). QRegularExpression unterstützt stattdessen gierige, faule und besitzanzeigende Quantoren. Die Option QRegularExpression::InvertedGreedinessOption pattern kann nützlich sein, um die Auswirkungen von QRegExp::setMinimal() zu emulieren: Wenn sie aktiviert ist, kehrt sie die Gierigkeit von Quantoren um (gierige Quantoren werden faul und umgekehrt).

Caret-Modi

Die Option QRegularExpression::AnchorAtOffsetMatchOption match kann verwendet werden, um das Verhalten von QRegExp::CaretAtOffset zu emulieren. Es gibt keine Entsprechung für die anderen QRegExp::CaretMode Modi.