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), qui est la syntaxe de la bibliothèque RE2.
Il existe un certain nombre d’opérateurs et de fonctions KQL qui effectuent la mise en correspondance de chaînes, la sélection et l’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 guillemets de chaîne. Par exemple, l’expression \A régulière RE2 est représentée dans KQL sous la forme "\\A". La barre oblique inverse supplémentaire indique que l’autre barre oblique inverse fait partie de l’expression \Arégulière .
Vue d’ensemble de la syntaxe
Le tableau suivant présente la syntaxe d’expression régulière RE2, qui est utilisée pour écrire des expressions régulières dans Kusto.
Élément Syntax
Description
Littéraux uniques
Les caractères uniques correspondent eux-mêmes, à l’exception des métacharacteurs (* + ? ( ) |), qui ont des significations uniques, comme décrit dans les lignes suivantes.
Métacharacteurs
Pour mettre en correspondance un métacharacteur littéralement, placez-le dans une séquence d’échappement avec des barres obliques inverses. Par exemple, l’expression \+ régulière correspond à un caractère littéral plus (+).
Alternative
Alternez deux expressions avec | pour créer une nouvelle expression qui correspond à l’une des expressions. Par exemple, e1 | e2 correspond à e1 ou e2.
Concaténation
Concaténer deux expressions pour créer une nouvelle expression qui correspond à la première expression suivie de la seconde. Par exemple, e1e2 correspond à e1 suivi de e2.
Répétition
Les métacharacteurs ?, +et * sont des opérateurs de répétition. Par exemple, e1? correspond à zéro ou à une occurrence de e1, e1+ correspond à une ou plusieurs occurrences de e1et e1* correspond à une séquence de zéro ou plusieurs chaînes, éventuellement différentes, qui correspondent e1à .
Notes
Les opérateurs d’expression régulière sont évalués dans cet ordre : l’alternance (|), la concaténation (expressions côte à côte) et la répétition (?, +, *). Utilisez des parenthèses pour contrôler l’ordre d’évaluation.
Expressions à caractère unique
Exemple
Description
.
n’importe quel caractère, y compris éventuellement un caractère de nouvelle ligne (s=vrai)
classe de caractères Unicode exclue (nom d’une lettre)
\P{Greek}
classe de caractères Unicode exclue
Composites
Exemple
Description
xy
x suivi de y
x\|y
x ou y (préférez x)
Répétitions
Exemple
Description
x*
zéro ou plus x, préférez plus
x+
un ou plusieurs x, préférez plus
x?
zéro ou un x, préférez un
x{n,m}
n ou n+1 ou ... ou mx, préférez plus
x{n,}
n ou plus x, préférez plus
x{n}
Exactement nx
x*?
zéro ou plus x, préférez moins
x+?
un ou plusieurs x, préférez moins
x??
zéro ou un x, préférez zéro
x{n,m}?
n ou n+1 ou ... ou mx, préférez moins
x{n,}?
n ou plus x, préférez moins
x{n}?
Exactement nx
x{}
(≡ x*) (NON PRIS EN CHARGE) VIM
x{-}
(≡ x*?) (NON PRIS EN CHARGE) VIM
x{-n}
(≡ x{n}?) (NON PRIS EN CHARGE) VIM
x=
(≡ x?) (NON PRIS EN CHARGE) VIM
Restriction d’implémentation : les formulaires de comptage x{n,m}, x{n,} et x{n} rejettent les formulaires qui créent un nombre minimal ou maximal de répétitions supérieur à 1 000. Les répétitions illimitées ne sont pas soumises à cette restriction.
Répétitions possessives
Exemple
Description
x*+
zéro ou plus x, possessif (NON PRIS EN CHARGE)
x++
un ou plusieurs x, possessifs (NON PRIS EN CHARGE)
x?+
zéro ou un x, possessif (NON PRIS EN CHARGE)
x{n,m}+
n Ou... ou mx, possessif (NON PRIS EN CHARGE)
x{n,}+
n ou plus x, possessif (NON PRIS EN CHARGE)
x{n}+
exact nx, possessif (NON PRIS EN CHARGE)
Regroupement
Exemple
Description
(re)
groupe de capture numéroté (sous-correspondance)
(?P<name>re)
nommé & groupe de capture numéroté (sous-correspondance)
(?<name>re)
nommé & groupe de capture numéroté (sous-correspondance) (NON PRIS EN CHARGE)
(?'name're)
nommé & groupe de capture numéroté (sous-correspondance) (NON PRIS EN CHARGE)
(?:re)
groupe non capturant
(?flags)
définir des indicateurs dans le groupe actif ; non capturation
(?flags:re)
définir des indicateurs pendant la re ; non capturation
(?#text)
commentaire (NON PRIS EN CHARGE)
(?\|x\|y\|z)
Réinitialisation de la numérotation des branches (NON PRIS EN CHARGE)
(?>re)
correspondance possessive de re (NON PRIS EN CHARGE)
re@>
correspondance possessive de re (NON PRIS EN CHARGE) VIM
%(re)
groupe non capturing (NON PRIS EN CHARGE) VIM
Indicateurs
Exemple
Description
i
respect de la casse (valeur par défaut false)
m
mode multiligne : ^ et $ mettre en correspondance la ligne de début/fin en plus du texte de début/fin (valeur false par défaut)
s
let . correspond \n (valeur par défaut false)
U
ungreedy : permuter la signification de x* et x*?, x+ et x+?, etc (false par défaut)
La syntaxe d’indicateur est xyz (set) ou -xyz (clear) ou xy-z (set xy, clear z).
Pour utiliser des indicateurs, vous devez spécifier les kind paramètres et flags , comme suit : kind=regexflags=regexFlags.
Chaînes vides
Exemple
Description
^
au début du texte ou de la ligne (m=true)
$
à la fin du texte (par exemple \z )\Z ou de la ligne (m=true)
\A
au début du texte
\b
à la limite de mots ASCII (\w d’un côté et \W, \Aou \z de l’autre)
\B
pas au niveau de la limite de mots ASCII
\g
au début du sous-texte recherché (NON PRIS EN CHARGE) PCRE
\G
à la fin de la dernière correspondance (NON PRIS EN CHARGE) PERL
\Z
à la fin du texte ou avant la nouvelle ligne à la fin du texte (NON PRIS EN CHARGE)
\z
à la fin du texte
(?=re)
avant la correspondance de re texte (NON PRIS EN CHARGE)
(?!re)
avant le texte non correspondant re (NON PRIS EN CHARGE)
(?<=re)
après la correspondance de re texte (NON PRIS EN CHARGE)
(?<!re)
après que le texte ne correspond re pas (NON PRIS EN CHARGE)
re&
avant la correspondance de re texte (NON PRIS EN CHARGE) VIM
re@=
avant la correspondance de re texte (NON PRIS EN CHARGE) VIM
re@!
avant le texte ne correspondant re pas (NON PRIS EN CHARGE) VIM
re@<=
après la correspondance de re texte (NON PRIS EN CHARGE) VIM
re@<!
après le texte ne correspondant re pas (NON PRIS EN CHARGE) VIM
\zs
définit le début de la correspondance (= \K) (NON PRIS EN CHARGE) VIM
\ze
définit la fin de la correspondance (NON PRIS EN CHARGE) VIM
\%^
début du fichier (NON PRIS EN CHARGE) VIM
\%$
FIN DU FICHIER (NON PRIS EN CHARGE) VIM
\%V
sur l’écran (NON PRIS EN CHARGE) VIM
\%#
position du curseur (NON PRIS EN CHARGE) VIM
\%'m
position de marque m (NON PRIS EN CHARGE) VIM
\%23l
à la ligne 23 (NON PRIS EN CHARGE) VIM
\%23c
dans la colonne 23 (NON PRIS EN CHARGE) VIM
\%23v
dans la colonne virtuelle 23 (NON PRIS EN CHARGE) VIM
Séquences d’échappement
Exemple
Description
\a
cloche (≡ \007)
\f
flux de formulaire (≡ \014)
\t
onglet horizontal (≡ \011)
\n
newline (≡ \012)
\r
retour chariot (≡ \015)
\v
caractère de tabulation vertical (≡ \013)
\*
littéral *, pour tout caractère de ponctuation *
\123
code caractère octal (jusqu’à trois chiffres)
\x7F
code de caractère hexadécimal (exactement deux chiffres)
\x{10FFFF}
code de caractères hexadécimal
\C
mettre en correspondance un seul octet, même en mode UTF-8
\Q...\E
texte ... littéral même si ... a une ponctuation
\1
backreference (NON PRIS EN CHARGE)
\b
backspace (NON PRIS EN CHARGE) (utilisez \010)
\cK
char de contrôle ^K (NON PRIS EN CHARGE) (utiliser \001 , etc.)
\e
escape (NON PRIS EN CHARGE) (utilisez \033)
\g1
backreference (NON PRIS EN CHARGE)
\g{1}
backreference (NON PRIS EN CHARGE)
\g{+1}
backreference (NON PRIS EN CHARGE)
\g{-1}
backreference (NON PRIS EN CHARGE)
\g{name}
named backreference (NOT SUPPORTED)
\g<name>
appel de sous-routine (NON PRIS EN CHARGE)
\g'name'
appel de sous-routine (NON PRIS EN CHARGE)
\k<name>
named backreference (NOT SUPPORTED)
\k'name'
named backreference (NOT SUPPORTED)
\lX
minuscules X (NON PRIS EN CHARGE)
\ux
majuscules x (NON PRIS EN CHARGE)
\L...\E
texte ... minuscule (NON PRIS EN CHARGE)
\K
réinitialiser le début de $0 (NON PRIS EN CHARGE)
\N{name}
caractère Unicode nommé (NON PRIS EN CHARGE)
\R
saut de ligne (NON PRIS EN CHARGE)
\U...\E
texte ... majuscule (NON PRIS EN CHARGE)
\X
séquence Unicode étendue (NON PRIS EN CHARGE)
\%d123
caractère décimal 123 (NON PRIS EN CHARGE) VIM
\%xFF
caractère hexadécimal FF (NON PRIS EN CHARGE) VIM
\%o123
caractère octal 123 (NON PRIS EN CHARGE) VIM
\%u1234
Caractère Unicode 0x1234 (NON PRIS EN CHARGE) VIM
\%U12345678
VIM de caractères Unicode 0x12345678 (NON PRIS EN CHARGE)
Éléments de classe de caractères
Exemple
Description
x
caractère unique
A-Z
plage de caractères (inclusive)
\d
classe de caractères Perl
[:foo:]
Classe de caractères ASCII foo
\p{Foo}
Classe de caractères Unicode Foo
\pF
Classe F de caractères Unicode (nom d’une lettre)
Classes de caractères nommées en tant qu’éléments de classe de caractères
Exemple
Description
[\d]
chiffres (≡ \d)
[^\d]
pas de chiffres (≡ \D)
[\D]
pas de chiffres (≡ \D)
[^\D]
not digits (≡ \d)
[[:name:]]
classe ASCII nommée à l’intérieur de la classe de caractères (≡ [:name:])
[^[:name:]]
classe ASCII nommée à l’intérieur de la classe de caractères non annulée (≡ [:^name:])
[\p{Name}]
propriété Unicode nommée à l’intérieur de la classe de caractères (≡ \p{Name})
[^\p{Name}]
propriété Unicode nommée à l’intérieur de la classe de caractères non annulée (≡ \P{Name})
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.