PowerShell
Expressions régulières

Syntaxe

• 'texte' -match 'RegExPattern'
• 'text' -replace 'RegExPattern', 'newvalue'
• [regex] :: Match ("text", "pattern") # Match unique
• [regex] :: Matches ("text", "pattern") # Correspondances multiples
• [regex] :: Remplacer ("text", "pattern", "newvalue")
• [regex] :: Remplacer ("text", "pattern", {param ($ m)}) #MatchEvaluator
• [regex] :: Escape ("input") #Escape des caractères spéciaux

Match unique

Vous pouvez rapidement déterminer si un texte inclut un motif spécifique à l'aide de Regex. Il existe plusieurs façons de travailler avec Regex dans PowerShell.

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

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

Utilisation de l'opérateur -Match

Pour déterminer si une chaîne correspond à un modèle à l'aide de l'opérateur -matches , utilisez la syntaxe 'input' -match 'pattern' . Cela retournera true ou false selon le résultat de la recherche. S'il y avait une correspondance, vous pouvez afficher la correspondance et les groupes (si définis dans le modèle) en accédant à la variable $Matches .

> $text -match $pattern
True

> $Matches

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

Vous pouvez également utiliser -match pour filtrer un tableau de chaînes et renvoyer uniquement les chaînes contenant une correspondance.

> $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)}

Utilisation de [RegEx] :: Match ()

Vous pouvez également utiliser la méthode statique Match() disponible dans la classe .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)

Remplacer

Une tâche courante pour regex consiste à remplacer le texte qui correspond à un modèle par une nouvelle valeur.

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

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

#Replace matches with:
$newvalue = 'test'

Utilisation de l'opérateur -Replace

L'opérateur -replace dans PowerShell peut être utilisé pour remplacer le texte correspondant à un motif par une nouvelle valeur en utilisant la syntaxe 'input' -replace 'pattern', 'newvalue' .

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

En utilisant la méthode [RegEx] :: Replace ()

Le remplacement de correspondances peut également être effectué à l'aide de la méthode Replace() dans la classe [RegEx] .NET.

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

Remplacer le texte par une valeur dynamique par un MatchEvalutor

Parfois, vous devez remplacer une valeur correspondant à un modèle par une nouvelle valeur basée sur cette correspondance spécifique, ce qui rend impossible la prédiction de la nouvelle valeur. Pour ces types de scénarios, un MatchEvaluator peut être très utile.

Dans PowerShell, un MatchEvaluator est aussi simple qu'un bloc de script avec un seul paramètre contenant un objet Match pour la correspondance en cours. La sortie de l'action sera la nouvelle valeur pour cette correspondance spécifique. MatchEvalutor peut être utilisé avec la méthode statique [Regex]::Replace() .

Exemple : Remplacement du texte à l'intérieur () par sa longueur

#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

}

Sortie:

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

This is 1 sample
text, this is
a 11

Exemple: Créer un sample majuscule

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

$MatchEvalutor = {
    param($match)

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

}

Sortie:

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

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

Échapper des caractères spéciaux

Un motif regex utilise de nombreux caractères spéciaux pour décrire un motif. Ex., . signifie "tout caractère", + est "un ou plusieurs" etc.

Pour utiliser ces caractères, sous forme de . , + Etc., dans un modèle, vous devez les échapper pour enlever leur signification particulière. Ceci est fait en utilisant le caractère d'échappement qui est une barre oblique inverse \ dans l'expression régulière. Exemple: Pour rechercher + , vous utiliseriez le pattern \+ .

Il peut être difficile de se souvenir de tous les caractères spéciaux dans regex. Pour échapper à tous les caractères spéciaux d'une chaîne que vous souhaitez rechercher, vous pouvez utiliser la méthode [RegEx]::Escape("input") .

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

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

Plusieurs correspondances

Il existe plusieurs façons de rechercher toutes les correspondances pour un motif dans un texte.

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

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

Utilisation de Select-String

Vous pouvez trouver toutes les correspondances (correspondance globale) en ajoutant le commutateur -AllMatches à 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)

Utiliser [RegEx] :: Matches ()

La méthode Matches() de la classe .NET `[regex] peut également être utilisée pour effectuer une recherche globale de plusieurs correspondances.

> [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)