about_Regular_Expressions

Descrição breve

Descreve expressões regulares no PowerShell.

Descrição longa

Uma expressão regular é um padrão usado para corresponder ao texto. Ele pode ser composto de caracteres literais, operadores e outras construções.

Este artigo demonstra a sintaxe de expressão regular no PowerShell. O PowerShell tem vários operadores e cmdlets que usam expressões regulares. Você pode ler mais sobre sua sintaxe e uso nos links abaixo.

• Select-String
• -match e -replace operadores
• -operador de divisão
• instrução switch com opção -regex

As expressões regulares do PowerShell não diferenciam maiúsculas de minúsculas por padrão. Cada método mostrado acima tem uma maneira diferente de forçar a diferenciação de maiúsculas e minúsculas.

• Para Select-String, use o parâmetro CaseSensitive .
• Para operadores que usam expressões regulares, use a versão que diferencia maiúsculas de minúsculas: -cmatch, -creplace, ou -csplit
• Para a switch instrução, use a -casesensitive opção

Literais de caracteres

Uma expressão regular pode ser um caractere literal ou uma cadeia de caracteres. A expressão faz com que o mecanismo corresponda exatamente ao texto especificado.

# This statement returns true because book contains the string "oo"
'book' -match 'oo'

Classes de caracteres

Embora os literais de caracteres funcionem se você souber o padrão exato, as classes de caracteres permitem que você seja menos específico.

Grupos de personagens

[character group] permite que você corresponda a qualquer número de caracteres uma vez, enquanto [^character group] corresponde apenas a caracteres que NÃO estão no grupo.

# This expression returns true if the pattern matches big, bog, or bug.
'big' -match 'b[iou]g'

Se a lista de caracteres a serem correspondidos incluir o caractere de hífen (-), ele deverá estar no início ou no final da lista para distingui-lo de uma expressão de intervalo de caracteres.

Intervalos de caracteres

Um padrão também pode ser um intervalo de caracteres. Os caracteres podem ser alfabéticos, numéricos [A-Z][0-9]ou até mesmo baseados em [ -~] ASCII (todos os caracteres imprimíveis).

# This expression returns true if the pattern matches any 2 digit number.
42 -match '[0-9][0-9]'

Números

A \d classe de caracteres corresponderá a qualquer dígito decimal. Por outro lado, \D corresponderá a qualquer caractere, exceto dígitos decimais.

# This expression returns true if it matches a server name.
# (Server-01 - Server-99).
'Server-01' -match 'Server-\d\d'

Caracteres de palavras

A \w classe de caracteres corresponderá a qualquer caractere [a-zA-Z_0-9]de palavra . Para corresponder a qualquer caractere que não seja uma palavra, use \W.

# This expression returns true.
# The pattern matches the first word character 'B'.
'Book' -match '\w'

Curingas

O ponto (.) é um caractere curinga em expressões regulares. Ele corresponderá a qualquer caractere, exceto uma nova linha (\n).

# This expression returns true.
# The pattern matches any 4 characters except the newline.
'a1\ ' -match '....'

Espaço em branco

Você pode combinar qualquer caractere de espaço em branco com a classe de \s caractere. Você pode corresponder a qualquer caractere que não seja de espaço em branco com \S. Você pode combinar caracteres de espaço literal com .

# This expression returns true.
# The pattern uses the whitespace character class to match the leading
# space and a literal space to matching the trailing space.
' - ' -match '\s- '

Quantificadores

Os quantificadores controlam quantas instâncias de cada elemento devem estar presentes na cadeia de caracteres de entrada.

Veja a seguir alguns dos quantificadores disponíveis no PowerShell:

O asterisco (*) corresponde ao elemento anterior zero ou mais vezes. O resultado é que mesmo uma string de entrada sem o elemento seria uma correspondência.

# This returns true for all account name strings even if the name is absent.
'ACCOUNT NAME:    Administrator' -match 'ACCOUNT NAME:\s*\w*'

O sinal de adição (+) corresponde ao elemento anterior uma ou mais vezes.

# This returns true if it matches any server name.
'DC-01' -match '[A-Z]+-\d\d'

O ponto de ? interrogação corresponde ao elemento anterior zero ou uma vez. Como asterisco *, ele corresponderá até mesmo a strings onde o elemento está ausente.

# This returns true for any server name, even server names without dashes.
'SERVER01' -match '[A-Z]+-?\d\d'

O {n, m} quantificador pode ser usado de várias maneiras diferentes para permitir o controle granular sobre o quantificador. O segundo elemento m e a vírgula , são opcionais.

# This returns true if it matches any phone number.
'111-222-3333' -match '\d{3}-\d{3}-\d{4}'

Âncoras

As âncoras permitem que você faça com que uma correspondência seja bem-sucedida ou falhe com base na posição das correspondências na cadeia de caracteres de entrada.

As duas âncoras comumente usadas são ^ e $. O cursor ^ corresponde ao início de uma cadeia de caracteres e $, que corresponde ao final de uma cadeia de caracteres. As âncoras permitem que você corresponda ao texto em uma posição específica e, ao mesmo tempo, descarte caracteres indesejados.

# The pattern expects the string 'fish' to be the only thing on the line.
# This returns FALSE.
'fishing' -match '^fish$'

Ao usar âncoras no PowerShell, você deve entender a diferença entre as opções de expressão regular Singleline e Multiline .

• modo Multilinha: o modo multilinha força ^ e $ a corresponder ao início e ao fim de cada LINHA, em vez de apenas ao início e ao fim da cadeia de caracteres de entrada.
• Singleline: o modo Singleline trata a cadeia de caracteres de entrada como uma SingleLine. Ele força o . caractere a corresponder a todos os caracteres (incluindo novas linhas), em vez de corresponder a todos os caracteres, EXCETO a nova linha \n.

Para ler mais sobre essas opções e como usá-las, visite a Linguagem de Expressão Regular - Referência Rápida.

Caracteres de escape

A barra invertida (\) é usada para escapar caracteres para que eles não sejam analisados pelo mecanismo de expressões regulares.

Os seguintes caracteres são reservados: [().\^$|?*+{.

Você precisará escapar desses caracteres em seus padrões para combiná-los em suas strings de entrada.

# This returns true and matches numbers with at least 2 digits of precision.
# The decimal point is escaped using the backslash.
'3.141' -match '3\.\d{2,}'

Há um método estático da classe regex que pode escapar do texto para você.

[regex]::escape('3.\d{2,}')

3\.\\d\{2,}

Outras fugas de personagens

Também há escapes de caracteres reservados que você pode usar para corresponder a tipos de caracteres especiais.

A seguir estão alguns escapes de caracteres comumente usados:

Grupos, capturas e substituições

As construções de agrupamento separam uma cadeia de caracteres de entrada em subcadeias de caracteres que podem ser capturadas ou ignoradas. As subcadeias de caracteres agrupadas são chamadas de subexpressões. Por padrão, as subexpressões são capturadas em grupos numerados, embora você também possa atribuir nomes a elas.

Uma construção de agrupamento é uma expressão regular entre parênteses. Qualquer texto correspondente à expressão regular incluída é capturado. O exemplo a seguir divide o texto de entrada em dois grupos de captura.

'The last logged on user was CONTOSO\jsmith' -match '(.+was )(.+)'

True

Use a variável automática Hashtable para recuperar o $Matchestexto capturado. O texto que representa toda a partida é armazenado na chave 0. É importante observar que a $Matches tabela de hash contém apenas a primeira ocorrência de qualquer padrão correspondente.

$Matches.0

The last logged on user was CONTOSO\jsmith

As capturas são armazenadas em chaves numéricas de números inteiros que aumentam da esquerda para a direita. Capture 1 contém todo o texto até o nome de usuário, capture 2 contém apenas o nome de usuário.

$Matches

Name           Value
----           -----
2              CONTOSO\jsmith
1              The last logged on user was
0              The last logged on user was CONTOSO\jsmith

PS> 'Good Dog' -match 'Dog'
True

PS> $Matches[0]
Dog

PS> $Matches.Item(0)
Dog

PS> $Matches.0
Dog

Capturas nomeadas

Por padrão, as capturas são armazenadas em ordem numérica crescente, da esquerda para a direita. Você também pode atribuir um nome a um grupo de captura. Esse nome se torna uma chave na $Matchesvariável automática Hashtable .

Dentro de um grupo de captura, use ?<keyname> para armazenar dados capturados em uma chave nomeada.

PS> $string = 'The last logged on user was CONTOSO\jsmith'
PS> $string -match 'was (?<domain>.+)\\(?<user>.+)'
True

PS> $Matches

Name                           Value
----                           -----
domain                         CONTOSO
user                           jsmith
0                              was CONTOSO\jsmith

PS> $Matches.domain
CONTOSO

PS> $Matches.user
jsmith

O exemplo a seguir armazena a entrada de log mais recente no Log de Segurança do Windows. A expressão regular fornecida extrai o nome de usuário e o domínio da mensagem e os armazena sob as chaves:N para nome e D para domínio.

$log = (Get-EventLog -LogName Security -Newest 1 -InstanceId 4689).message
$r = '(?s).*Account Name:\s*(?<N>.*).*Account Domain:\s*(?<D>[A-Z,0-9]*)'
$log -match $r

True

$Matches

Name                           Value
----                           -----
D                              CONTOSO
N                              jsmith
0                              A process has exited....

Para obter mais informações, consulte Agrupando constructos em expressões regulares.

Substituições em expressões regulares

O uso das expressões regulares (regex) com o operador permite substituir dinamicamente o texto usando o -replace texto capturado.

<input> -replace <original>, <substitute>

• <input>: A string a ser pesquisada
• <original>: Uma expressão regular usada para pesquisar a string de entrada
• <substitute>: uma expressão de substituição regex para substituir correspondências encontradas na cadeia de caracteres de entrada.

Os <original> operandos e <substitute> estão sujeitos a regras do mecanismo de expressões regulares, como escape de caracteres ou expressões de substituição. O padrão de substituição pode consistir em uma ou mais substituições junto com caracteres literais.

Os grupos de captura podem ser referenciados <substitute> na cadeia de caracteres usando o $ caractere antes do identificador de grupo.

Duas maneiras de referenciar grupos de captura são por número e por nome.

• Por número - Os grupos de captura são numerados da esquerda para a direita.

  'John D. Smith' -replace '(\w+) (\w+)\. (\w+)', '$1.$2.$3@contoso.com'
  

  John.D.Smith@contoso.com
  

• Por nome - Os grupos de captura também podem ser referenciados por nome.

  'CONTOSO\Administrator' -replace '\w+\\(?<user>\w+)', 'FABRIKAM\${user}'
  

  FABRIKAM\Administrator
  

A $& expressão representa todo o texto correspondente.

'Gobble' -replace 'Gobble', '$& $&'

Gobble Gobble

'Hello World' -replace '(\w+) \w+', '$1 Universe'
"Hello World" -replace "(\w+) \w+", "`$1 Universe"

Hello Universe
Hello Universe

'5.72' -replace '(.+)', '$$$1'
"5.72" -replace "(.+)", "`$`$`$1"

$5.72
$5.72

Para obter informações detalhadas sobre expressões de substituição, consulte Substituições em expressões regulares.

Confira também

• about_Operators
• about_Comparison_Operators