QRegExp Class

Ausführliche Beschreibung

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

Ein regulärer Ausdruck, auch „regexp“ genannt, ist ein Muster zum Abgleichen von Teilzeichenfolgen in einem Text. Dies ist in vielen Kontexten nützlich, z. B.

Es wird eine kurze Einführung in reguläre Ausdrücke gegeben, eine Beschreibung der regulären Ausdruckssprache von Qt, einige Beispiele sowie die Funktionsdokumentation selbst. QRegExp orientiert sich an der regulären Ausdruckssprache von Perl. Es unterstützt Unicode vollständig. QRegExp kann auch in einem einfacheren Modus mit Platzhaltern verwendet werden, der der Funktionalität in Befehlsshells ähnelt. 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 abzugleichende Muster als einfache Zeichenkette interpretiert wird, d. h., Sonderzeichen (z. B. Backslash) werden nicht maskiert.

Ein gutes Buch zum Thema reguläre Ausdrücke ist „Mastering Regular Expressions“ (3. Auflage) von Jeffrey E. F. Friedl, ISBN 0-596-52812-4.

Sicherheitshinweise

QRegExp legt keine Begrenzung für die Ressourcen fest, die ein Muster beanspruchen darf, und die Größe seiner internen Puffer kann zu einem Überlauf führen. Ein relativ kleines, gezielt gestaltetes Muster kann daher den verfügbaren Speicher erschöpfen, einen Stapelüberlauf verursachen oder den Speicher beschädigen. Dies geschieht während der Kompilierung des Musters, d. h. sobald das Muster zugewiesen wird, und erfordert keine Textübereinstimmung. Dasselbe gilt für „ wildcard “-Muster, die intern in reguläre Ausdrücke übersetzt werden.

Verwenden Sie QRegExp nur mit Mustern aus einer vertrauenswürdigen Quelle. Verwenden Sie stattdessen vorzugsweise „ QRegularExpression “, wodurch die Ressourcen begrenzt werden, die ein Abgleich verbrauchen darf.

Einführung

Regexps setzen sich aus Ausdrücken, Quantifikatoren und Assertionen zusammen. Der einfachste Ausdruck ist ein Zeichen, z. B. x oder 5. Ein Ausdruck kann auch eine in eckige Klammern gesetzte Zeichenfolge sein. [ABCD] passt auf ein A oder ein B oder ein C oder ein D. Denselben Ausdruck können wir auch als [A-D] schreiben, und ein Ausdruck, der auf jeden Großbuchstaben des englischen Alphabets passt, lautet [A-Z].

Ein Quantifikator gibt die Anzahl der Vorkommen eines Ausdrucks an, die abgeglichen werden müssen. x{1,1} bedeutet, dass genau ein x abgeglichen wird. x{1,5} bedeutet, dass eine Folge von x-Zeichen abgeglichen wird, die mindestens ein x, aber nicht mehr als fünf enthält.

Beachten Sie, dass reguläre Ausdrücke im Allgemeinen nicht zur Überprüfung auf ausgeglichene Klammern oder Tags verwendet werden können. Beispielsweise kann ein regulärer Ausdruck so geschrieben werden, dass er mit einem öffnenden HTML- <b> -Tag und dessen schließendem </b>-Tag übereinstimmt, sofern die <b> -Tags nicht verschachtelt sind; sind die <b> -Tags jedoch verschachtelt, wird derselbe reguläre Ausdruck mit einem öffnenden <b> -Tag und dem falschen schließenden </b>-Tag übereinstimmen. Für das Fragment <b>bold <b>bolder</b></b> würde das erste <b> mit dem ersten </b> abgeglichen werden, was nicht korrekt ist. Es ist jedoch möglich, einen regulären Ausdruck zu schreiben, der verschachtelte Klammern oder Tags korrekt abgleicht – allerdings nur, wenn die Anzahl der Verschachtelungsebenen feststeht und bekannt ist. Ist die Anzahl der Verschachtelungsebenen nicht feststehend und bekannt, ist es unmöglich, einen regulären Ausdruck zu schreiben, der nicht fehlschlägt.

Angenommen, wir möchten einen regulären Ausdruck erstellen, der auf ganze Zahlen im Bereich von 0 bis 99 passt. Da mindestens eine Ziffer erforderlich ist, beginnen wir mit dem Ausdruck [0-9]{1,1}, der genau einmal auf eine einzelne Ziffer passt. Dieser reguläre Ausdruck passt auf ganze Zahlen im Bereich von 0 bis 9. Um ganze Zahlen bis einschließlich 99 zu finden, erhöht man die maximale Anzahl der Vorkommen auf 2, sodass der reguläre Ausdruck zu [0-9]{1,2} wird. Dieser reguläre Ausdruck erfüllt die ursprüngliche Anforderung, ganze Zahlen von 0 bis 99 zu finden, findet jedoch auch ganze Zahlen, die in der Mitte von Zeichenketten vorkommen. Wenn die gefundene Ziffer die gesamte Zeichenkette umfassen soll, müssen wir die Ankerzeichen ^ (Caret) und $ (Dollar) verwenden. Steht ^ als erstes Zeichen in einem regulären Ausdruck, bedeutet dies, dass der Ausdruck vom Anfang der Zeichenkette an übereinstimmen muss. Ist $ das letzte Zeichen des regulären Ausdrucks, bedeutet dies, dass der reguläre Ausdruck bis zum Ende der Zeichenkette übereinstimmen muss. Der reguläre Ausdruck lautet dann ^[0-9]{1,2}$. Beachten Sie, dass Ankerzeichen wie ^ und $ keine Zeichen, sondern Positionen in der Zeichenkette angeben.

Falls Sie an anderer Stelle Beschreibungen von regulären Ausdrücken gesehen haben, sahen diese möglicherweise anders aus als die hier gezeigten. Das liegt daran, dass bestimmte Zeichenmengen und Quantoren so häufig vorkommen, dass ihnen spezielle Symbole zugewiesen wurden, um sie darzustellen. [0-9] kann durch das Symbol \dersetzt werden. Der Quantifikator für genau ein Vorkommen, {1,1}, kann durch den Ausdruck selbst ersetzt werden, d. h. x{1,1} ist dasselbe wie x. Unser Matcher für 0 bis 99 könnte also wie folgt geschrieben werden : ^\d{1,2}$. Er kann auch wie folgt geschrieben werden : ^\d\d {0,1}$, d. h . ab dem Anfang der Zeichenkette soll eine Ziffer gefunden werden, unmittelbar gefolgt von 0 oder 1 Ziffern. In der Praxis würde man ihn als ^\d\d ?$ schreiben . Das „?“ ist eine Kurzform für den Quantifikator {0,1}, d. h. 0 oder 1 Vorkommen. „?“ macht einen Ausdruck optional. Der reguläre Ausdruck ^\d\d ?$ bedeutet : Ab dem Anfang der Zeichenkette soll eine Ziffer gefunden werden, unmittelbar gefolgt von 0 oder 1 weiteren Ziffern, unmittelbar gefolgt vom Ende der Zeichenkette.

Um einen regulären Ausdruck zu schreiben, der mit einem der Wörter „mail“ , „letter“ oder „correspondence“ übereinstimmt, jedoch nicht mit Wörtern, die diese Wörter enthalten, z. B. „email“, „mailman“, „mailer“ und „letterbox“, beginne mit einem regulären Ausdruck, der mit „mail“ übereinstimmt. Vollständig ausgedrückt lautet der reguläre Ausdruck 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 den regulären Ausdruck auf „mail“ vereinfachen, d. h. ein „m“, gefolgt von einem „a“, gefolgt von einem „i“, gefolgt von einem „l“. Nun können wir den senkrechten Strich |, der „oder“ bedeutet, verwenden, um die beiden anderen Wörter einzubeziehen, sodass unser regulärer Ausdruck zum Abgleichen eines der drei Wörter zu „mail|letter|correspondence“ wird. Suche nach „mail“ oder „letter“ oder „correspondence“. Dieser reguläre Ausdruck findet zwar eines der drei Wörter, die wir suchen, aber er findet auch Wörter, die wir nicht suchen, z. B. „email“. Um zu verhindern, dass der reguläre Ausdruck unerwünschte Wörter findet, müssen wir ihm mitteilen, dass die Suche an Wortgrenzen beginnen und enden soll. Zunächst setzen wir unseren regulären Ausdruck in Klammern: (mail|letter|correspondence). Klammern gruppieren Ausdrücke und kennzeichnen einen Teil des regulären Ausdrucks, den wir „ capture “ möchten. Durch das Einfassen des Ausdrucks in Klammern können wir ihn als Bestandteil komplexerer regulärer Ausdrücke verwenden. Außerdem können wir so überprüfen, welches der drei Wörter tatsächlich gefunden wurde. Um zu erzwingen, dass die Übereinstimmung an Wortgrenzen beginnt und endet, setzen wir den regulären Ausdruck in \bWortgrenzen-Assertionen ein: \b(mail|letter|correspondence)\b. Nun bedeutet der reguläre Ausdruck: Finde eine Wortgrenze, gefolgt vom Ausdruck in Klammern, gefolgt von einer Wortgrenze. Die \b Assertion passt auf eine Position im regulären Ausdruck, nicht auf ein Zeichen. Eine Wortgrenze ist jedes Nicht-Wort-Zeichen, z. B. ein Leerzeichen, ein Zeilenumbruch oder der Anfang bzw. das Ende einer Zeichenkette.

Wenn wir das Und-Zeichen durch die HTML-Entität & ersetzen wollen, lautet der zu suchende reguläre Ausdruck einfach &. Dieser reguläre Ausdruck findet jedoch auch Und-Zeichen, die bereits in HTML-Entitäten umgewandelt wurden. Wir möchten nur „&“-Zeichen ersetzen, auf die nicht bereits „amp;“ folgt. Dazu benötigen wir die negative Vorausschau-Bedingung (?!__). Der reguläre Ausdruck lässt sich dann als &(?!amp;) schreiben, d. h. er passt auf ein „&“-Zeichen, auf das kein „amp;“ folgt.

Wenn wir alle Vorkommen von „Eric“ und „Eirik“ in einer Zeichenkette zählen wollen, gibt es zwei gültige Lösungen: \b(Eric|Eirik)\b und \bEi?ri[ck]\b. Die Wortgrenzen-Assertion „\b “ ist erforderlich, um zu vermeiden, dass Wörter gefunden werden, die einen der beiden Namen enthalten, z. B. „Ericsson“. Beachten Sie, dass der zweite reguläre Ausdruck mehr Schreibweisen findet, als wir möchten: „Eric“, „Erik“, „Eiric“ und „Eirik“.

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

Zeichen und Abkürzungen für Zeichenmengen

Hinweis: Der C++-Compiler wandelt Backslashes in Zeichenketten um. Um ein \ in einem regulären Ausdruck einzufügen, geben Sie es zweimal ein, d. h. \\. Um das Backslash-Zeichen selbst zu finden, geben Sie es viermal ein, d. h. \\\\.

Zeichenmengen

Eckige Klammern bedeuten, dass jedes darin enthaltene Zeichen gefunden werden soll. Die oben beschriebenen Zeichenmengenabkürzungen können in einer Zeichenmenge in eckigen Klammern vorkommen. Abgesehen von den Zeichenmengenabkürzungen und den folgenden zwei Ausnahmen haben Zeichen in eckigen Klammern keine besondere Bedeutung.

Die Verwendung der vordefinierten Zeichenmengen-Abkürzungen ist plattform- und sprachübergreifend portabler als die Verwendung von Zeichenbereichen. Beispielsweise passt [0-9] auf eine Ziffer in westlichen Alphabeten, während \d entspricht einer Ziffer in jedem beliebigen Alphabet.

Hinweis: In anderen Dokumentationen zu regulären Ausdrücken werden Zeichenmengen oft als „Zeichenklassen“ bezeichnet.

Quantifizierer

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

Um einen Quantor nicht nur auf das vorangehende Zeichen anzuwenden, gruppieren Sie Zeichen in einem Ausdruck mithilfe von Klammern. Beispielsweise findet „tag+“ ein „t“, gefolgt von einem „a“ und mindestens einem „g“, während „(tag)+“ mindestens ein Vorkommen von „tag“ findet.

Hinweis: Quantoren sind normalerweise „gierig“. Sie finden immer so viel Text wie möglich. Beispielsweise findet 0+ die erste Null, die sie finden, sowie alle darauf folgenden Nullen. Auf „20005“ angewendet, ergibt dies„20005“. Quantoren können nicht-gierig gemacht werden, siehe setMinimal().

Text erfassen

Klammern ermöglichen es uns, Elemente zu gruppieren, damit wir sie quantifizieren und erfassen können. Wenn wir beispielsweise den Ausdruck „mail|letter|correspondence“ haben, der mit einer Zeichenkette übereinstimmt, wissen wir, dass eines der Wörter übereinstimmt, aber nicht, welches. Durch die Verwendung von Klammern können wir alles „erfassen“, was innerhalb ihrer Grenzen übereinstimmt. Wenn wir also (mail|letter|correspondence) verwenden und diesen regulären Ausdruck 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 des regulären Ausdrucks selbst verwenden. Um auf den erfassten Text zu verweisen, verwenden wir Rückverweise, die wie bei ` cap()` ab 1 indiziert sind. Beispielsweise könnten wir mit „\b “ nach doppelten Wörtern in einer Zeichenkette suchen : (\w+)\W+\1\b . Das bedeutet, dass nach einer Wortgrenze gesucht wird, gefolgt von einem oder mehreren Wortzeichen, gefolgt von einem oder mehreren Nicht-Wortzeichen, gefolgt von demselben Text wie im ersten Ausdruck in Klammern, gefolgt von einer Wortgrenze.

Wenn wir Klammern ausschließlich zum Gruppieren und nicht zum Erfassen verwenden möchten, können wir die Syntax ohne Erfassung nutzen, z. B. (?:green|blue). Klammern ohne Erfassung beginnen mit „(?:“ und enden mit „)“. In diesem Beispiel suchen wir entweder nach „green“ oder „blue“, erfassen das Suchergebnis jedoch nicht, sodass wir nur wissen, ob ein Treffer vorliegt oder nicht, nicht aber, welche Farbe tatsächlich gefunden wurde. Die Verwendung von nicht-erfassenden Klammern ist effizienter als die Verwendung von erfassenden Klammern, da die Regexp-Engine weniger Verwaltungsaufwand betreiben muss.

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

Aus historischen Gründen sind Quantoren (z. B. *), die auf erfassende Klammern angewendet werden, „gieriger“ als andere Quantoren. Beispielsweise passt „a*(a*)“ auf „aaa“ mit `cap(1) == "aaa"`. Dieses Verhalten unterscheidet sich von dem anderer Regexp-Engines (insbesondere Perl). Um ein intuitiveres Erfassungsverhalten zu erzielen, geben Sie ` QRegExp::RegExp2 ` im QRegExp-Konstruktor an oder rufen Sie ` setPatternSyntax` auf (QRegExp::RegExp2).

Wenn die Anzahl der Übereinstimmungen nicht im Voraus bestimmt werden kann, ist es üblich, ` 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"]

Aussagen

Assertions geben an der Stelle, an der sie im regulären Ausdruck vorkommen, eine Aussage über den Text ab, passen jedoch nicht auf bestimmte Zeichen. In der folgenden Liste steht E für einen beliebigen Ausdruck.

Platzhalter-Abgleich

Die meisten Befehlsshells wie bash oder cmd.exe unterstützen „File Globbing“, also die Möglichkeit, eine Gruppe von Dateien mithilfe von Platzhaltern zu identifizieren. Mit der Funktion setPatternSyntax() kann zwischen dem Regexp- und dem Platzhaltermodus gewechselt werden. Der Platzhalterabgleich ist wesentlich einfacher als vollständige reguläre Ausdrücke und verfügt nur über vier Funktionen:

Im Modus „Wildcard“ können die Platzhalterzeichen nicht mit einem Escape-Zeichen versehen werden. Im Modus „ WildcardUnix “ dient das Zeichen „\“ als Escape-Zeichen für den Platzhalter.

Befinden wir uns beispielsweise im Wildcard-Modus und haben Zeichenfolgen, die Dateinamen enthalten, könnten wir HTML-Dateien mit *.html identifizieren. Dies entspricht null oder mehr Zeichen, gefolgt von einem Punkt und anschließend den Zeichen „h“, „t“, „m“ und „l“.

Um eine Zeichenkette anhand eines Platzhalterausdrucks zu prüfen, verwenden Sie ` exactMatch()`. 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 von Perl unterstützten Abkürzungen für Zeichenklassen werden auch von QRegExp unterstützt, siehe characters and abbreviations for sets of characters.

In QRegExp bedeutet „ ^ “ – außer innerhalb von Zeichenklassen – immer den Anfang der Zeichenkette, daher müssen Carets immer mit einem Escape-Zeichen versehen werden, sofern sie nicht zu diesem Zweck verwendet werden. In Perl ändert sich die Bedeutung des Carets automatisch je nach Kontext, sodass ein Escape-Zeichen selten erforderlich ist. Dasselbe gilt für „ $ “, das in QRegExp immer das Ende der Zeichenkette bedeutet.

Die Quantoren von QRegExp entsprechen den „greedy“-Quantoren von Perl (siehe jedoch „ note above “). Nicht-greedy-Abgleichen können nicht auf einzelne Quantoren angewendet werden, wohl aber auf alle Quantoren im Muster. Um beispielsweise den Perl-Regexp „ro+?m“ abzugleichen, ist Folgendes erforderlich:

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

Das Äquivalent zur Perl-Option „ /i “ ist „ setCaseSensitivity “ (Qt::CaseInsensitive).

Die Perl-Option „ /g “ lässt sich mithilfe von „ loop “ nachbilden.

In QRegExp steht „.“ für ein beliebiges Zeichen, daher verfügen alle QRegExp-Regulären Ausdrücke über eine Entsprechung zur Perl-Option „ /s “. QRegExp verfügt über keine Entsprechung zur Perl-Option „ /m “, dies lässt sich jedoch auf verschiedene Weise emulieren, beispielsweise durch Aufteilen der Eingabe in Zeilen oder durch eine Schleife mit einem regulären Ausdruck, der nach Zeilenumbrüchen sucht.

Da QRegExp zeichenfolgenorientiert ist, gibt es keine Assertions wie „ \A “, „ \Z “ oder „ \z “. Die Assertion „ \G “ wird nicht unterstützt, kann aber in einer Schleife nachgebildet werden.

Perls $& entspricht cap(0) oder capturedTexts()[0]. Es gibt keine QRegExp-Entsprechungen für $`, $' oder $+. Perls Erfassungsvariablen $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 Syntax von Perl für reguläre Ausdrücke ( /x ) 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 Literalzeichenfolgen verwendet werden, um dasselbe zu erreichen:

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

Sowohl positive als auch negative Lookahead-Prüfungen mit Nullbreite (?=Muster) und (?!Muster) werden mit derselben Syntax wie in Perl unterstützt. Perls Lookbehind-Prüfungen, „unabhängige“ Unterausdrücke und bedingte Ausdrücke werden nicht unterstützt.

Nicht-erfassende Klammern werden ebenfalls unterstützt, und zwar mit derselben Syntax (?:Muster).

Siehe QString::split() und QStringList::join() für Entsprechungen zu den Perl-Funktionen „split“ und „join“.

Hinweis: Da C++ \-Zeichen umwandelt, müssen diese im Code doppelt geschrieben werden, z. B. \b muss als \\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 Zeichenkette stimmtmit „6“ überein. Dies ist ein einfacher regulärer Ausdruck zur Validierung von Ganzzahlen 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 stimmt mit„This_is-OK“ überein. Wir haben die Zeichenabkürzung „\S “ (keine Leerzeichen) und die Anker verwendet, um Zeichenfolgen zu finden, die keine Leerzeichen enthalten.

Im folgenden Beispiel suchen wir nach Zeichenfolgen, die „mail“, „letter“ oder „correspondence“ enthalten, wobei jedoch nur ganze Wörter berücksichtigt werden, d. h. nicht „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 passt auf „Bitte schreibe den Brief“. Das Wort „Brief“ wird ebenfalls erfasst (aufgrund der Klammern). So können wir sehen, welchen Text wir erfasst haben:

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

Dadurch wird der Text aus dem ersten Satz von Erfassungs-Klammern erfasst (wobei die linken Erfassungs-Klammern von links nach rechts gezählt werden). Die Klammern werden ab 1 gezählt, da cap(0) den gesamten übereinstimmenden regulären Ausdruck darstellt (entspricht in den meisten Regex-Engines dem Zeichen „&“).

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 das QRegExp an die replace()-Funktion 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 den regulären Ausdruck wiederholt in der Zeichenkette abzugleichen. Beachten Sie, dass wir, anstatt jeweils um ein Zeichen vorwärts zu gehen (` pos++ `), auch ` pos += rx.matchedLength() ` hätten schreiben können, um die bereits gefundene Zeichenkette zu überspringen. Die Anzahl entspricht dann 3, was dem Ausdruck „One Eric another Eirik, and an Ericsson. Wie viele Eiriks, Eric?'; „Ericsson“ oder „Eiriks“ werden nicht gefunden, da sie nicht von Nicht-Wortgrenzen umschlossen sind.

Eine häufige Anwendung von regulären Ausdrücken besteht darin, Zeilen mit durch Trennzeichen getrennten Daten in ihre einzelnen Felder aufzuteilen.

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 der reguläre Ausdruck ziemlich lang und nicht sehr flexibel – der Code funktioniert nicht mehr, wenn wir weitere Felder hinzufügen. Eine einfachere und bessere Lösung besteht darin, nach dem Trennzeichen zu suchen – in diesem Fall „\t “ – und den umgebenden Text zu extrahieren. Die Funktion „ QString::split()“ kann eine Trennzeichenfolge oder einen regulären Ausdruck als Argument entgegennehmen und eine Zeichenkette entsprechend aufteilen.

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

Hier ist field[0] der Firmenname, field[1] die Webadresse und so weiter.

Um das Matching einer Shell nachzuahmen, 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

Der Wildcard-Abgleich kann aufgrund seiner Einfachheit praktisch sein, aber jeder Wildcard-Regexp lässt sich auch mit vollständigen Regexps definieren, z. B. .*\.html$. Beachten Sie, dass wir mit einem Platzhalter nicht sowohl auf „ .html “- als auch auf „ .htm “-Dateien abgleichen können, es sei denn, wir verwenden „*.htm*“, was dann aber auch auf „test.html.bak“ zutrifft. Ein vollständiger regulärer Ausdruck bietet uns die benötigte Präzision: „.*\.html?$“.

QRegExp kann mit setCaseSensitivity() groß- und kleinschreibungsunabhängig abgleichen und nicht-gieriges Abgleichen verwenden, siehe setMinimal(). Standardmäßig verwendet QRegExp vollständige reguläre Ausdrücke, dies lässt sich jedoch mit setPatternSyntax() ändern. Die Suche kann vorwärts mit indexIn() oder rückwärts mit lastIndexIn() erfolgen. Auf erfasste Textteile kann mit „ capturedTexts “ () zugegriffen werden, was eine Zeichenfolgenliste aller erfassten Zeichenfolgen zurückgibt, oder mit „ cap “ (), was die erfasste Zeichenfolge für den angegebenen Index zurückgibt. Die Funktion „ pos “ () nimmt einen Übereinstimmungsindex entgegen und gibt die Position in der Zeichenfolge zurück, an der die Übereinstimmung gefunden wurde (oder -1, falls keine Übereinstimmung vorlag).

Portierung auf QRegularExpression

Die in Qt 5 eingeführte Klasse „ QRegularExpression “ implementiert Perl-kompatible reguläre Ausdrücke und stellt hinsichtlich der angebotenen APIs, der unterstützten Mustersyntax und der Ausführungsgeschwindigkeit eine erhebliche Verbesserung gegenüber QRegExp dar. Der größte Unterschied besteht darin, dass ` QRegularExpression ` lediglich einen regulären Ausdruck enthält und bei einer Übereinstimmungsanfrage nicht verändert wird. Stattdessen wird ein ` QRegularExpressionMatch `-Objekt zurückgegeben, um das Ergebnis einer Übereinstimmung zu überprüfen und die erfasste Teilzeichenfolge zu extrahieren. Dasselbe gilt für globale Übereinstimmungen und ` QRegularExpressionMatchIterator`.

Weitere Unterschiede werden im Folgenden beschrieben.

Unterschiedliche Mustersyntax

Die Portierung eines regulären Ausdrucks von QRegExp nach QRegularExpression erfordert möglicherweise Änderungen am Muster selbst.

In bestimmten Szenarien war QRegExp zu nachsichtig und akzeptierte Muster, die bei der Verwendung von „ QRegularExpression “ schlichtweg ungültig sind. Diese lassen sich leicht erkennen, da die mit diesen Mustern erstellten „ QRegularExpression “-Objekte ungültig sind (siehe QRegularExpression::isValid()).

In anderen Fällen kann sich die Semantik eines von QRegExp nach ` QRegularExpression ` portierten Musters unbemerkt ändern. Daher ist es notwendig, die verwendeten Muster zu überprüfen. Die auffälligsten Fälle von stillschweigender Inkompatibilität sind:

• Für die Verwendung eines hexadezimalen Escape-Zeichens wie \xHHHH mit mehr als zwei Ziffern sind geschweifte Klammern erforderlich. Ein Muster wie \x2022 muss in \x{2022} portiert werden, da es sonst mit einem Leerzeichen (0x20) gefolgt von der Zeichenkette "22" übereinstimmt. Generell wird dringend empfohlen, beim Escape-Zeichen \x stets geschweifte Klammern zu verwenden, unabhängig von der Anzahl der angegebenen Ziffern.
• Eine 0-bis-n-Quantifizierung wie „ {,n} “ muss in „ {0,n} “ umgewandelt werden, um die Semantik beizubehalten. Andernfalls würde ein Muster wie „ \d{,3} “ auf eine Ziffer gefolgt von genau der Zeichenfolge „ "{,3}" “ passen.
• QRegExp führt standardmäßig eine Unicode-bewusste Übereinstimmungssuche durch, während QRegularExpression eine separate Option erfordert; weitere Details finden Sie weiter unten.
• c{.} in QRegExp passt standardmäßig auf alle Zeichen, einschließlich des Zeilenumbruchzeichens. QRegularExpression schließt das Zeilenumbruchzeichen standardmäßig aus. Um das Zeilenumbruchzeichen einzubeziehen, setzen Sie die Musteroption „ QRegularExpression::DotMatchesEverythingOption “.

Einen Überblick über die von QRegularExpression unterstützte Syntax für reguläre Ausdrücke finden Sie in der Manpage pcrepattern(3), in der die von PCRE (der Referenzimplementierung für Perl-kompatible reguläre Ausdrücke) unterstützte Mustersyntax beschrieben wird.

Portierung von QRegExp::exactMatch()

QRegExp::exactMatch() erfüllte zwei Zwecke: Es führte einen exakten Abgleich eines regulären Ausdrucks mit einer Zielzeichenfolge durch und implementierte den partiellen Abgleich.

Portierung aus dem exakten Abgleich von QRegExp

Der exakte Abgleich gibt an, ob der reguläre Ausdruck mit der gesamten Zielzeichenfolge übereinstimmt. Beispielsweise liefern die Klassen für die Zielzeichenfolge „ "abc123" “ folgende Ergebnisse:

Eine exakte Übereinstimmung wird in ` QRegularExpression` nicht berücksichtigt. Wenn Sie sicherstellen möchten, dass die Suchzeichenfolge exakt mit dem regulären Ausdruck übereinstimmt, können Sie das Muster mit der Funktion ` QRegularExpression::anchoredPattern()` umschließen:

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

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

Portierung aus dem Bereich „Partial Matching“ von QRegExp

Bei der Verwendung von ` QRegExp::exactMatch()` kann man, falls keine exakte Übereinstimmung gefunden wurde, dennoch herausfinden, wie viel der Suchzeichenfolge durch den regulären Ausdruck abgedeckt wurde, indem man ` QRegExp::matchedLength()` aufruft. Wenn die zurückgegebene Länge der Länge der Suchzeichenfolge entspricht, kann man daraus schließen, dass eine teilweise Übereinstimmung gefunden wurde.

QRegularExpression unterstützt das partielle Abgleichen explizit mithilfe des entsprechenden QRegularExpression::MatchType.

Globale Übereinstimmung

Aufgrund von Einschränkungen der QRegExp-API war es nicht möglich, den globalen Abgleich korrekt zu implementieren (d. h. so wie es Perl tut). Insbesondere sind Muster, die 0 Zeichen abgleichen können (wie "a*"), problematisch.

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

Wenn Sie beispielsweise folgenden Code haben:

QString subject("the quick fox");

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

können Sie ihn wie folgt umschreiben:

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 finden Zeichenklassen wie \w, \d usw. Zeichen mit der entsprechenden Unicode-Eigenschaft: So passt beispielsweise \d auf jedes Zeichen mit der Unicode-Eigenschaft „ Nd “ (Dezimalziffer).

Diese Zeichenklassen finden standardmäßig nur Übereinstimmungen mit ASCII-Zeichen, wenn „ QRegularExpression “ verwendet wird: So findet beispielsweise „ \d “ genau ein Zeichen im ASCII-Bereich „ 0-9 “. Dieses Verhalten lässt sich durch die Verwendung der Musteroption „ QRegularExpression::UseUnicodePropertiesOption “ ändern.

Platzhalterabgleich

Es gibt in „ QRegularExpression “ keine direkte Möglichkeit, Platzhalterabgleiche durchzuführen. Es steht jedoch die Methode ` QRegularExpression::wildcardToRegularExpression()` zur Verfügung, um „glob“-Muster in einen Perl-kompatiblen regulären Ausdruck zu übersetzen, der für diesen Zweck verwendet werden kann.

Wenn Sie beispielsweise folgenden Code haben:

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

können Sie ihn wie folgt umschreiben:

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

Bitte beachten Sie jedoch, dass einige Shell-ähnliche Platzhaltermuster möglicherweise nicht wie erwartet übersetzt werden. Der folgende Beispielcode führt zu einem stillen Fehler, wenn er einfach mit der oben genannten Funktion konvertiert 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

Dies liegt daran, dass der von ` QRegularExpression::wildcardToRegularExpression()` zurückgegebene reguläre Ausdruck 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 minimale Übereinstimmung, indem es einfach die „Gier“ der Quantoren umkehrte (QRegExp unterstützte keine „lazy“-Quantoren wie *?, +? usw.). QRegularExpression unterstützt hingegen „greedy“, „lazy“ und „possessive“ Quantoren. Die Musteroption „ QRegularExpression::InvertedGreedinessOption “ kann nützlich sein, um die Effekte von ` QRegExp::setMinimal()` nachzubilden: Wenn sie aktiviert ist, kehrt sie die „Gier“ der Quantoren um (gierige werden zu „lazy“ und umgekehrt).

Caret-Modi

Die Abgleichoption „ QRegularExpression::AnchorAtOffsetMatchOption “ kann verwendet werden, um das Verhalten von „ QRegExp::CaretAtOffset “ nachzubilden. Für die anderen „ QRegExp::CaretMode “-Modi gibt es keine Entsprechung.