Syntaxe des expressions régulières

Article
09/03/2024

S’applique à : ✅Microsoft Fabric ✅Azure Data Explorer✅Azure Monitor ✅Microsoft Sentinel

Cet article fournit une vue d’ensemble de la syntaxe d’expression régulière prise en charge par Langage de requête Kusto (KQL).

Il existe un certain nombre d’opérateurs et de fonctions KQL qui effectuent des correspondances de chaîne, de sélection et d’extraction avec des expressions régulières, telles que matches regex, parseet replace_regex().

Dans KQL, les expressions régulières doivent être encodées en tant que littéraux de chaîne et suivre les règles de guillemet de chaîne. Par exemple, l’expression \A régulière est représentée dans KQL en tant que "\\A". La barre oblique inverse supplémentaire indique que l’autre barre oblique inverse fait partie de l’expression \Arégulière.

Syntaxe

Les sections suivantes documentent la syntaxe d’expression régulière prise en charge par Kusto.

Mettre en correspondance un caractère

Modèle	Description
`.`	Tout caractère sauf nouvelle ligne (inclut une nouvelle ligne avec indicateur s)
`[0-9]`	N’importe quel chiffre ASCII
`\d`	Chiffre (`\p{Nd}`)
`\D`	Pas un chiffre
`\pX`	Classe de caractères Unicode identifiée par un nom à une lettre
`\p{Greek}`	Classe de caractères Unicode (catégorie générale ou script)
`\PX`	Classe de caractères Unicode negated identifiée par un nom à une lettre
`\P{Greek}`	Classe de caractères Unicode negated (catégorie générale ou script)

Classes de caractères

Modèle	Description
`[xyz]`	Classe de caractères correspondant à x, y ou z (union).
`[^xyz]`	Classe de caractères correspondant à n’importe quel caractère, sauf x, y et z.
`[a-z]`	Classe de caractères correspondant à n’importe quel caractère dans la plage a-z.
`[[:alpha:]]`	Classe de caractères ASCII ([A-Za-z])
`[[:^alpha:]]`	Classe de caractères ASCII negated ([^A-Za-z])
`[x[^xyz]]`	Classe de caractères imbriquée/groupée (correspondant à n’importe quel caractère sauf y et z)
`[a-y&&xyz]`	Intersection (correspondance x ou y)
`[0-9&&[^4]]`	Soustraction à l’aide de l’intersection et de la négation (correspondance 0-9 à l’exception de 4)
`[0-9--4]`	Soustraction directe (correspondant 0-9 sauf 4)
`[a-g~~b-h]`	Différence symétrique (correspondance `a` et `h` uniquement)
`[\[\]]`	Échappement dans les classes de caractères (correspondance [ ou ])
`[a&&b]`	Classe de caractères vide correspondant à rien

Remarque

Toute classe de caractères nommée peut apparaître à l’intérieur d’une classe de caractères entre crochets [...] . Par exemple, [\p{Greek}[:digit:]] correspond à n’importe quel chiffre ASCII ou tout point de code dans le Greek script. [\p{Greek}&&\pL] correspond aux lettres grecques.

La priorité dans les classes de caractères est comprise entre la plupart des liaisons et la liaison minimale :

Gammes: [a-cd] == [[a-c]d]
Union: [ab&&bc] == [[ab]&&[bc]]
Intersection, différence, différence symétrique : toutes ont une priorité équivalente et sont évaluées de gauche à droite. Par exemple : [\pL--\p{Greek}&&\p{Uppercase}] == [[\pL--\p{Greek}]&&\p{Uppercase}].
Négation : [^a-z&&b] == [^[a-z&&b]].

Composites

Modèle	Description
`xy`	Concaténation (`x` suivie de `y`)
`x\\|y`	Alternation (`x` ou `y` , préférer `x`)

Répétitions

Modèle	Description
`x*`	Zéro ou plus de x (gourmand)
`x+`	Un ou plusieurs x (gourmands)
`x?`	Zéro ou l’un des x (gourmand)
`x*?`	Zéro ou plus de x (non agrégée/différée)
`x+?`	Une ou plusieurs de x (non-agrégées/différées)
`x??`	Zéro ou l’un des x (ungreedy/lazy)
`x{n,m}`	Au moins n x et au plus m x (gourmand)
`x{n,}`	Au moins n x (gourmand)
`x{n}`	Exactement n x
`x{n,m}?`	Au moins n x et au plus m x (nongreedy/lazy)
`x{n,}?`	Au moins n x (ungreedy/lazy)
`x{n}?`	Exactement n x

Correspondances vides

Modèle	Description
`^`	Début d’une botte de foin (ou début de ligne avec mode multiligne)
`$`	Fin d’une pile de foin (ou fin de ligne avec mode multiligne)
`\A`	Seul le début d’une botte de foin (même avec le mode multiligne activé)
`\z`	Seule la fin d’une botte de foin (même avec le mode multiligne activé)
`\b`	Limite de mots Unicode (`\w` d’un côté et `\W`, `\A`ou `\z` d’autre)
`\B`	Pas de limite de mot Unicode
`\b{start}`, `\<`	Limite de début de mot Unicode (`\W\\|\A` à gauche, `\w` à droite)
`\b{end}`, `\>`	Limite de fin de mot Unicode (`\w` à gauche, `\W\\|\z` à droite)
`\b{start-half}`	Moitié d’une limite de début de mot Unicode (`\W\\|\A` à gauche)
`\b{end-half}`	Moitié d’une limite de fin de mot Unicode (`\W\\|\z` à droite)

Regroupement et indicateurs

Modèle	Description
`(exp)`	Groupe de capture numéroté (indexé par parenthèse ouvrante)
`(?P<name>exp)`	Groupe de capture nommé (également numéroté) (les noms doivent être alphanumériques)
`(?<name>exp)`	Groupe de capture nommé (également numéroté) (les noms doivent être alphanumériques)
`(?:exp)`	Groupe de non-capture
`(?flags)`	Définir des indicateurs dans le groupe actuel
`(?flags:exp)`	Définir des indicateurs pour exp (sans capture)

Les noms de groupes de capture peuvent contenir uniquement des points de code Unicode alphanumériques, des points., des traits de soulignement et des crochets _[ et ]. Les noms doivent commencer par un point de code alphabétique ou un _ point de code alphabétique. Les points de code alphabétiques correspondent à la Alphabetic propriété Unicode, tandis que les points de code numériques correspondent à l’union des Decimal_Numbercatégories générales Letter_Number et Other_Number des catégories générales.

Les indicateurs sont des caractères uniques. Par exemple, (?x) définit l’indicateur x et (?-x) efface l’indicateur x. Plusieurs indicateurs peuvent être définis ou effacés en même temps : (?xy) définit x à la fois les x indicateurs et y les indicateurs et (?x-y) efface l’indicateury. Par défaut, tous les indicateurs sont désactivés, sauf indication contraire. Il s'agit de :

Indicateur	Description
`i`	Respect de la casse : les lettres correspondent à la fois en majuscules et en minuscules
`m`	Mode multiligne : `^` et `$` mettre en correspondance le début/la fin de ligne
`s`	Autoriser point (.). à mettre en correspondance `\n`
`R`	Active le mode CRLF : lorsque le mode multiligne est activé, `\r\n` est utilisé
`U`	Permuter la signification et `xx?`
`u`	Prise en charge Unicode (activée par défaut)
`x`	Mode détaillé, ignore les espaces blancs et autorise les commentaire de ligne s (à partir de `#`)

Notez qu’en mode détaillé, les espaces blancs sont ignorés partout, y compris dans les classes de caractères. Pour insérer un espace blanc, utilisez sa forme d’échappement ou un littéral hexadécimal. Par exemple, \ ou \x20 pour un espace ASCII.

Remarque

Les indicateurs peuvent être activés dans un modèle. Par exemple, la syntaxe suivante utilise une correspondance sans respect de la casse pour la première partie et une correspondance respectant la casse pour la deuxième partie : (?i)a+(?-i)b+.
a+ correspond à ou a A, mais les b+ seules correspondances b.
Le mode multiligne signifie ^ et $ ne correspond plus uniquement au début ou à la fin de l’entrée, mais également au début ou à la fin des lignes. Notez que les ^ correspondances après de nouvelles lignes, même à la fin de l’entrée.
Lorsque le mode CRLF et le mode multiligne sont activés, puis ^ $ correspondent à l’un ou l’autre \r , \nmais jamais au milieu d’un \r\n.
Le mode Unicode peut également être désactivé de manière sélective, bien que seul le résultat ne corresponde pas à UTF-8 non valide. Par exemple, l’utilisation d’une limite de mots ASCII au lieu d’une limite de mot Unicode peut rendre certaines recherches régulières exécutées plus rapidement : (?-u:\b).+(?-u:\b) pour qu’elles correspondent $$abc$$.

Séquences d’échappement

Modèle	Description
`\*`	Littéral `*`, s’applique à tous les ASCII, sauf `[0-9A-Za-z<>]`
`\a`	Cloche (`\x07`)
`\f`	Flux de formulaire (`\x0C`)
`\t`	Tabulation horizontale
`\n`	Nouvelle ligne
`\r`	Retour chariot
`\v`	Onglet vertical (`\x0B`)
`\A`	Correspond au début d’une botte de foin
`\z`	Correspondances à la fin d’une botte de foin
`\b`	Assertion de limite Word
`\B`	Assertion de limite de mot negated
`\b{start}`, `\<`	Assertion de limite de début de mot
`\b{end}`, `\>`	Assertion de limite de fin de mot
`\b{start-half}`	Moitié d’une assertion de limite de début de mot
`\b{end-half}`	Moitié d’une assertion de limite de fin de mot
`\123`	Code de caractère octal, jusqu’à trois chiffres
`\x7F`	Code de caractère hexadécimal (exactement deux chiffres)
`\x{10FFFF}`	Code de caractère hexadécimal correspondant à un point de code Unicode
`\u007F`	Code de caractère hexadécimal (exactement quatre chiffres)
`\u{7F}`	Code de caractère hexadécimal correspondant à un point de code Unicode
`\U0000007F`	Code de caractère hexadécimal (exactement huit chiffres)
`\U{7F}`	Code de caractère hexadécimal correspondant à un point de code Unicode
`\p{Letter}`	classe de caractères Unicode
`\P{Letter}`	Classe de caractères Unicode negated
`\d`, , `\s\w`	classe de caractères Perl
`\D`, , `\S\W`	Classe de caractères Perl negated

Classes de caractères Perl (conviviales Unicode)

Ces classes sont basées sur les définitions fournies dans UTS#18 :

Modèle	Description
`\d`	Ddigit (`\p{Nd}`)
`\D`	Pas de chiffre
`\s`	Espace blanc (`\p{White_Space}`)
`\S`	Pas d’espace blanc
`\w`	Caractère Word (`\p{Alphabetic}\p{Join_Control}` + + + `\p{Pc}` + `\p{M}\d`)
`\W`	Caractère pas de mot

Classes de caractères ASCII

Ces classes sont basées sur les définitions fournies dans UTS#18 :

Modèle	Description
`[[:alnum:]]`	Alphanumérique (`[0-9A-Za-z]`)
`[[:alpha:]]`	Alphabétique (`[A-Za-z]`)
`[[:ascii:]]`	ASCII (`[\x00-\x7F]`)
`[[:blank:]]`	Vide (`[\t ]`)
`[[:cntrl:]]`	Contrôle (`[\x00-\x1F\x7F]`)
`[[:digit:]]`	Chiffres (`[0-9]`)
`[[:graph:]]`	Graphique (`[!-~]`)
`[[:lower:]]`	Minuscules (`[a-z]`)
`[[:print:]]`	Imprimable (`[ -~]`)
`[[:punct:]]`	Ponctuation ([!-/:-@\[-`{-~])
`[[:space:]]`	Espace blanc (`[\t\n\v\f\r ]`)
`[[:upper:]]`	Majuscules (`[A-Z]`)
`[[:word:]]`	Caractères word (`[0-9A-Za-z_]`)
`[[:xdigit:]]`	Chiffre hexadécimal (`[0-9A-Fa-f]`)

Performances

Cette section fournit des conseils sur la vitesse et l’utilisation des ressources des expressions regex.

Unicode peut avoir un impact sur l’utilisation de la mémoire et la vitesse de recherche

KQL regex fournit une prise en charge de première classe pour Unicode. Dans de nombreux cas, la mémoire supplémentaire nécessaire pour prendre en charge Unicode est négligeable et n’affecte généralement pas la vitesse de recherche.

Voici quelques exemples de classes de caractères Unicode qui peuvent avoir un impact sur l’utilisation de la mémoire et la vitesse de recherche :

Utilisation de la mémoire : l’impact d’Unicode provient principalement de l’utilisation de classes de caractères Unicode. Les classes de caractères Unicode ont tendance à être plus volumineuses. Par exemple, la \w classe de caractères correspond à environ 140 000 points de code distincts par défaut. Cela nécessite une mémoire supplémentaire et peut ralentir la compilation de regex. Si vos besoins peuvent être satisfaits par ASCII, il est recommandé d’utiliser des classes ASCII au lieu de classes Unicode. La version ASCII seule de \w peut être exprimée de plusieurs façons, toutes équivalentes.
```
[0-9A-Za-z_]
(?-u:\w)
[[:word:]]
[\w&&\p{ascii}]
```
Vitesse de recherche : Unicode a tendance à être géré assez bien, même lors de l’utilisation de classes de caractères Unicode volumineuses. Toutefois, certains des moteurs regex internes plus rapides ne peuvent pas gérer une assertion de limite de mots prenant en charge Unicode. Par conséquent, si vous n’avez pas besoin d’assertions de limites de mots prenant en charge Unicode, vous pouvez envisager d’utiliser (?-u:\b) au lieu de \b. L’utilisation (?-u:\b) d’une définition ASCII uniquement d’un caractère de mot, qui peut améliorer la vitesse de recherche.

Les littéraux peuvent accélérer les recherches

KQL regex a une capacité forte à reconnaître des littéraux au sein d’un modèle regex, ce qui peut accélérer considérablement les recherches. Si possible, l’inclusion de littéraux dans votre modèle peut considérablement améliorer les performances de recherche. Par exemple, dans le regex \w+@\w+, les premières occurrences sont @ mises en correspondance, puis une correspondance inverse est effectuée pour \w+ rechercher la position de départ.

Partage via