Sintassi regex

Articolo
09/03/2024

Si applica a: ✅Microsoft Fabric ✅Azure Esplora dati ✅ Azure Monitor✅Microsoft Sentinel

Questo articolo offre una panoramica della sintassi delle espressioni regolari supportata da Linguaggio di query Kusto (KQL).

Esistono diversi operatori e funzioni KQL che eseguono la corrispondenza di stringhe, la selezione e l'estrazione con espressioni regolari, ad esempio matches regex, parsee replace_regex().

In KQL le espressioni regolari devono essere codificate come valori letterali stringa e seguire le regole di virgolette di stringa. Ad esempio, l'espressione \A regolare è rappresentata in KQL come "\\A". La barra rovesciata aggiuntiva indica che l'altra barra rovesciata fa parte dell'espressione \Aregolare .

Sintassi

Nelle sezioni seguenti viene illustrata la sintassi dell'espressione regolare supportata da Kusto.

Trova la corrispondenza di un carattere

Modello	Descrizione
`.`	Qualsiasi carattere tranne la nuova riga (include una nuova riga con il flag s)
`[0-9]`	Qualsiasi cifra ASCII
`\d`	Cifra (`\p{Nd}`)
`\D`	Non una cifra
`\pX`	Classe di caratteri Unicode identificata da un nome di una lettera
`\p{Greek}`	Classe di caratteri Unicode (categoria generale o script)
`\PX`	Classe di caratteri Unicode negata identificata da un nome di una lettera
`\P{Greek}`	Classe di caratteri Unicode negata (categoria generale o script)

Classi di caratteri

Modello	Descrizione
`[xyz]`	Classe di caratteri corrispondente a x, y o z (unione).
`[^xyz]`	Classe di caratteri corrispondente a qualsiasi carattere tranne x, y e z.
`[a-z]`	Classe di caratteri corrispondente a qualsiasi carattere nell'intervallo a-z.
`[[:alpha:]]`	Classe di caratteri ASCII ([A-Za-z])
`[[:^alpha:]]`	Classe di caratteri ASCII negata ([^A-Za-z])
`[x[^xyz]]`	Classe di caratteri annidata/di raggruppamento (corrispondente a qualsiasi carattere ad eccezione di y e z)
`[a-y&&xyz]`	Intersezione (x o y corrispondente)
`[0-9&&[^4]]`	Sottrazione tramite intersezione e negazione (corrispondente a 0-9 eccetto 4)
`[0-9--4]`	Sottrazione diretta (corrispondente a 0-9, ad eccezione di 4)
`[a-g~~b-h]`	Differenza simmetrica (corrispondenza `a` e `h` solo)
`[\[\]]`	Escape nelle classi di caratteri (corrispondenti [ o ])
`[a&&b]`	Classe di caratteri vuota che non corrisponde a nulla

Nota

Qualsiasi classe di caratteri denominata può essere visualizzata all'interno di una classe di caratteri tra parentesi quadre [...] . Ad esempio, [\p{Greek}[:digit:]] corrisponde a qualsiasi cifra ASCII o a qualsiasi punto di codice nello Greek script. [\p{Greek}&&\pL] corrisponde alle lettere greche.

La precedenza nelle classi di caratteri è dalla maggior parte dell'associazione alla meno vincolante:

Gamme: [a-cd] == [[a-c]d]
Unione: [ab&&bc] == [[ab]&&[bc]]
Intersezione, differenza, differenza simmetrica: tutti hanno precedenza equivalente e vengono valutati da sinistra a destra. Ad esempio: [\pL--\p{Greek}&&\p{Uppercase}] == [[\pL--\p{Greek}]&&\p{Uppercase}].
Negazione: [^a-z&&b] == [^[a-z&&b]].

Compositi

Modello	Descrizione
`xy`	Concatenazione (`x` seguita da `y`)
`x\\|y`	Alternanza (`x` o `y` , preferisce `x`)

Ripetizioni

Modello	Descrizione
`x*`	Zero o più di x (greedy)
`x+`	Uno o più x (greedy)
`x?`	Zero o uno di x (greedy)
`x*?`	Zero o più di x (nongreedy/lazy)
`x+?`	Uno o più x (nongreedy/lazy)
`x??`	Zero o uno di x (nongreedy/lazy)
`x{n,m}`	Almeno n x e al massimo m x (greedy)
`x{n,}`	Almeno n x (greedy)
`x{n}`	Esattamente n x
`x{n,m}?`	Almeno n x e al massimo m x (nongreedy/lazy)
`x{n,}?`	Almeno n x (nongreedy/lazy)
`x{n}?`	Esattamente n x

Corrispondenze vuote

Modello	Descrizione
`^`	Inizio di un haystack (o start-of-line con modalità multiriga)
`$`	Fine di un haystack (o end-of-line con modalità multiriga)
`\A`	Solo l'inizio di un pagliaio (anche con la modalità multiriga abilitata)
`\z`	Solo la fine di un pagliaio (anche con la modalità multiriga abilitata)
`\b`	Limite di parole Unicode (`\w` su un lato e `\W`, `\A`o `\z` su un altro)
`\B`	Non un limite di parole Unicode
`\b{start}`, `\<`	Limite di inizio parola Unicode (`\W\\|\A` a sinistra, `\w` a destra)
`\b{end}`, `\>`	Limite di fine parola Unicode (`\w` a sinistra, `\W\\|\z` a destra)
`\b{start-half}`	Metà di un limite di inizio parola Unicode (`\W\\|\A` a sinistra)
`\b{end-half}`	Metà di un limite di fine parola Unicode (`\W\\|\z` a destra)

Raggruppamento e flag

Modello	Descrizione
`(exp)`	Gruppo di acquisizione numerato (indicizzato aprendo parentesi)
`(?P<name>exp)`	Gruppo di acquisizione denominato (anche numerato) (i nomi devono essere alfanumerici)
`(?<name>exp)`	Gruppo di acquisizione denominato (anche numerato) (i nomi devono essere alfanumerici)
`(?:exp)`	Gruppo non di acquisizione
`(?flags)`	Impostare i flag all'interno del gruppo corrente
`(?flags:exp)`	Impostare i flag per exp (non di acquisizione)

I nomi dei gruppi di acquisizione possono contenere solo punti di codice Unicode alfanumerici, punti ., caratteri di sottolineatura _e parentesi quadre[ e ]. I nomi devono iniziare con un _ punto di codice alfabetico o . I punti di codice alfabetici corrispondono alla Alphabetic proprietà Unicode, mentre i punti di codice numerici corrispondono all'unione delle Decimal_Numbercategorie generali Letter_Number e Other_Number .

I flag sono caratteri singoli. Ad esempio, (?x) imposta il flag x e (?-x) cancella il flag x. È possibile impostare o cancellare più flag contemporaneamente: (?xy) imposta i x flag e y e imposta il flag e (?x-y) cancella il x y flag. Per impostazione predefinita, tutti i flag sono disabilitati, se non diversamente specificato. Sono:

Flag	Descrizione
`i`	Senza distinzione tra maiuscole e minuscole: le lettere corrispondono sia maiuscole che minuscole
`m`	Modalità a più righe: `^` e `$` inizio/fine riga
`s`	Consenti punto (.). per trovare la corrispondenza `\n`
`R`	Abilita la modalità CRLF: quando viene abilitata la modalità multiriga, `\r\n` viene usata
`U`	Scambia il significato di `x` e `x?`
`u`	Supporto Unicode (abilitato per impostazione predefinita)
`x`	Modalità dettagliata, ignora gli spazi vuoti e consente i commenti di riga (a partire da `#`)

Si noti che in modalità dettagliata, gli spazi vuoti vengono ignorati ovunque, incluse le classi di caratteri. Per inserire spazi vuoti, utilizzare il formato di escape o un valore letterale esadecimale. Ad esempio, \ o \x20 per uno spazio ASCII.

Nota

I flag possono essere attivati o disattivati all'interno di un modello. Ad esempio, la sintassi seguente usa una corrispondenza senza distinzione tra maiuscole e minuscole per la prima parte e una corrispondenza con distinzione tra maiuscole e minuscole per la seconda parte: (?i)a+(?-i)b+.
a+corrisponde a a o A, ma corrisponde solo ba b+ .
La modalità a più righe indica ^ e $ non corrisponde più solo all'inizio o alla fine dell'input, ma anche all'inizio o alla fine delle righe. Si noti che ^ corrisponde dopo le nuove righe, anche alla fine dell'input.
Quando sia la modalità CRLF che la modalità multiriga sono abilitate, quindi ^ e $ corrispondono a \r e \n, ma mai al centro di un oggetto \r\n.
La modalità Unicode può anche essere disabilitata in modo selettivo, anche se solo quando il risultato non corrisponde a UTF-8 non valido. Ad esempio, l'uso di un limite di parole ASCII anziché un limite di parole Unicode potrebbe rendere più veloci alcune ricerche regex: (?-u:\b).+(?-u:\b) per trovare una corrispondenza $$abc$$con .

Sequenze di escape

Modello	Descrizione
`\*`	Valore letterale `*`, si applica a tutti i valori ASCII tranne `[0-9A-Za-z<>]`
`\a`	Bell (`\x07`)
`\f`	Feed modulo (`\x0C`)
`\t`	Tabulazione orizzontale
`\n`	Nuova riga
`\r`	Ritorno a capo
`\v`	Scheda Verticale (`\x0B`)
`\A`	Corrisponde all'inizio di un pagliaio
`\z`	Corrisponde alla fine di un pagliaio
`\b`	Asserzione limite di Word
`\B`	Asserzione limite parola negata
`\b{start}`, `\<`	Asserzione limite iniziale di parola
`\b{end}`, `\>`	Asserzione limite di fine parola
`\b{start-half}`	Metà di un'asserzione limite iniziale di parola
`\b{end-half}`	Metà di un'asserzione limite di fine parola
`\123`	Codice carattere ottale, fino a tre cifre
`\x7F`	Codice carattere esadecimale (esattamente due cifre)
`\x{10FFFF}`	Codice carattere esadecimale corrispondente a un punto di codice Unicode
`\u007F`	Codice carattere esadecimale (esattamente quattro cifre)
`\u{7F}`	Codice carattere esadecimale corrispondente a un punto di codice Unicode
`\U0000007F`	Codice carattere esadecimale (esattamente otto cifre)
`\U{7F}`	Codice carattere esadecimale corrispondente a un punto di codice Unicode
`\p{Letter}`	classe di caratteri Unicode
`\P{Letter}`	Classe di caratteri Unicode negata
`\d`, `\s`, `\w`	classe di caratteri Perl
`\D`, `\S`, `\W`	Classe di caratteri Perl negata

Classi di caratteri perl (descrittivo Unicode)

Queste classi sono basate sulle definizioni fornite in UTS#18:

Modello	Descrizione
`\d`	Ddigit (`\p{Nd}`)
`\D`	Non cifra
`\s`	Spazi vuoti (`\p{White_Space}`)
`\S`	Non spazi vuoti
`\w`	Carattere parola (`\p{Alphabetic}\p{Join_Control}` + + + `\p{Pc}` + `\p{M}\d`)
`\W`	Carattere non parola

Classi di caratteri ASCII

Queste classi sono basate sulle definizioni fornite in UTS#18:

Modello	Descrizione
`[[:alnum:]]`	Alfanumerico (`[0-9A-Za-z]`)
`[[:alpha:]]`	Alfabetico (`[A-Za-z]`)
`[[:ascii:]]`	ASCII (`[\x00-\x7F]`)
`[[:blank:]]`	Vuoto (`[\t ]`)
`[[:cntrl:]]`	Controllo (`[\x00-\x1F\x7F]`)
`[[:digit:]]`	Cifre (`[0-9]`)
`[[:graph:]]`	Grafico (`[!-~]`)
`[[:lower:]]`	Minuscolo (`[a-z]`)
`[[:print:]]`	Stampabile (`[ -~]`)
`[[:punct:]]`	Punteggiatura ([!-/:-@\[-`{-~])
`[[:space:]]`	Spazi vuoti (`[\t\n\v\f\r ]`)
`[[:upper:]]`	Maiuscole (`[A-Z]`)
`[[:word:]]`	Caratteri di parola (`[0-9A-Za-z_]`)
`[[:xdigit:]]`	Cifra esadecimale (`[0-9A-Fa-f]`)

Prestazioni

Questa sezione fornisce alcune indicazioni sulla velocità e sull'utilizzo delle risorse delle espressioni regex.

Unicode può influire sull'utilizzo della memoria e sulla velocità di ricerca

L'espressione regolare KQL fornisce il supporto di prima classe per Unicode. In molti casi, la memoria aggiuntiva necessaria per supportare Unicode è trascurabile e in genere non influisce sulla velocità di ricerca.

Di seguito sono riportati alcuni esempi di classi di caratteri Unicode che possono influire sull'utilizzo della memoria e sulla velocità di ricerca:

Utilizzo della memoria: l'impatto di Unicode dipende principalmente dall'uso di classi di caratteri Unicode. Le classi di caratteri Unicode tendono ad avere dimensioni maggiori. Ad esempio, la \w classe di caratteri corrisponde a circa 140.000 punti di codice distinti per impostazione predefinita. Ciò richiede memoria aggiuntiva e può rallentare la compilazione regex. Se i requisiti possono essere soddisfatti da ASCII, è consigliabile usare classi ASCII anziché classi Unicode. La versione solo ASCII di \w può essere espressa in diversi modi, tutte equivalenti.
```
[0-9A-Za-z_]
(?-u:\w)
[[:word:]]
[\w&&\p{ascii}]
```
Velocità di ricerca: Unicode tende a essere gestito abbastanza bene, anche quando si usano classi di caratteri Unicode di grandi dimensioni. Tuttavia, alcuni dei motori regex interni più veloci non possono gestire un'asserzione di limiti di parola compatibile con Unicode. Pertanto, se non sono necessarie asserzioni di limiti delle parole con riconoscimento Unicode, è consigliabile usare (?-u:\b) anziché \b. (?-u:\b) usa una definizione solo ASCII di un carattere di parola, che può migliorare la velocità di ricerca.

I valori letterali possono accelerare le ricerche

L'espressione regolare KQL ha una forte capacità di riconoscere valori letterali all'interno di un modello regex, che può velocizzare notevolmente le ricerche. Se possibile, l'inclusione di valori letterali nel modello può migliorare notevolmente le prestazioni di ricerca. Ad esempio, nell'espressione \w+@\w+regolare le prime occorrenze di @ vengono confrontate e quindi viene eseguita una corrispondenza inversa per \w+ trovare la posizione iniziale.

Condividi tramite