Sintaxe Regex

Artigo
09/03/2024

Aplica-se a: ✅Microsoft Fabric✅Azure Data Explorer ✅Azure Monitor✅Microsoft Sentinel

Este artigo fornece uma visão geral da sintaxe de expressão regular compatível com a KQL (Linguagem de Consulta Kusto).

Há vários operadores e funções KQL que executam correspondência, seleção e extração de strings com expressões regulares, como matches regex, parsee replace_regex().

No KQL, as expressões regulares devem ser codificadas como literais de cadeia de caracteres e seguir as regras de aspas de cadeia de caracteres. Por exemplo, a expressão \A regular é representada em KQL como "\\A". A barra invertida extra indica que a outra barra invertida faz parte da expressão \Aregular .

Sintaxe

As seções a seguir documentam a sintaxe de expressão regular com suporte do Kusto.

Combine um personagem

Padrão	Descrição
`.`	Qualquer caractere, exceto nova linha (inclui nova linha com sinalizador s)
`[0-9]`	Qualquer dígito ASCII
`\d`	Dígito (`\p{Nd}`)
`\D`	Não é um dígito
`\pX`	Classe de caracteres Unicode identificada por um nome de uma letra
`\p{Greek}`	Classe de caractere Unicode (categoria geral ou script)
`\PX`	Classe de caracteres Unicode negada identificada por um nome de uma letra
`\P{Greek}`	Classe de caractere Unicode negada (categoria geral ou script)

Classes de caracteres

Padrão	Descrição
`[xyz]`	Classe de caracteres correspondente a x, y ou z (união).
`[^xyz]`	Classe de caracteres correspondente a qualquer caractere, exceto x, y e z.
`[a-z]`	Classe de caracteres correspondente a qualquer caractere no intervalo de a-z.
`[[:alpha:]]`	Classe de caracteres ASCII ([A-Za-z])
`[[:^alpha:]]`	Classe de caracteres ASCII negada ([^A-Za-z])
`[x[^xyz]]`	Classe de caracteres aninhada/agrupada (correspondendo a qualquer caractere, exceto y e z)
`[a-y&&xyz]`	Interseção (correspondência x ou y)
`[0-9&&[^4]]`	Subtração usando interseção e negação (correspondência 0-9, exceto 4)
`[0-9--4]`	Subtração direta (correspondente 0-9, exceto 4)
`[a-g~~b-h]`	Diferença simétrica (correspondente `a` e `h` apenas)
`[\[\]]`	Escape em classes de caracteres (correspondência [ ou ])
`[a&&b]`	Classe de caracteres vazia que não corresponde a nada

Observação

Qualquer classe de caracteres nomeada pode aparecer dentro de uma classe de caracteres entre colchetes [...] . Por exemplo, [\p{Greek}[:digit:]] corresponde a qualquer dígito ASCII ou a qualquer ponto de código no Greek script. [\p{Greek}&&\pL] corresponde às letras gregas.

A precedência nas classes de caracteres é da mais vinculativa para a menos vinculativa:

Intervalos: [a-cd] == [[a-c]d]
União: [ab&&bc] == [[ab]&&[bc]]
Interseção, diferença, diferença simétrica: todos têm precedência equivalente e são avaliados da esquerda para a direita. Por exemplo, [\pL--\p{Greek}&&\p{Uppercase}] == [[\pL--\p{Greek}]&&\p{Uppercase}].
Negação: [^a-z&&b] == [^[a-z&&b]].

Composições

Padrão	Descrição
`xy`	Concatenação (`x` seguido por `y`)
`x\\|y`	Alternância (`x` ou `y` , preferir `x`)

Repetições

Padrão	Descrição
`x*`	Zero ou mais de x (ganancioso)
`x+`	Um ou mais de x (ganancioso)
`x?`	Zero ou um de x (ganancioso)
`x*?`	Zero ou mais de x (não ganancioso/preguiçoso)
`x+?`	Um ou mais de x (não ganancioso/preguiçoso)
`x??`	Zero ou um de x (não ganancioso/preguiçoso)
`x{n,m}`	Pelo menos n x e no máximo m x (ganancioso)
`x{n,}`	Pelo menos n x (ganancioso)
`x{n}`	Exatamente n x
`x{n,m}?`	Pelo menos n x e no máximo m x (não ganancioso / preguiçoso)
`x{n,}?`	Pelo menos n x (não ganancioso / preguiçoso)
`x{n}?`	Exatamente n x

Fósforos vazios

Padrão	Descrição
`^`	Início de um palheiro (ou início de linha com modo de várias linhas)
`$`	Fim de um palheiro (ou fim de linha com modo de várias linhas)
`\A`	Apenas o início de um palheiro (mesmo com o modo multilinha ativado)
`\z`	Apenas o final de um palheiro (mesmo com o modo de várias linhas ativado)
`\b`	Limite de palavra Unicode (`\w` de um lado e `\W`, `\A`, ou `\z` do outro)
`\B`	Não é um limite de palavra Unicode
`\b{start}`, `\<`	Limite de início de palavra Unicode (`\W\\|\A` à esquerda, `\w` à direita)
`\b{end}`, `\>`	Limite de fim de palavra Unicode (`\w` à esquerda, `\W\\|\z` à direita)
`\b{start-half}`	Metade de um limite de início de palavra Unicode (`\W\\|\A` à esquerda)
`\b{end-half}`	Metade de um limite de fim de palavra Unicode (`\W\\|\z` à direita)

Agrupamento e sinalizadores

Padrão	Descrição
`(exp)`	Grupo de captura numerado (indexado por parênteses de abertura)
`(?P<name>exp)`	Grupo de captura nomeado (também numerado) (os nomes devem ser alfanuméricos)
`(?<name>exp)`	Grupo de captura nomeado (também numerado) (os nomes devem ser alfanuméricos)
`(?:exp)`	Grupo sem captura
`(?flags)`	Definir sinalizadores dentro do grupo atual
`(?flags:exp)`	Definir sinalizadores para exp (sem captura)

Os nomes dos grupos de captura podem conter apenas pontos de código Unicode alfanuméricos ., pontos, sublinhados _e colchetes[ e ]. Os nomes devem começar com um ponto de código alfabético ou um _ ponto de código alfabético. Os pontos de código alfabéticos correspondem à propriedade Unicode, enquanto os Alphabetic Decimal_Numberpontos de código numéricos correspondem à união das categorias , Letter_Number e Other_Number geral.

Sinalizadores são caracteres únicos. Por exemplo, (?x) define o sinalizador x e (?-x) limpa o sinalizador x. Vários sinalizadores podem ser definidos ou limpos ao mesmo tempo: (?xy) define os x sinalizadores (?x-y) e y define o x sinalizador e limpa o y sinalizador. Por padrão, todos os sinalizadores são desativados, salvo indicação em contrário. Eles são:

Sinalizador	Descrição
`i`	Não diferencia maiúsculas de minúsculas: as letras correspondem a maiúsculas e minúsculas
`m`	Modo multilinha: `^` e `$` partida/fim da linha
`s`	Permitir ponto (.). para combinar `\n`
`R`	Habilita o modo CRLF: quando o modo multilinha está ativado, `\r\n` é usado
`U`	Troque o significado de `x` e `x?`
`u`	Suporte a Unicode (habilitado por padrão)
`x`	Modo detalhado, ignora espaços em branco e permite comentários de linha (começando com `#`)

Observe que, no modo detalhado, o espaço em branco é ignorado em todos os lugares, inclusive dentro das classes de caracteres. Para inserir espaços em branco, use sua forma de escape ou um literal hexadecimal. Por exemplo, \ ou \x20 para um espaço ASCII.

Observação

Os sinalizadores podem ser alternados dentro de um padrão. Por exemplo, a sintaxe a seguir usa uma correspondência que não diferencia maiúsculas de minúsculas para a primeira parte e uma correspondência que diferencia maiúsculas de minúsculas para a segunda parte: (?i)a+(?-i)b+.
a+ corresponde a ou a A, mas as b+ únicas correspondências b.
O modo multilinha significa ^ e $ não corresponde mais apenas no início ou no final da entrada, mas também no início ou no final das linhas. Observe que ^ corresponde após novas linhas, mesmo no final da entrada.
Quando o modo CRLF e o modo de várias linhas estão ativados, então ^ e $ correspondem a um \r e \n, mas nunca no meio de um \r\n.
O modo Unicode também pode ser desabilitado seletivamente, embora apenas quando o resultado não corresponder a UTF-8 inválido. Por exemplo, usar um limite de palavra ASCII em vez de um limite de palavra Unicode pode fazer com que algumas pesquisas regex sejam executadas mais rapidamente: (?-u:\b).+(?-u:\b) para corresponder $$abc$$a .

Sequências de escape

Padrão	Descrição
`\*`	Literal `*`, aplica-se a todos os ASCII, exceto `[0-9A-Za-z<>]`
`\a`	Sino (`\x07`)
`\f`	Alimentação de formulário (`\x0C`)
`\t`	Guia horizontal
`\n`	Nova linha
`\r`	Retorno de carro
`\v`	Guia vertical (`\x0B`)
`\A`	Partidas no início de um palheiro
`\z`	Fósforos no final de um palheiro
`\b`	Asserção de limite de palavra
`\B`	Asserção de limite de palavra negada
`\b{start}`, `\<`	Asserção de limite de início de palavra
`\b{end}`, `\>`	Asserção de limite de fim de palavra
`\b{start-half}`	Metade de uma declaração de limite no início da palavra
`\b{end-half}`	Metade de uma declaração de limite de fim de palavra
`\123`	Código de caractere octal, até três dígitos
`\x7F`	Código de caractere hexadecimal (exatamente dois dígitos)
`\x{10FFFF}`	Código de caractere hexadecimal correspondente a um ponto de código Unicode
`\u007F`	Código de caractere hexadecimal (exatamente quatro dígitos)
`\u{7F}`	Código de caractere hexadecimal correspondente a um ponto de código Unicode
`\U0000007F`	Código de caractere hexadecimal (exatamente oito dígitos)
`\U{7F}`	Código de caractere hexadecimal correspondente a um ponto de código Unicode
`\p{Letter}`	classe de caractere Unicode
`\P{Letter}`	Classe de caractere Unicode negada
`\d`, `\s`, `\w`	classe de caractere Perl
`\D`, `\S`, `\W`	Classe de caracteres Perl negada

Classes de caracteres Perl (amigável para Unicode)

Essas classes são baseadas nas definições fornecidas em UTS#18:

Padrão	Descrição
`\d`	Ddígitos (`\p{Nd}`)
`\D`	Não dígito
`\s`	Espaço em branco (`\p{White_Space}`)
`\S`	Não é espaço em branco
`\w`	Caractere de palavra (`\p{Alphabetic}\d` + `\p{Pc}\p{M}\p{Join_Control}` + + + )
`\W`	Não caractere de palavra

Classes de caracteres ASCII

Essas classes são baseadas nas definições fornecidas em UTS#18:

Padrão	Descrição
`[[:alnum:]]`	Alfanumérico (`[0-9A-Za-z]`)
`[[:alpha:]]`	Alfabético (`[A-Za-z]`)
`[[:ascii:]]`	ASCII (`[\x00-\x7F]`)
`[[:blank:]]`	Em branco (`[\t ]`)
`[[:cntrl:]]`	Controle (`[\x00-\x1F\x7F]`)
`[[:digit:]]`	Dígitos (`[0-9]`)
`[[:graph:]]`	Gráfico (`[!-~]`)
`[[:lower:]]`	Minúsculas (`[a-z]`)
`[[:print:]]`	Imprimível (`[ -~]`)
`[[:punct:]]`	Pontuação ([!-/:-@\[-`{-~])
`[[:space:]]`	Espaço em branco (`[\t\n\v\f\r ]`)
`[[:upper:]]`	Maiúsculas (`[A-Z]`)
`[[:word:]]`	Caracteres de palavras (`[0-9A-Za-z_]`)
`[[:xdigit:]]`	Dígito hexadecimal (`[0-9A-Fa-f]`)

Desempenho

Esta seção fornece algumas diretrizes sobre a velocidade e o uso de recursos de expressões regex.

O Unicode pode afetar o uso da memória e a velocidade de pesquisa

O regex KQL fornece suporte de primeira classe para Unicode. Em muitos casos, a memória extra necessária para dar suporte ao Unicode é insignificante e normalmente não afetará a velocidade de pesquisa.

A seguir estão alguns exemplos de classes de caracteres Unicode que podem afetar o uso da memória e a velocidade de pesquisa:

Uso de memória: o impacto do Unicode surge principalmente do uso de classes de caracteres Unicode. As classes de caracteres Unicode tendem a ser maiores em tamanho. Por exemplo, a classe de \w caracteres corresponde a cerca de 140.000 pontos de código distintos por padrão. Isso requer memória adicional e pode retardar a compilação regex. Se seus requisitos puderem ser atendidos pelo ASCII, é recomendável usar classes ASCII em vez de classes Unicode. A versão somente ASCII de \w pode ser expressa de várias maneiras, todas equivalentes.
```
[0-9A-Za-z_]
(?-u:\w)
[[:word:]]
[\w&&\p{ascii}]
```
Velocidade de pesquisa: o Unicode tende a ser tratado muito bem, mesmo ao usar grandes classes de caracteres Unicode. No entanto, alguns dos mecanismos regex internos mais rápidos não podem lidar com uma declaração de limite de palavra com reconhecimento de Unicode. Portanto, se você não precisar de declarações de limite de palavras com reconhecimento de Unicode, considere usar (?-u:\b) em vez de \b. O (?-u:\b) usa uma definição somente ASCII de um caractere de palavra, o que pode melhorar a velocidade de pesquisa.

Literais podem acelerar pesquisas

O regex KQL tem uma forte capacidade de reconhecer literais dentro de um padrão regex, o que pode acelerar significativamente as pesquisas. Se possível, incluir literais em seu padrão pode melhorar muito o desempenho da pesquisa. Por exemplo, no regex \w+@\w+, as primeiras ocorrências de são correspondidas e, em seguida, uma correspondência reversa é executada @ para \w+ encontrar a posição inicial.

Partilhar via