Expressions régulières

Les fonctions IsMatch, Match et MatchAll sont utilisées pour extraire et valider des modèles dans un texte. Le modèle qu’elles utilisent est appelé une expression régulière.

Les expressions régulières sont puissantes et polyvalentes. Cependant, ils peuvent parfois apparaître sous la forme d’une séquence aléatoire de signes de ponctuation. Cet article ne décrit pas tous les aspects des expressions régulières, mais une grande quantité d’informations, de didacticiels et d’outils est disponible en ligne.

Les expressions régulières ont une longue histoire et sont disponibles dans de nombreux langages de programmation. Chaque langage de programmation a son propre dialecte d’expressions régulières, et il existe peu de normes. Dans la mesure du possible, nous nous efforçons que la même expression régulière donne le même résultat dans toutes les implémentations Power Fx. La compatibilité n’est pas facile à réaliser car Power Fx s’exécute sur JavaScript et .NET qui présentent des différences significatives. Pour s’exécuter sur différentes plateformes, les expressions régulières Power Fx utilisent un sous-ensemble de fonctionnalités largement prises en charge dans le secteur.

Par conséquent, certaines expressions régulières qui fonctionnent dans d’autres environnements peuvent être bloquées ou nécessiter des ajustements dans Power Fx. Des erreurs au moment de la création sont signalées lorsque des fonctionnalités non prises en charge sont rencontrées. C’est pourquoi l’expression régulière et les options doivent être constantes au moment de la création et non dynamiques, par exemple lorsqu’elles sont fournies dans une variable.

Fonctionnalités prises en charge

Power Fx prend en charge les fonctionnalités d’expression régulière suivantes, avec des notes sur la façon dont le comportement de Power Fx peut différer de celui d’autres systèmes.

L’expression régulière doit être constante et ne doit pas être calculée ou stockée dans une variable. L’opérateur &, l’interpolation de chaîne $"{...}" et les fonctions Concatenate, Char et UniChar avec des arguments constants sont pris en charge.

Caractères littéraux

Utilisez \x ou \u à la place. Les codes octaux pour les caractères, comme \044 ou \o{044}, sont interdits, car ils peuvent être ambigus avec des références antérieures numérotées.

\v n’est pas pris en charge, car il est ambigu dans les langages d’expression régulière. Utilisez \x0b pour un onglet vertical ou [\x0b\f\r\n\x85\u2028\u2029] pour un espace blanc vertical.

Assertions

Les assertions correspondent à une position particulière dans le texte, mais ne consomment aucun caractère.

$ correspond à la fin d’une ligne, y compris tout caractère \r\n, \r ou \n de fin.

Les assertions lookahead et lookbehind ne peuvent pas contenir de sous-correspondances ou de quantificateurs illimités à l’intérieur, et ne peuvent pas être utilisées avec un quantificateur à l’extérieur.

Classes de caractères

Pour plus de clarté et éviter toute ambiguïté, les classes de caractères entre crochets sont plus restrictives que dans d’autres langages d’expression régulière :

• Les traits d’union littéraux doivent être échappés. Utilisez [\-a] au lieu de [-a] pour mettre en correspondance - ou a.
• Les crochets de début doivent être échappés. Utilisez [\[a] au lieu de [[] pour mettre en correspondance [ ou a.
• À moins qu’il ne s’agisse du premier caractère et qu’il indique la négation, le caractère doit être échappé. Utilisez [a\^] au lieu de [a^] pour mettre en correspondance ^ ou a.
• Les accolades doivent être échappées. Utilisez [\{\}] pour mettre en correspondance { ou }.
• La classe de caractères vides [] n’est pas prise en charge. Pour inclure un crochet fermant dans une classe de caractères, échappez-le.

Catégories de caractères Unicode prises en charge par \p{} et \P{} :

• Lettres : L, Lu, Ll, Lt, Lm, Lo
• Marques : M, Mn, Mc, Me
• Nombres : N, Nd, Nl, No
• Ponctuation : P, Pc, Pd, Ps, Pe, Pi, Pf, Po
• Symboles : S, Sm, Sc, Sk, So
• Séparateurs : Z, Zs, Zl, Zp
• Control et format : Cc, Cf, tandis que les autres catégories de préfixe C ne sont pas prises en charge.

\W, \D, \S et \P{} ne peuvent pas être utilisés dans une classe de caractères négative [^...]. Afin d’être implémentées sur certaines plateformes, ces classes de caractères négatives sont traduites en leurs équivalents Unicode, ce qui pourrait être difficile à faire s’ils étaient également négatifs.

Les caractères Unicode compris entre U+10000 et U+10FFFF, nécessitant des paires de substitution, ne sont pas pris en charge dans les classes de caractères.

Quantificateurs

Les quantificateurs possessifs ne sont pas pris en charge.

Le mélange de sous-correspondances et de quantificateurs présente des limites. Pour plus d’informations, voir Sous-correspondances éventuellement vides.

Groupes

Les sous-correspondances nommées et numérotées ne peuvent pas être utilisées ensemble. Par défaut, les sous-correspondances nommées sont activées et sont préférées pour plus de clarté et de maintenabilité, tandis que les groupes de capture standard deviennent des groupes sans capture avec des performances améliorées. Ce comportement peut être modifié avec MatchOptions.NumberedSubMatches, qui fournit des groupes de capture traditionnels, mais désactive les groupes de capture nommés. Certaines implémentations traitent différemment une combinaison de groupes de capture numérotés et nommés, c’est pourquoi Power Fx l’interdit.

Les groupes de capture auto-référencés ne sont pas pris en charge, par exemple l’expression régulière (a\1).

Deux groupes de capture ne peuvent pas partager le même nom, par exemple, l’expression régulière (?<id>\w+)|(?<id>\d+) n’est pas prise en charge.

Le nom d’une sous-correspondance nommée doit commencer par un caractère \p{L} ou _ et peut continuer avec ces caractères plus \p{Nd}. La longueur des noms est limitée à 62 unités de code UTF-16.

Les références antérieures à des sous-correspondances éventuellement vides et à des sous-correspondances dans un lookbehind ou lookahead ne sont pas non plus prises en charge.

Certaines implémentations offrent une option de « capture explicite » pour améliorer les performances, ce qui n’est pas nécessaire dans Power Fx, car il s’agit de la valeur par défaut. MatchOptions.NumberedSubMatches la désactive et active implicitement les captures numérotées.

Le mélange de sous-correspondances et de quantificateurs présente des limites. Voir Sous-correspondances éventuellement vides pour plus d’informations.

Commentaires

Voir MatchOptions.FreeSpacing pour une alternative à la mise en forme et aux commentaires d’expressions régulières.

Optionsen ligne

Les modes en ligne pris en charge sont [imsx]. Ceux-ci correspondent à MatchOptions.IgnoreCase, MatchOptions.Multiline, MatchOptions.DotAll et MatchOptions.FreeSpacing, respectivement. n est également accepté pour la compatibilité, mais n’a aucun effet car il s’agit de la valeur par défaut et est incompatible avec MatchOptions.NumberedSubMatches.

Les options en ligne ne peuvent pas être utilisées pour désactiver une option ou définir une option pour une sous-expression.

Options

Les options de correspondance modifient le comportement de la correspondance d’expressions régulières. Il existe deux façons d’activer les options, qui peuvent être mélangées tant qu’il n’y a pas de conflit :

• Valeur d’énumération MatchOptions transmise comme troisième argument à Match, MatchAll et IsMatch. Les options peuvent être combinées avec l’opérateur & ou la fonction Concatenate, par exemple MatchOptions.DotAll & MatchOptions.FreeSpacing. Toutes les fonctions d’expression régulière nécessitent que MatchOptions soit une valeur constante, elle ne peut pas être calculée ou stockée dans une variable.
• Préfixe (?...) au tout début de l’expression régulière. Les options peuvent être combinées avec plusieurs lettres dans la construction (?...), par exemple (?sx). Certaines options n’ont pas d’équivalent (?...) mais peuvent avoir d’autres moyens d’obtenir le même effet, par exemple MatchOptions.BeginsWith est l’équivalent de ^ au début de l’expression régulière.

contient

Activé avec MatchOptions.Contains sans équivalent texte de l’expression régulière. MatchOptions.Contains est la valeur par défaut pour toutes les fonctions en dehors de Power Apps ; dans Power Apps MatchOptions.Complete est la valeur par défaut pour IsMatch.

Terminer

Activé avec MatchOptions.Complete ou utilisez ^ et $ au début et à la fin de l’expression régulière, respectivement.

BeginsWith

Activé avec MatchOptions.BeginsWith ou utilisez ^ au début et à la fin de l’expression régulière.

EndsWith

Activé avec MatchOptions.EndsWith ou utilisez $ à la fin de l’expression régulière.

DotAll (en anglais seulement)

Activé avec MatchOptions.DotAll ou utilisez (?s) au début de l’expression régulière.

Normalement, l’opérateur point . correspond à tous les caractères, à l’exception des caractères de saut de ligne [\n\x0b\f\r\x85\u2028\u2029]. Avec le modificateur DotAll, tous les caractères sont mis en correspondance, y compris les caractères de saut de ligne.

Dans cet exemple, seul « Hello » mis en correspondance par défaut, le . ne correspond pas au saut de ligne :

Trim( Match( "Hello
              World", ".*" ).FullMatch )
// returns 
// "Hello"

Mais si nous ajoutons le modificateur DotAll, alors le saut de ligne et tous les caractères suivants sont mis en correspondance :

Trim( Match( "Hello
              World", ".*", MatchOptions.DotAll ).FullMatch )
// returns 
// "Hello
// World"

FreeSpacing (Espacement libre)

Activé avec MatchOptions.FreeSpacing ou utilisez (?x) au début d’une expression régulière.

L’espacement libre facilite la lecture et le maintien d’une expression régulière complexe. Les règles sont simples :

• Les caractères d’espace sont ignorés dans l’expression régulière, y compris tous les caractères qui correspondraient à \s. Si la mise en correspondance d’un espace, utilisez \s, \ , \t, \r ou \n.
• # commence un commentaire qui s’exécute jusqu’à la fin de la ligne. Lui et tous les caractères qui suivent le caractère de saut de ligne suivant (caractères non mis en correspondance par . sans MatchOptions.DotAll) sont ignorés.
• Les classes de caractères ne sont pas incluses dans ces modifications. Les caractères d'espace et # agissent comme ils le font normalement. Par exemple, IsMatch( "a#b c", "(?x)a[ #]b[ #]c" ) renvoie true. Certains langages d’expression régulière incluent des classes de caractères en espacement libre, ou fournissent une option pour les inclure, contrairement à Power Fx.

Par exemple, voici une expression régulière complexe pour mettre en correspondance une date et heure 8601 ISO :

IsMatch( 
    "2025-01-17T19:38:49+0000",
    "^\d{4}-(0\d|1[012])-([012]\d|3[01])(T([01]\d|2[0123]):[0-5]\d(:[0-5]\d(\.\d{3})?)?(Z|[\-+]\d{4}))?$"
)
// returns true

Et voici l’expression régulière identique avec un espacement libre utilisant plusieurs lignes, une indentation pour les groupes et des commentaires d’expression régulière, ce qui rend cette version plus facile à comprendre, à valider et à maintenir.

IsMatch( "2025-01-17T19:38:49+0000", 
    "(?x)                 # enables free spacing, must be very first
    ^                     # matches from beginning of text
    \d{4}                 # year (0000-9999)
    -(0\d|1[012])         # month (00-12)
    -([012]\d|3[01])      # day (00-31, range not checked against month)
    (T([01]\d|2[0123])    # optional time, starting with hours (00-23)
      :[0-5]\d            # minutes (00-59)
      (:[0-5]\d           # optional seconds (00-59)
        (\.\d{3})?        # optional milliseconds (000-999)
      )?
      (Z|[\-+]\d{4})      # time zone
    )?
    $                     # matches to end of text
    "
)
// returns true

IgnoreCase

Activé avec MatchOptions.IgnoreCase ou utilisez (?i) au début d’une expression régulière.

Correspond au texte dans une casse non sensible : les lettres majuscules correspondent aux lettres minuscules et les lettres minuscules correspondent aux lettres majuscules.

Par exemple :

IsMatch( "HELLO!", "hello", MatchOptions.IgnoreCase )
// returns true

IsMatch( "file://c:/temp/info.txt", "^FILE://", MatchOptions.IgnoreCase )
// returns true

La plupart des parties ou Power Fx prennent en compte la culture, mais pas ici. L’utilisation de la correspondance invariante de culture est la norme de l’industrie pour les expressions régulières, y compris dans JavaScript et Perl. Elle est utile dans le deuxième exemple où une ressource système est mise en correspondance, par exemple, dans la culture tr-TR où I n’est pas l’équivalent en majuscule de i.

Si une correspondance sensible à la culture et insensible à la casse est nécessaire, utilisez la classe de caractères avec les caractères correspondants à la place, par exemple [Hh][Ee][Ll][Ll][Oo] pour le premier exemple.

Multiline

Activé avec MatchOptions.Multiline ou utilisez (?m) au début d’une expression régulière.

Normalement, les ancres ^ et $ correspondent au début et à la fin du texte d’entrée. Avec le modificateur Multiligne, ces ancres correspondent au début et à la fin des lignes dans le texte d’entrée, où chaque ligne se termine par \r, \n, \r\n ou la fin de l’entrée. Par exemple :

MatchAll( "Hello" & Char(13) & Char(10) & "World", "^.+$" )
// returns 
// "Hello"

Modèles prédéfinis

Les modèles prédéfinis vous permettent de mettre en correspondre un caractère d’un jeu de caractères ou une séquence de plusieurs caractères. Utilisez l’opérateur de concaténation de chaîne & pour combiner vos chaînes de texte avec les membres de l’énumération Match :

Par exemple, le modèle "A" & Match.MultipleDigits correspond à la lettre « A » suivie d’un ou de plusieurs chiffres.

Le modèle Match.Email est plus complexe que les autres. Il détecte et extrait les adresses e-mail courantes au format local@hostname.tld, éventuellement à partir de longs passages de texte, et prend en charge les caractères internationaux et les emojis. Utilisez-le pour valider un formulaire qui utilise une adresse e-mail comme entrée, comme test rapide de l’entrée dans une formulaire de courrier électronique. Si vous n’extrayez pas, utilisez MatchOptions.Complete pour détecter une adresse e-mail, par exemple, dans un contrôle d’entrée de texte.

Cependant, Match.Email ne valide pas que l’adresse e-mail est conforme à toutes les nombreuses normes en évolution pour les adresses e-mail, les noms de domaine et les domaines de niveau supérieur qui nécessiteraient une expression régulière compliquée qui devrait être mise à jour de temps en temps. Bien que la plupart des adresses e-mail soient traitées comme prévu, Match.Email correspond à certains cas non valides, par exemple un trait de soulignement dans le nom d’hôte, et ne correspond pas à certains cas valides, comme les adresses e-mail ou les adresses IP entre guillemets. En cas de besoin, il existe de nombreuses expressions régulières sur le web pour détecter une adresse e-mail vraiment légale. Testez toujours votre expression régulière pour vos besoins spécifiques avant de l’utiliser en production.

Si vous souhaitez voir l’expression régulière utilisée, évaluez la formule Text( Match.Email ). La première partie correspond aux caractères précédant le @ et exclut la ponctuation ASCII courante conformément à la norme RFC 822 et ses révisions, ainsi que la ponctuation de début et de fin Unicode pour faciliter l’extraction, par exemple (, [, “, « et 「. Il ne prend pas en charge l’utilisation rare et déconseillée de chaînes ou de commentaires entre guillemets. Après le @, les deuxième et troisième parties de l’expression régulière sont identiques et séparées par un ., ce qui garantit qu’il y a toujours au moins un . dans l’adresse. Ces parties excluent touta la ponctuation Unicode, excepté pour ., - et _. Les adresses IP ne sont pas prises en charge. Tout au long de l’adresse e-mail, les caractères internationaux et les emojis sont pris en charge.

Dans Power Apps, lorsque Power Fx 1.0 n’est pas utilisé, Match.Email et Match.Hyphen ont des définitions légèrement différentes. Match.Email est plus simple, mais ne convient pas à l’extraction d’une adresse e-mail, car il capture des espaces. Auparavant, Match.Hyphen était échappé en dehors d’une classe de caractère, ce qui est maintenant illégal.

NumberedSubMatches (Sous-correspondances numérotées)

Activé avec MatchOptions.NumberedSubMatches sans option en ligne. (?n) est pris en charge comme opposé de cette option pour des raisons de compatibilité et correspond à la valeur par défaut.

Par défaut, (...) ne capture pas, l’équivalent de ce que la plupart des systèmes appellent « capture explicite ». Pour effectuer une capture, utilisez une capture nommée avec (?<name>...) et une référence antérieure \k<name>. L’utilisation de captures nommées améliore les performances en ne capturant pas les groupes qui ne sont pas nécessaires, en améliorant la clarté en utilisant des noms et en n’étant pas sujette aux erreurs si la position des captures change.

Si vous disposez déjà d’une expression régulière, celle-ci peut dépendre des groupes capturés automatiquement et numérotés, y compris les références antérieures numérotées. Ce comportement est disponible en utilisant l’option MatchOptions.NumberedSubMatches.

Les sous-correspondances nommées et numérotées ne peuvent pas être utilisées ensemble. Étant donné que certaines implémentations traitent différemment une combinaison de groupes de capture numérotés et nommés, Power Fx l’interdit.

Sous-correspondances éventuellement vides

Comme indiqué dans l’introduction, les expressions régulières de Power Fx sont intentionnellement limitées aux fonctionnalités qui peuvent être implémentées de manière cohérente sur .NET, JavaScript et d’autres moteurs d’expressions régulières du langage de programmation. Les erreurs au moment de la création empêchent l’utilisation de fonctionnalités qui ne font pas partie de cet ensemble.

Un domaine qui peut être différent d’une implémentation à l’autre est la façon dont les sous-correspondances vides sont gérées. Par exemple, considérons l’expression régulière (?<submatch>a*)+ qui doit correspondre au texte a. Sur .NET, la sous-correspondance génère une chaîne de texte vide, tandis que sur JavaScript elle génère a. Les deux peuvent être considérés comme des implémentations correctes, car le quantificateur + peut être satisfait avec une chaîne vide puisque le contenu du groupe a un quantificateur *.

Pour éviter des résultats différents dans les implémentations Power Fx, les sous-correspondances qui peuvent être vides ne peuvent pas être utilisées avec un quantificateur. Voici des exemples de la façon dont une sous-correspondance peut être vide :

La sous-correspondance dans (?<submatch>a+)+ ne peut pas être vide car il doit y en avoir au moins un a dans la sous-correspondance, et elle est prise en charge.

Unicode

Les expressions régulières Power Fx utilisent des catégories Unicode pour définir \w, \d et \s, avec des catégories spécifiques disponibles via \p{..}.

Ces définitions peuvent varier d’une plateforme à l’autre. Par exemple, la norme Unicode est mise à jour de temps en temps avec de nouveaux caractères qui seront ensuite implémentés par les plateformes à leur propre rythme. Attendez-vous à des variations dans les résultats d’une plateforme à l’autre jusqu’à ce que toutes les plateformes soient mises à jour.

Les expressions régulières Power Fx garantissent que les informations de catégorie sont toujours disponibles pour le plan multilingue de base (caractères U+0 à U+ffff). Certaines plateformes n’implémentent pas de catégories pour les caractères dans le plan multilingue supplémentaire et au-delà (U+10000 à U+10ffff). Cette limitation n’est généralement pas un problème, car les caractères du plan multilingue de base sont les plus couramment utilisés. Utilisez des valeurs de caractère directement au lieu de catégories si votre scénario implique des caractères à U+10000 ou plus. Testez vos expressions régulières sur les plateformes que vous comptez utiliser.

De petites différences de cas limites peuvent exister entre les plates-formes. Par exemple, certaines plateformes peuvent ne pas voir ſ comme correspondant à s lorsque MatchOptions.IgnoreCase est appelé. Si ces caractères sont importants pour votre scénario, utilisez une classe de caractères comme [ſsS] pour ignorer la casse et inclure explicitement les caractères souhaités.