QRegExp Class

Description détaillée

Cette classe est obsolète dans Qt 6. Veuillez utiliser QRegularExpression à la place pour tout nouveau code. Pour des directives sur le portage de l'ancien code de QRegExp vers QRegularExpression, voir {Portage vers QRegularExpression}.

Une expression régulière, ou "regexp", est un modèle permettant de faire correspondre des sous-chaînes dans un texte. Elle est utile dans de nombreux contextes, par exemple,

Une brève introduction aux regexps est présentée, ainsi qu'une description du langage regexp de Qt, quelques exemples et la documentation de la fonction elle-même. QRegExp s'inspire du langage de regexp de Perl. Il supporte entièrement l'Unicode. QRegExp peut également être utilisé dans un mode plus simple, avec des caractères de remplacement, qui est similaire à la fonctionnalité trouvée dans les shells de commande. Les règles syntaxiques utilisées par QRegExp peuvent être modifiées à l'aide de setPatternSyntax(). En particulier, la syntaxe du motif peut être définie à QRegExp::FixedString, ce qui signifie que le motif à rechercher est interprété comme une chaîne de caractères simple, c'est-à-dire que les caractères spéciaux (par exemple, la barre oblique inverse) ne sont pas échappés.

Un bon texte sur les regexps est Mastering Regular Expressions (Third Edition) de Jeffrey E. F. Friedl, ISBN 0-596-52812-4.

Introduction

Les regexps sont construites à partir d'expressions, de quantificateurs et d'assertions. L'expression la plus simple est un caractère, par exemple x ou 5. Une expression peut également être un ensemble de caractères entre crochets. [ ABCD] correspondra à un A, un B, un C ou un D. Nous pouvons écrire cette même expression sous la forme [A-D], et une expression correspondant à n'importe quelle lettre majuscule de l'alphabet anglais s'écrit [A-Z].

Un quantificateur précise le nombre d'occurrences d'une expression qui doivent être prises en compte. x{1,1} signifie qu'il faut prendre en compte un et un seul x. x{1,5} signifie qu'il faut prendre en compte une séquence de x caractères contenant au moins un x mais pas plus de cinq.

Notez qu'en général, les expressions rationnelles ne peuvent pas être utilisées pour vérifier la présence de parenthèses équilibrées ou de balises. Par exemple, une expression rationnelle peut être écrite pour faire correspondre une ouverture html <b> et sa fermeture </b>, si les balises <b> ne sont pas imbriquées, mais si les balises <b> sont imbriquées, cette même expression rationnelle fera correspondre une ouverture <b> avec une fermeture erronée </b>. Pour le fragment <b>bold <b>bolder</b></b>, le premier <b> serait associé au premier </b>, ce qui n'est pas correct. Il est toutefois possible d'écrire une expression rationnelle qui fera correspondre correctement des parenthèses ou des balises imbriquées, mais uniquement si le nombre de niveaux d'imbrication est fixe et connu. Si le nombre de niveaux d'imbrication n'est pas fixe et connu, il est impossible d'écrire une expression rationnelle qui n'échouera pas.

Supposons que nous voulions une expression rationnelle qui corresponde à des nombres entiers compris entre 0 et 99. Il faut au moins un chiffre, nous commençons donc par l'expression [0-9]{1,1}, qui correspond à un seul chiffre exactement une fois. Cette expression permet de faire correspondre les nombres entiers compris entre 0 et 9. Pour faire correspondre les nombres entiers jusqu'à 99, augmentez le nombre maximal d'occurrences à 2, de sorte que la regexp devient [0-9]{1,2}. Cette regexp répond à l'exigence initiale de faire correspondre les nombres entiers de 0 à 99, mais elle correspond également aux nombres entiers qui se trouvent au milieu des chaînes de caractères. Si nous voulons que l'entier correspondant soit la chaîne entière, nous devons utiliser les assertions d'ancrage, ^ (caret) et $ (dollar). Lorsque ^ est le premier caractère d'une regexp, cela signifie que la regexp doit correspondre au début de la chaîne. Lorsque $ est le dernier caractère de la regexp, cela signifie que la regexp doit correspondre à la fin de la chaîne. La regexp devient alors ^[0-9]{1,2}$. Notez que les assertions, par exemple ^ et $, ne correspondent pas à des caractères mais à des emplacements dans la chaîne.

Si vous avez vu des expressions rationnelles décrites ailleurs, il se peut qu'elles soient différentes de celles présentées ici. En effet, certains jeux de caractères et certains quantificateurs sont si courants qu'ils ont été représentés par des symboles spéciaux. [0-9] peut être remplacé par le symbole \d. Le quantificateur correspondant à une seule occurrence, {1,1}, peut être remplacé par l'expression elle-même, c'est-à-dire que x{1,1} est identique à x. Ainsi, notre outil de recherche de 0 à 99 pourrait s'écrire ^\d{1 ,2}$. Il peut également s'écrire ^\d\d {0 ,1}$, c'est-à-dire qu'à partir du début de la chaîne, il faut faire correspondre un chiffre, suivi immédiatement de 0 ou 1 chiffre. En pratique, elle s'écrit ^\d\d ?$. Le ? est une abréviation du quantificateur {0,1}, c'est-à-dire 0 ou 1 occurrence. ? rend une expression facultative. La regexp ^\d\d ?$ signifie Au début de la chaîne, faire correspondre un chiffre, suivi immédiatement de 0 ou 1 chiffre supplémentaire, suivi immédiatement de la fin de la chaîne.

Pour écrire une expression rationnelle qui correspond à l'un des mots "mail" , "letter" ou "correspondence", mais qui ne correspond pas aux mots qui contiennent ces mots, par exemple "email", "mailman", "mailer" et "letterbox", commencez par une expression rationnelle qui correspond à "mail". Exprimée complètement, la regexp est m{1,1}a{1,1}i{1,1}l{1,1}, mais comme une expression de caractère est automatiquement quantifiée par {1,1}, nous pouvons simplifier la regexp en mail, c'est-à-dire un "m" suivi d'un "a" suivi d'un "i" suivi d'un "l". Nous pouvons maintenant utiliser la barre verticale |, qui signifie ou, pour inclure les deux autres mots, de sorte que notre expression rationnelle correspondant à l'un des trois mots devient courrier|lettre|correspondance. Elle correspond à "courrier" , "lettre" ou "correspondance". Bien que cette expression rationnelle corresponde à l'un des trois mots que nous voulons faire correspondre, elle correspondra également à des mots que nous ne voulons pas faire correspondre, par exemple, "email". Afin d'éviter que l'expression rationnelle ne corresponde à des mots non désirés, nous devons lui demander de commencer et de terminer la correspondance à la limite des mots. Tout d'abord, nous plaçons notre expression rationnelle entre parenthèses (mail|lettre|correspondance). Les parenthèses regroupent les expressions et identifient une partie de l'expression recherchée que nous souhaitons capture. Le fait de mettre l'expression entre parenthèses nous permet de l'utiliser en tant que composant dans des expressions recherchées plus complexes. Cela nous permet également d'examiner lequel des trois mots a réellement été trouvé. Pour forcer la correspondance à commencer et à se terminer sur les frontières des mots, nous entourons la regexp de \b assertions de limites de mots: \b(mail|letter|correspondance)\b. La regexp signifie maintenant : Correspondre à une limite de mot, suivie de l'expression rationnelle entre parenthèses, suivie d'une limite de mot. L'assertion \b correspond à une position dans l'expression rationnelle, et non à un caractère. Une limite de mot est un caractère autre qu'un mot, par exemple un espace, une nouvelle ligne ou le début ou la fin d'une chaîne de caractères.

Si nous voulons remplacer les caractères esperluette par l'entité HTML &amp ;, l'expression rationnelle à utiliser est simplement &. Mais cette expression rationnelle correspondra également aux esperluettes qui ont déjà été converties en entités HTML. Nous voulons remplacer uniquement les esperluettes qui ne sont pas déjà suivies par amp ;. Pour cela, nous avons besoin de l'assertion négative (?!__). La regexp peut alors être écrite sous la forme &(?!amp ;), c'est-à-dire qu'elle correspond à une esperluette qui n' est pas suivie d'une amp ;.

Si nous voulons compter toutes les occurrences de 'Eric' et 'Eirik' dans une chaîne de caractères, deux solutions valables sont \b(Eric|Eirik)\b et \bEi?ri[ck]\b. L'assertion de limite de mot '\b' est nécessaire pour éviter de faire correspondre des mots qui contiennent l'un ou l'autre nom, par exemple 'Ericsson'. Notez que la deuxième expression rationnelle correspond à plus d'orthographes que nous ne le souhaitons : "Eric", "Erik", "Eiric" et "Eirik".

Certains des exemples présentés ci-dessus sont mis en œuvre dans la section code examples.

Caractères et abréviations pour les ensembles de caractères

Remarque : le compilateur C++ transforme les barres obliques inverses en chaînes de caractères. Pour inclure une barre oblique inverse dans une expression rationnelle, saisissez-la deux fois, c'est-à-dire \\. Pour faire correspondre le caractère barre oblique inverse lui-même, saisissez-le quatre fois, c'est-à-dire \\\\.

Jeux de caractères

Les crochets signifient qu'il y a correspondance avec n'importe quel caractère contenu dans les crochets. Les abréviations des jeux de caractères décrites ci-dessus peuvent apparaître dans un jeu de caractères entre crochets. À l'exception des abréviations du jeu de caractères et des deux exceptions suivantes, les caractères n'ont pas de signification particulière entre crochets.

L'utilisation des abréviations du jeu de caractères prédéfini est plus facile à utiliser que l'utilisation de plages de caractères sur les différentes plates-formes et dans les différentes langues. Par exemple, [0-9] correspond à un chiffre dans les alphabets occidentaux mais \d correspond à un chiffre dans n'importe quel alphabet.

Remarque : dans d'autres documentations sur les expressions rationnelles, les jeux de caractères sont souvent appelés "classes de caractères".

Les quantificateurs

Par défaut, une expression est automatiquement quantifiée par {1,1}, c'est-à-dire qu'elle doit apparaître exactement une fois. Dans la liste suivante, E signifie expression. Une expression est un caractère, ou une abréviation pour un ensemble de caractères, ou un ensemble de caractères entre crochets, ou une expression entre parenthèses.

Pour appliquer un quantificateur à plus que le caractère précédent, utilisez des parenthèses pour regrouper les caractères dans une expression. Par exemple, tag+ correspond à un "t" suivi d'un "a" suivi d'au moins un "g", tandis que (tag)+ correspond à au moins une occurrence de "tag".

Remarque : les quantificateurs sont normalement "gourmands". Ils correspondent toujours à la plus grande partie possible du texte. Par exemple, 0+ correspond au premier zéro qu'il trouve et à tous les zéros consécutifs après le premier zéro. Appliqué à "20005", il correspond à "20005". Les quantificateurs peuvent être rendus non gourmands, voir setMinimal().

Capture du texte

Les parenthèses nous permettent de regrouper des éléments afin de les quantifier et de les capturer. Par exemple, si l'expression mail|lettre|correspondance correspond à une chaîne de caractères, nous savons que l 'un des mots correspond, mais pas lequel. L'utilisation de parenthèses nous permet de "capturer" tout ce qui correspond à l'intérieur de leurs limites. Ainsi, si nous avons utilisé (mail|lettre|correspondance) et que nous avons comparé cette expression rationnelle à la chaîne "Je vous ai envoyé un e-mail", nous pouvons utiliser les fonctions cap() ou capturedTexts() pour extraire les caractères correspondants, dans ce cas "mail".

Nous pouvons utiliser le texte capturé à l'intérieur de l'expression rationnelle elle-même. Pour faire référence au texte capturé, nous utilisons les références arrière qui sont indexées à partir de 1, de la même manière que pour cap(). Par exemple, nous pouvons rechercher des mots en double dans une chaîne en utilisant \b( \w+ )\W + \1\b , ce qui signifie correspondre à une limite de mot suivie d'un ou plusieurs caractères de mot suivis d'un ou plusieurs caractères de non-mot suivis du même texte que la première expression entre parenthèses suivie d'une limite de mot.

Si nous voulons utiliser les parenthèses uniquement pour le regroupement et non pour la capture, nous pouvons utiliser la syntaxe non capturante, par exemple (?:vert|bleu). Les parenthèses non capturantes commencent par "(? :" et se terminent par ")". Dans cet exemple, la correspondance est soit "verte", soit "bleue", mais nous ne capturons pas la correspondance, de sorte que nous savons seulement si nous avons trouvé la correspondance, mais pas quelle couleur nous avons effectivement trouvée. L'utilisation de parenthèses non capturantes est plus efficace que l'utilisation de parenthèses capturantes, car le moteur d'expressions rationnelles doit faire moins de comptabilité.

Les parenthèses capturantes et non capturantes peuvent être imbriquées.

Pour des raisons historiques, les quantificateurs (par exemple *) qui s'appliquent aux parenthèses capturantes sont plus "gourmands" que les autres quantificateurs. Par exemple, a*(a*) correspondra à "aaa" si cap(1) == "aaa". Ce comportement est différent de celui d'autres moteurs d'expressions rationnelles (notamment Perl). Pour obtenir un comportement de capture plus intuitif, spécifiez QRegExp::RegExp2 au constructeur de QRegExp ou appelez setPatternSyntax(QRegExp::RegExp2).

Lorsque le nombre de correspondances ne peut être déterminé à l'avance, il est courant d'utiliser cap() dans une boucle. Par exemple :

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

Assertions

Les assertions font une déclaration sur le texte à l'endroit où elles apparaissent dans l'expression rationnelle, mais elles ne correspondent à aucun caractère. Dans la liste suivante, E représente n'importe quelle expression.

Correspondance de caractères génériques

La plupart des interpréteurs de commandes tels que bash ou cmd.exe prennent en charge le "file globbing", c'est-à-dire la possibilité d'identifier un groupe de fichiers à l'aide de caractères génériques. La fonction setPatternSyntax() permet de basculer entre le mode regexp et le mode wildcard. La correspondance avec les caractères génériques est beaucoup plus simple que les expressions rationnelles complètes et ne comporte que quatre caractéristiques :

Dans le mode Wildcard, les caractères génériques ne peuvent pas être échappés. Dans le mode WildcardUnix, le caractère "\" échappe au caractère générique.

Par exemple, si nous sommes en mode joker et que les chaînes de caractères contiennent des noms de fichiers, nous pouvons identifier les fichiers HTML avec *.html. Cela correspondra à zéro ou plusieurs caractères suivis d'un point et de 'h', 't', 'm' et 'l'.

Pour tester une chaîne de caractères à l'aide d'une expression générique, utilisez exactMatch(). Par exemple :

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

Notes pour les utilisateurs de Perl

La plupart des abréviations de classes de caractères supportées par Perl sont supportées par QRegExp, voir characters and abbreviations for sets of characters.

Dans QRegExp, à part à l'intérieur des classes de caractères, ^ signifie toujours le début de la chaîne, donc les carets doivent toujours être échappés à moins qu'ils ne soient utilisés dans ce but. En Perl, la signification du caret varie automatiquement en fonction de l'endroit où il apparaît, de sorte qu'il est rarement nécessaire de l'échapper. Il en va de même pour $ qui, dans QRegExp, signifie toujours la fin de la chaîne.

Les quantificateurs de QRegExp sont les mêmes que les quantificateurs gourmands de Perl (mais voir note above). La correspondance non gourmande ne peut pas être appliquée à des quantificateurs individuels, mais peut être appliquée à tous les quantificateurs du motif. Par exemple, pour faire correspondre la regexp Perl ro+?m, il faut :

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

L'équivalent de l'option /i de Perl est setCaseSensitivity(Qt::CaseInsensitive).

L'option /g de Perl peut être émulée en utilisant une option loop.

Dans QRegExp , . correspond à n'importe quel caractère, donc toutes les expressions rationnelles de QRegExp ont l'équivalent de l'option /s de Perl. QRegExp n'a pas d'équivalent à l'option /m de Perl, mais celle-ci peut être émulée de différentes manières, par exemple en divisant l'entrée en lignes ou en bouclant avec une regexp qui recherche les nouvelles lignes.

Comme QRegExp est orienté vers les chaînes de caractères, il n'y a pas d'assertions \A, \Z, ou \z. L'assertion \G n'est pas supportée mais peut être émulée dans une boucle.

Le $& de Perl est cap(0) ou capturedTexts()[0]. Il n'y a pas d'équivalent QRegExp pour $`, $' ou $+. Les variables de capture de Perl, $1, $2, ... correspondent à cap(1) ou capturedTexts()[1], cap(2) ou capturedTexts()[2], etc.

Pour remplacer un motif, utilisez QString::replace().

La syntaxe étendue /x de Perl n'est pas supportée, pas plus que les directives, par exemple (?i), ou les commentaires de regexp, par exemple (?#comment). En revanche, les règles de C++ pour les chaînes littérales peuvent être utilisées pour obtenir le même résultat :

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

Les assertions lookahead positives et négatives de largeur nulle (?=pattern) et (?!pattern) sont supportées avec la même syntaxe que Perl. Les assertions d'anticipation de Perl, les sous-expressions "indépendantes" et les expressions conditionnelles ne sont pas supportées.

Les parenthèses non capturantes sont également supportées, avec la même syntaxe (?:pattern).

Voir QString::split() et QStringList::join() pour les équivalents des fonctions split et join de Perl.

Remarque : comme le C++ transforme les \Ns, ils doivent être écrits deux fois dans le code, par exemple \b doit être écrit \N\b.

Exemples de code

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 troisième chaîne correspond à"6". Il s'agit d'une simple expression rationnelle de validation pour les nombres entiers compris entre 0 et 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 deuxième chaîne correspond à'This_is-OK'. Nous avons utilisé l'abréviation du jeu de caractères '\S' (sans espace) et les ancres pour faire correspondre les chaînes qui ne contiennent pas d'espace.

Dans l'exemple suivant, nous faisons correspondre les chaînes contenant "mail", "letter" ou "correspondence", mais uniquement les mots entiers, c'est-à-dire pas "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 deuxième chaîne correspond à "Veuillez écrire la lettre". Le mot "lettre" est également capturé (en raison des parenthèses). Nous pouvons voir le texte que nous avons capturé comme suit :

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

Ceci capturera le texte de la première série de parenthèses capturantes (en comptant les parenthèses capturantes de gauche à droite). Les parenthèses sont comptées à partir de 1 puisque cap(0) est l'expression recherchée complète (équivalente à '&' dans la plupart des moteurs d'expressions recherchées).

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"

Ici, nous avons passé la QRegExp à la fonction replace() de QString pour remplacer le texte correspondant par un nouveau texte.

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

Nous avons utilisé la fonction indexIn() pour faire correspondre de manière répétée la regexp à la chaîne de caractères. Notez qu'au lieu d'avancer d'un caractère à la fois pos++, nous aurions pu écrire pos += rx.matchedLength() pour sauter la chaîne déjà trouvée. Le compte sera égal à 3, ce qui correspond à "Un Eric, un autre Eirik et un Ericsson. Combien d'Eiriks, Eric?"; il ne correspond pas à "Ericsson" ou "Eiriks" parce qu'ils ne sont pas délimités par des frontières de non-mots.

Une utilisation courante des expressions rationnelles consiste à diviser des lignes de données délimitées en leurs champs constitutifs.

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

Dans cet exemple, nos lignes d'entrée ont le format suivant : nom de l'entreprise, adresse web et pays. Malheureusement, la regexp est assez longue et peu polyvalente - le code s'interrompra si nous ajoutons d'autres champs. Une solution plus simple et plus efficace consiste à rechercher le séparateur, '\t' dans ce cas, et à prendre le texte environnant. La fonction QString::split() peut prendre une chaîne de séparation ou une expression rationnelle comme argument et diviser une chaîne en conséquence.

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

Ici, le champ [0] correspond à la société, le champ [1] à l'adresse web, etc.

Pour imiter la correspondance d'un shell, nous pouvons utiliser le mode "wildcard".

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 correspondance par caractères génériques peut être pratique en raison de sa simplicité, mais toute expression rationnelle de caractères génériques peut être définie à l'aide d'expressions rationnelles complètes, par exemple .*\.html$. Remarquez que nous ne pouvons pas faire correspondre les fichiers .html et .htm avec un joker, à moins d'utiliser *.htm* qui correspondra également à 'test.html.bak'. Une expression rationnelle complète nous donne la précision dont nous avons besoin, .*\.html?$.

QRegExp peut faire une correspondance insensible à la casse en utilisant setCaseSensitivity(), et peut utiliser une correspondance non gourmande, voir setMinimal(). Par défaut, QRegExp utilise des expressions rationnelles complètes, mais cela peut être modifié avec setPatternSyntax(). La recherche peut se faire vers l'avant avec indexIn() ou vers l'arrière avec lastIndexIn(). Le texte capturé peut être consulté en utilisant capturedTexts() qui renvoie une liste de chaînes de caractères de toutes les chaînes capturées, ou en utilisant cap() qui renvoie la chaîne capturée pour l'index donné. La fonction pos() prend un index de correspondance et renvoie la position dans la chaîne où la correspondance a été faite (ou -1 s'il n'y a pas eu de correspondance).

Portage vers QRegularExpression

La classe QRegularExpression introduite dans Qt 5 Compatibility APIs implémente des expressions régulières compatibles avec Perl et représente une grande amélioration par rapport à QRegExp en termes d'API offertes, de syntaxe de motif prise en charge et de vitesse d'exécution. La plus grande différence est que QRegularExpression contient simplement une expression régulière et qu'elle n'est pas modifiée lorsqu'une correspondance est demandée. Au lieu de cela, un objet QRegularExpressionMatch est renvoyé pour vérifier le résultat d'une correspondance et extraire la sous-chaîne capturée. Il en va de même pour les correspondances globales et QRegularExpressionMatchIterator.

D'autres différences sont décrites ci-dessous.

Syntaxe différente des motifs

Le portage d'une expression régulière de QRegExp à QRegularExpression peut nécessiter des modifications du motif lui-même.

Dans certains cas, QRegExp était trop indulgent et acceptait des motifs qui sont tout simplement invalides lorsqu'on utilise QRegularExpression. Il est facile de les détecter, car les objets QRegularExpression construits avec ces motifs ne sont pas valides (voir QRegularExpression::isValid()).

Dans d'autres cas, un motif porté de QRegExp à QRegularExpression peut changer silencieusement de sémantique. Il est donc nécessaire de revoir les motifs utilisés. Les cas les plus notables d'incompatibilité silencieuse sont les suivants :

• Les accolades sont nécessaires pour utiliser un échappement hexadécimal comme \xHHHH avec plus de 2 chiffres. Un motif comme \x2022 doit être porté à \x{2022}, sinon il correspondra à un espace (0x20) suivi de la chaîne "22". En général, il est fortement recommandé de toujours utiliser des accolades avec l'échappement \x, quel que soit le nombre de chiffres spécifiés.
• Une quantification de 0 à n comme {,n} doit être portée à {0,n} pour préserver la sémantique. Sinon, un motif tel que \d{,3} correspondrait à un chiffre suivi de la chaîne exacte "{,3}".
• QRegExp effectue par défaut une correspondance compatible avec Unicode, tandis que QRegularExpression nécessite une option distincte ; voir ci-dessous pour plus de détails.
• c{.} dans QRegExp correspond par défaut à tous les caractères, y compris le caractère de retour à la ligne. QRegularExpression exclut le caractère de retour à la ligne par défaut. Pour inclure le caractère de retour à la ligne, définissez l'option QRegularExpression::DotMatchesEverythingOption.

Pour une vue d'ensemble de la syntaxe des expressions régulières prises en charge par QRegularExpression, veuillez consulter la page de manuel pcrepattern(3), qui décrit la syntaxe des motifs prise en charge par PCRE (l'implémentation de référence des expressions régulières compatibles avec Perl).

Portage de QRegExp::exactMatch()

QRegExp::exactMatchLa fonction QRegExp::exactMatch() avait deux objectifs : elle permettait de faire correspondre exactement une expression rationnelle à une chaîne de caractères, et elle implémentait une correspondance partielle.

Portage de la correspondance exacte de QRegExp

La correspondance exacte indique si l'expression rationnelle correspond à l'intégralité de la chaîne sujet. Par exemple, les classes produisent sur la chaîne sujet "abc123":

La correspondance exacte n'est pas reflétée dans QRegularExpression. Si vous voulez être sûr que la chaîne de l'objet correspond exactement à l'expression régulière, vous pouvez envelopper le motif à l'aide de la fonction QRegularExpression::anchoredPattern() :

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

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

Portage de la correspondance partielle de QRegExp

Lors de l'utilisation de QRegExp::exactMatch(), si une correspondance exacte n'a pas été trouvée, il est toujours possible de connaître la longueur de la chaîne du sujet correspondant à l'expression rationnelle en appelant QRegExp::matchedLength(). Si la longueur renvoyée est égale à la longueur de la chaîne de l'objet, on peut en conclure qu'une correspondance partielle a été trouvée.

QRegularExpression prend en charge la correspondance partielle de manière explicite au moyen de l'adresse QRegularExpression::MatchType.

Correspondance globale

En raison des limitations de l'API QRegExp, il était impossible d'implémenter correctement la correspondance globale (c'est-à-dire comme le fait Perl). En particulier, les motifs qui peuvent correspondre à 0 caractère (comme "a*") sont problématiques.

QRegularExpression::globalMatch() implémente correctement la correspondance globale de Perl, et l'itérateur retourné peut être utilisé pour examiner chaque résultat.

Par exemple, si vous avez un code comme :

QString subject("the quick fox");

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

Vous pouvez le réécrire comme suit :

QString subject("the quick fox");

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

Prise en charge des propriétés Unicode

Lors de l'utilisation de QRegExp, les classes de caractères telles que \w, \d, etc. correspondent aux caractères ayant la propriété Unicode correspondante : par exemple, \d correspond à tout caractère ayant la propriété Unicode Nd (chiffre décimal).

Ces classes de caractères ne correspondent par défaut qu'aux caractères ASCII lors de l'utilisation de QRegularExpression: par exemple, \d correspond exactement à un caractère de la plage ASCII 0-9. Il est possible de modifier ce comportement en utilisant l'option de motif QRegularExpression::UseUnicodePropertiesOption.

Correspondance avec les caractères génériques

Il n'y a pas de moyen direct de faire des correspondances avec des caractères génériques dans QRegularExpression. Cependant, la méthode QRegularExpression::wildcardToRegularExpression() est fournie pour traduire les motifs globaux en une expression rationnelle compatible avec Perl qui peut être utilisée à cette fin.

Par exemple, si vous avez un code comme :

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

Vous pouvez le réécrire comme suit :

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

Notez cependant que certains motifs de caractères génériques de type shell peuvent ne pas être traduits comme vous l'attendez. L'exemple de code suivant se cassera silencieusement s'il est simplement converti en utilisant la fonction mentionnée ci-dessus :

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

C'est parce que, par défaut, l'expression régulière retournée par QRegularExpression::wildcardToRegularExpression() est complètement ancrée. Pour obtenir une expression régulière qui n'est pas ancrée, passez QRegularExpression::UnanchoredWildcardConversion comme option de conversion :

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

Correspondance minimale

QRegExp::setMinimal() implémente la correspondance minimale en inversant simplement l'avidité des quantificateurs (QRegExp ne supporte pas les quantificateurs paresseux, comme *?, +?, etc.). QRegularExpression supporte au contraire les quantificateurs avides, paresseux et possessifs. L'option QRegularExpression::InvertedGreedinessOption peut être utile pour émuler les effets de QRegExp::setMinimal() : si elle est activée, elle inverse l'avidité des quantificateurs (les quantificateurs avides deviennent paresseux et vice versa).

Modes de caret

L'option QRegularExpression::AnchorAtOffsetMatchOption match peut être utilisée pour émuler le comportement de QRegExp::CaretAtOffset. Il n'y a pas d'équivalent pour les autres modes de QRegExp::CaretMode.