Condividi tramite

about_Espressioni_Regolari

Breve descrizione

Descrive le espressioni regolari in PowerShell.

Descrizione lunga

Nota

Questo articolo illustra la sintassi e i metodi per l'uso di espressioni regolari in PowerShell. Non copre tutte le espressioni possibili. Per informazioni di riferimento più complete, vedere Linguaggio di espressioni regolari - Riferimento rapido.

Un'espressione regolare è un criterio usato per trovare una corrispondenza con il testo. Può essere costituito da caratteri letterali, operatori e altri costrutti. PowerShell utilizza il motore regex .NET .

Questo articolo illustra la sintassi delle espressioni regolari in PowerShell. PowerShell include diversi operatori e cmdlet che usano espressioni regolari. Per altre informazioni sulla sintassi e sull'utilizzo, vedere i collegamenti seguenti.

Le espressioni regolari di PowerShell non fanno distinzione tra maiuscole e minuscole per impostazione predefinita. Ogni metodo mostrato sopra ha un modo diverso per forzare la distinzione tra maiuscole e minuscole.

  • Per Select-String, utilizzare il parametro CaseSensitive.
  • Per gli operatori che usano espressioni regolari, usare la versione con distinzione tra maiuscole e minuscole: -cmatch, -creplaceo -csplit
  • Per l'istruzione switch, usare l'opzione -CaseSensitive

Valori letterali carattere

Un'espressione regolare può essere un carattere letterale o una stringa. L'espressione fa in modo che il motore corrisponda esattamente al testo specificato.

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

Classi di caratteri

Mentre i letterali di caratteri funzionano se si conosce il modello esatto, le classi di caratteri consentono di essere meno specifici.

Gruppi di caratteri

[character group] consente di associare un numero qualsiasi di caratteri una volta, mentre [^character group] corrisponde solo ai caratteri NON nel gruppo.

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

Se l'elenco di caratteri da associare include il carattere trattino (-), deve trovarsi all'inizio o alla fine dell'elenco per distinguerlo da un'espressione di intervallo di caratteri.

Intervalli di caratteri

Uno schema può anche essere un intervallo di caratteri. I caratteri possono essere alfabetici [A-Z], [0-9]numerici o persino [ -~] basati su ASCII (tutti i caratteri stampabili).

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

Numeri

La \d classe di caratteri corrisponde a qualsiasi cifra decimale. Al contrario, \D corrisponde a qualsiasi carattere ad eccezione delle cifre decimali.

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

Caratteri di parola

La classe di caratteri \w corrisponde a qualsiasi carattere di parola [a-zA-Z_0-9]. Per trovare la corrispondenza con qualsiasi carattere non alfanumerico, usare \W.

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

Caratteri jolly

Il punto (.) è un carattere jolly nelle espressioni regolari. Corrisponde a qualsiasi carattere ad eccezione di una nuova riga (\n).

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

Spazi vuoti

È possibile associare qualsiasi carattere di spazio vuoto alla classe di caratteri \s. È possibile associare qualsiasi carattere non vuoto a \S. È possibile associare i caratteri dello spazio letterale con .

# 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- '

Quantificatori

I quantificatori controllano il numero di istanze di ogni elemento che devono essere presenti nella stringa di input.

Di seguito sono riportati alcuni quantificatori disponibili in PowerShell:

Quantificatore Descrizione
* Zero o più volte.
+ Una o più volte.
? Zero o una volta.
{n,m} Almeno n, ma non più di m volte.

L'asterisco (*) corrisponde all'elemento precedente zero o più volte. Il risultato è che anche una stringa di input senza l'elemento presente verrebbe considerata una corrispondenza.

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

Il segno più (+) corrisponde all'elemento precedente una o più volte.

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

Il punto interrogativo ? corrisponde all'elemento precedente zero o una volta. Come l'asterisco *, corrisponde anche alle stringhe in cui l'elemento è assente.

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

Il quantificatore {n, m} può essere usato in diversi modi per consentire un controllo granulare sul quantificatore. Il secondo elemento m e la virgola , sono facoltativi.

Quantificatore Descrizione
{n} Trova la corrispondenza ESATTAMENTE n numero di volte.
{n,} Abbina almeno n volte.
{n,m} Trova la corrispondenza tra n e m numero di volte. 
# This returns true if it matches any phone number.
'111-222-3333' -match '\d{3}-\d{3}-\d{4}'

Ancoraggi

Gli ancoraggi consentono di determinare se una corrispondenza avrà esito positivo o negativo in base alla loro posizione nella stringa di input.

I due ancoraggi comunemente usati sono ^ e $. Il cursore ^ corrisponde all'inizio di una stringa e $, che corrisponde alla fine di una stringa. Gli ancoraggi consentono di far corrispondere il testo in una posizione specifica, scartando anche i caratteri indesiderati.

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

Nota

Quando si definisce un'espressione regolare contenente un ancoraggio ($ ), è necessario racchiudere l'espressione regolare tra virgolette singole ('). Se si usano virgolette doppie ("), PowerShell interpreta la stringa come espressione di variabile espandibile.

Quando si usano ancoraggi in PowerShell, è necessario comprendere la differenza tra le opzioni di espressioni regolari Singola linea e Multilinea.

  • Multilinea: la modalità multilinea forza ^ e $ a corrispondere all'inizio e alla fine di ogni riga anziché all'inizio e alla fine della stringa di input.
  • Singleline: la modalità SingleLine considera la stringa di input come SingleLine. Forza il carattere . a corrispondere a ogni carattere (comprese le nuove righe), invece di corrispondere a ogni carattere tranne la nuova riga \n.

Per maggiori informazioni su queste opzioni e su come usarle, visitare la pagina su Linguaggio di espressioni regolari - Riferimento rapido.

Caratteri di escape

Il backslash (\) viene usato per evitare l'interpretazione dei caratteri, affinché non vengano analizzati dal motore delle espressioni regolari.

I caratteri seguenti sono riservati: [().\^$|?*+{.

Dovrai eseguire l'escape di questi caratteri nei tuoi modelli per farli corrispondere alle stringhe di input.

# 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,}'

Esiste un metodo statico della classe regex che può eseguire l'escape del testo per te.

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

3\.\\d\{2,}

Nota

In questo modo vengono 'escapati' tutti i caratteri riservati di espressioni regolari, incluse le barre rovesciate esistenti usate nelle classi di caratteri. Assicurarsi di usarlo solo nella parte del modello in cui devi eseguire l'escape.

Altri caratteri di escape

Sono inoltre disponibili caratteri di escape riservati che è possibile usare per trovare corrispondenze con tipi di caratteri speciali.

Di seguito sono riportati alcuni caratteri di escape di uso comune:

Sequenza di escape Descrizione
\t Corrisponde a un tab
\n Corrisponde a una nuova riga
\r Corrisponde a un ritorno a capo

Gruppi, acquisizioni e sostituzioni

I costrutti di raggruppamento separano una stringa di input in sottostringhe che possono essere acquisite o ignorate. Le sottostringhe raggruppate sono denominate sottoespressioni. Per impostazione predefinita, le sottoespressioni vengono acquisite in gruppi numerati, anche se è possibile assegnare nomi anche a tali sottoespressioni.

Un costrutto di raggruppamento è un'espressione regolare racchiusa tra parentesi. Qualsiasi testo corrispondente all'espressione regolare racchiusa viene catturato. Nell'esempio seguente il testo di input viene suddiviso in due gruppi di acquisizione.

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

True

Usare la $MatchesHashtable variabile automatica per recuperare il testo acquisito. Il testo che rappresenta l'intera corrispondenza viene archiviato nella chiave 0. È importante notare che la tabella hash $Matches contiene solo la prima occorrenza di qualsiasi motivo corrispondente.

$Matches.0

The last logged on user was CONTOSO\jsmith

Le catture vengono archiviate in chiavi numeriche intere che aumentano da sinistra a destra. Capture 1 contiene tutto il testo fino al nome utente, mentre capture 2 contiene solo il nome utente.

$Matches

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

Importante

La chiave 0 è un Integer. È possibile usare qualsiasi metodo hashtable per accedere al valore archiviato.

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

PS> $Matches[0]
Dog

PS> $Matches.Item(0)
Dog

PS> $Matches.0
Dog

Acquisizioni denominate

Per impostazione predefinita, le acquisizioni vengono archiviate in ordine numerico crescente, da sinistra a destra. È possibile assegnare anche un nome a un gruppo di cattura. Questo nome diventa una chiave nella variabile automatica della tabella hash $Matches.

All'interno di un gruppo di acquisizione, usare ?<keyname> per archiviare i dati acquisiti in una chiave denominata.

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

Nell'esempio seguente viene archiviata la voce di log più recente nel registro di sicurezza di Windows. L'espressione regolare fornita estrae il nome utente e il dominio dal messaggio e li archivia nelle chiavi:N per nome e D per il dominio.

$log = (Get-WinEvent -LogName Security -MaxEvents 1).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...

Per altre informazioni, vedere Costrutti di raggruppamento nelle espressioni regolari.

Sostituzioni nelle espressioni regolari

L'uso delle espressioni regolari (regex) con l'operatore -replace consente di sostituire in modo dinamico il testo usando il testo acquisito.

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

  • <input>: stringa da cercare
  • <original>: espressione regolare usata per cercare la stringa di input
  • <substitute>: espressione di sostituzione regex per sostituire le corrispondenze trovate nella stringa di input.

Gli operandi <original> e <substitute> sono soggetti a regole del motore delle espressioni regolari, ad esempio l'escape dei caratteri o le espressioni di sostituzione. Il modello di sostituzione può essere costituito da una o più sostituzioni insieme ai caratteri letterali.

È possibile fare riferimento ai gruppi di acquisizione nella stringa <substitute> usando il carattere $ prima dell'identificatore di gruppo.

Due modi per fare riferimento ai gruppi di acquisizione sono numero e Nome.

  • Per numero: i gruppi di acquisizione vengono numerati da sinistra a destra.

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

    John.D.Smith@contoso.com

  • Per Nome - È anche possibile fare riferimento ai gruppi di acquisizione in base al nome.

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

    FABRIKAM\Administrator

L'espressione $& rappresenta tutto il testo corrispondente.

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

Gobble Gobble

Avvertimento

Poiché il carattere $ viene usato nell'espansione di stringhe, è necessario usare stringhe letterali con sostituzione oppure eseguire l'escape del carattere $ quando si usano virgolette doppie.

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

Hello Universe
Hello Universe

Inoltre, se si desidera avere il $ come carattere letterale, usare $$ anziché i caratteri di escape normali. Quando si usano virgolette doppie, eseguire comunque l'escape di tutte le istanze di $ per evitare la sostituzione errata.

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

$5.72
$5.72

Per informazioni dettagliate sulle espressioni di sostituzione, vedere Sostituzioni nelle espressioni regolari.

Commenti nelle espressioni regolari

Le espressioni regolari possono essere molto complesse e difficili da leggere. È possibile usare i commenti per renderli più comprensibili. Esistono due tipi di commenti consentiti nelle espressioni regolari.

  • Commento in linea ((?#))
  • Commento di fine riga (#)

Per altre informazioni, vedere la sezione commenti delle espressioni regolari di about_Comments.

Vedere anche

  • Last updated on