PowerShell
Wyrażenia regularne

Składnia

• „text” -match „RegExPattern”
• „text” -replace „RegExPattern”, „newvalue”
• [regex] :: Dopasuj („tekst”, „wzór”) # Pojedyncze dopasowanie
• [regex] :: Dopasowania („tekst”, „wzór”) # Wiele dopasowań
• [regex] :: Zamień („tekst”, „wzór”, „nowa wartość”)
• [regex] :: Replace („text”, „pattern”, {param ($ m)}) #MatchEvaluator
• [regex] :: Escape („input”) #Escape special specials

Pojedynczy mecz

Możesz szybko ustalić, czy tekst zawiera określony wzór, używając Regex. Istnieje wiele sposobów pracy z programem Regex w programie PowerShell.

#Sample text
$text = @"
This is (a) sample
text, this is
a (sample text)
"@

#Sample pattern: Content wrapped in ()
$pattern = '\(.*?\)'

Korzystanie z operatora -Match

Aby ustalić, czy łańcuch pasuje do wzorca za pomocą wbudowanego operatora -matches , użyj składni 'input' -match 'pattern' . Zwróci wartość true lub false zależności od wyniku wyszukiwania. Jeśli było dopasowanie, możesz wyświetlić dopasowanie i grupy (jeśli zdefiniowane we wzorcu), wchodząc do zmiennej $Matches .

> $text -match $pattern
True

> $Matches

Name Value
---- -----
0    (a)  

Możesz także użyć opcji -match aby przefiltrować tablicę ciągów i zwracać tylko ciągi zawierające dopasowanie.

> $textarray = @"
This is (a) sample
text, this is
a (sample text)
"@ -split "`n"

> $textarray -match $pattern
This is (a) sample
a (sample text)

> $m = Select-String -InputObject $text -Pattern $pattern

> $m

This is (a) sample
text, this is
a (sample text)

> $m | Format-List *

IgnoreCase : True
LineNumber : 1
Line       : This is (a) sample
             text, this is
             a (sample text)
Filename   : InputStream
Path       : InputStream
Pattern    : \(.*?\)
Context    : 
Matches    : {(a)}

> $textarray | Select-String -Pattern $pattern

This is (a) sample
a (sample text)

#You can also access the matches, groups etc.
> $textarray | Select-String -Pattern $pattern | fl *


IgnoreCase : True
LineNumber : 1
Line       : This is (a) sample
Filename   : InputStream
Path       : InputStream
Pattern    : \(.*?\)
Context    : 
Matches    : {(a)}

IgnoreCase : True
LineNumber : 3
Line       : a (sample text)
Filename   : InputStream
Path       : InputStream
Pattern    : \(.*?\)
Context    : 
Matches    : {(sample text)}

Korzystanie z [RegEx] :: Match ()

Możesz także użyć statycznej metody Match() dostępnej w klasie .NET [RegEx] .

> [regex]::Match($text,$pattern)

Groups   : {(a)}
Success  : True
Captures : {(a)}
Index    : 8
Length   : 3
Value    : (a)

> [regex]::Match($text,$pattern) | Select-Object -ExpandProperty Value
(a)

Zastąpić

Typowym zadaniem wyrażenia regularnego jest zastępowanie tekstu pasującego do wzorca nową wartością.

#Sample text
$text = @"
This is (a) sample
text, this is
a (sample text)
"@

#Sample pattern: Text wrapped in ()
$pattern = '\(.*?\)'

#Replace matches with:
$newvalue = 'test'

Korzystanie z operatora -Replace

Za pomocą operatora -replace w programie PowerShell można zastąpić tekst pasujący do wzorca nową wartością, używając składni 'input' -replace 'pattern', 'newvalue' .

> $text -replace $pattern, $newvalue
This is test sample
text, this is
a test

Korzystanie z metody [RegEx] :: Replace ()

Zastępowanie dopasowań można również wykonać przy użyciu metody Replace() w klasie [RegEx] .NET.

[regex]::Replace($text, $pattern, 'test')
This is test sample
text, this is
a test

Zamień tekst na wartość dynamiczną za pomocą MatchEvalutor

Czasami trzeba zastąpić wartość pasującą do wzorca nową wartością, która jest oparta na tym konkretnym dopasowaniu, co uniemożliwia przewidzenie nowej wartości. W tego typu scenariuszach MatchEvaluator może być bardzo przydatny.

W PowerShell MatchEvaluator jest tak prosty jak blok skryptu z pojedynczym parametrem, który zawiera obiekt Match dla bieżącego dopasowania. Wynik działania będzie nową wartością dla tego konkretnego dopasowania. MatchEvalutor może być używany z metodą statyczną [Regex]::Replace() .

Przykład : zamiana tekstu w środku () jego długość

#Sample text
$text = @"
This is (a) sample
text, this is
a (sample text)
"@
    
#Sample pattern: Content wrapped in ()
$pattern = '(?<=\().*?(?=\))'

$MatchEvalutor = {
    param($match)

    #Replace content with length of content
    $match.Value.Length

}

Wynik:

> [regex]::Replace($text, $pattern, $MatchEvalutor)

This is 1 sample
text, this is
a 11

Przykład: zrób sample dużymi literami

#Sample pattern: "Sample"
$pattern = 'sample'

$MatchEvalutor = {
    param($match)

    #Return match in upper-case
    $match.Value.ToUpper()

}

Wynik:

> [regex]::Replace($text, $pattern, $MatchEvalutor)

This is (a) SAMPLE
text, this is
a (SAMPLE text)

Ucieczka ze znaków specjalnych

Wzór regularny używa wielu znaków specjalnych do opisania wzoru. Np., . oznacza „dowolny znak”, + oznacza „jeden lub więcej” itp.

Aby użyć tych znaków, jako . , + itd., we wzorze musisz uciec przed nimi, aby usunąć ich specjalne znaczenie. Odbywa się to za pomocą znaku ucieczki, który jest ukośnikiem odwrotnym \ w wyrażeniu regularnym. Przykład: aby wyszukać + , użyj wzoru \+ .

Zapamiętanie wszystkich znaków specjalnych w wyrażeniu regularnym może być trudne, więc aby uciec od każdego znaku specjalnego w ciągu, który chcesz wyszukać, możesz użyć metody [RegEx]::Escape("input") .

> [regex]::Escape("(foo)")
\(foo\)

> [regex]::Escape("1+1.2=2.2")
1\+1\.2=2\.2

Wiele dopasowań

Istnieje wiele sposobów znalezienia wszystkich dopasowań dla wzorca w tekście.

#Sample text
$text = @"
This is (a) sample
text, this is
a (sample text)
"@

#Sample pattern: Content wrapped in ()
$pattern = '\(.*?\)'

Za pomocą Select-String

Możesz znaleźć wszystkie dopasowania (dopasowanie globalne), dodając przełącznik -AllMatches do Select-String .

> $m = Select-String -InputObject $text -Pattern $pattern -AllMatches

> $m | Format-List *

IgnoreCase : True
LineNumber : 1
Line       : This is (a) sample
             text, this is
             a (sample text)
Filename   : InputStream
Path       : InputStream
Pattern    : \(.*?\)
Context    : 
Matches    : {(a), (sample text)}

#List all matches
> $m.Matches

Groups   : {(a)}
Success  : True
Captures : {(a)}
Index    : 8
Length   : 3
Value    : (a)

Groups   : {(sample text)}
Success  : True
Captures : {(sample text)}
Index    : 37
Length   : 13
Value    : (sample text)

#Get matched text
> $m.Matches | Select-Object -ExpandProperty Value
(a)
(sample text)

Korzystanie z [RegEx] :: Matches ()

Metodę Matches() w klasie `[regex] .NET można również wykorzystać do globalnego wyszukiwania wielu dopasowań.

> [regex]::Matches($text,$pattern)

Groups   : {(a)}
Success  : True
Captures : {(a)}
Index    : 8
Length   : 3
Value    : (a)

Groups   : {(sample text)}
Success  : True
Captures : {(sample text)}
Index    : 37
Length   : 13
Value    : (sample text)

> [regex]::Matches($text,$pattern) | Select-Object -ExpandProperty Value

(a)
(sample text)