about_Regular_Expressions

  • Articolo

Descrizione breve

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 viene illustrata tutta la sintassi. Per informazioni di riferimento più complete, vedere Il linguaggio delle espressioni regolari - Guida di 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.

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 illustrato in precedenza ha un modo diverso per forzare la distinzione tra maiuscole e minuscole.

  • Per Select-Stringusare 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 usare l'opzione switch-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 valori letterali carattere funzionano se si conosce il modello esatto, le classi di caratteri consentono di essere meno specifiche.

Gruppi di caratteri

[character group] consente di trovare una corrispondenza con 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

Un criterio può anche essere un intervallo di caratteri. I caratteri possono essere alfabetici [A-Z], numerici [0-9]o anche 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 corrisponderà a qualsiasi cifra decimale. Al contrario, \D corrisponderà a qualsiasi cifra non decimale.

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

Caratteri di parola

La \w classe di caratteri corrisponderà a qualsiasi carattere di [a-zA-Z_0-9]parola . 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. Corrisponderà 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 '....'

Spazio vuoto

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

# 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} nAlmeno , 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 sarebbe 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 *, corrisponderà 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 {n, m} quantificatore 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 il numero di volte.
{n,} Trova la corrispondenza con almeno n il numero di volte.
{n,m} Trova la corrispondenza tra n e m il 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 fare in modo che una corrispondenza abbia esito positivo o negativo in base alla posizione corrispondente all'interno della stringa di input.

I due ancoraggi usati comunemente sono ^ e $. Il cursore ^ corrisponde all'inizio di una stringa e $, che corrisponde alla fine di una stringa. Gli ancoraggi consentono di trovare una corrispondenza con il testo in una posizione specifica, ignorando 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, assicurarsi di racchiudere l'espressione regolare usando virgolette singole () anziché virgolette doppie ('") o PowerShell espanderà l'espressione come variabile.

Quando si usano ancoraggi in PowerShell, è necessario comprendere la differenza tra le opzioni di espressione regolare a riga singola e multilinea .

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

Per altre informazioni su queste opzioni e su come usarle, visitare Il linguaggio delle espressioni regolari - Guida di riferimento rapido.

Uso di caratteri di escape

La barra rovesciata (\) viene usata per i caratteri di escape in modo che non vengano analizzati dal motore delle espressioni regolari.

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

Dovrai eseguire l'escape di questi caratteri nei modelli in modo che corrispondano 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ò essere preceduto da un escape del testo.

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

3\.\\d\{2,}

Nota

In questo modo vengono preceduti tutti i caratteri di espressione regolare riservati, incluse le barre rovesciata esistenti usate nelle classi di caratteri. Assicurarsi di usarlo solo nella parte del modello di cui è necessario 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:

Carattere di escape Descrizione
\t Corrisponde a una scheda
\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 acquisito. 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 $Matchesvariabile automatica Hashtable per recuperare il testo acquisito. Il testo che rappresenta l'intera corrispondenza viene archiviato nella chiave 0. È importante notare che la $Matches tabella hash contiene solo la prima occorrenza di qualsiasi criterio di corrispondenza.

$Matches.0

The last logged on user was CONTOSO\jsmith

Le acquisizioni vengono archiviate in chiavi Integer numeriche che aumentano da sinistra a destra. L'acquisizione 1 contiene tutto il testo fino a quando il nome utente non contiene 2 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 0 chiave è un valore 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. È anche possibile assegnare un nome a un gruppo di acquisizione. Questo nome diventa una chiave nella $Matchesvariabile automatica Hashtable .

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 log Sicurezza di Windows. L'espressione regolare fornita estrae il nome utente e il dominio dal messaggio e li archivia sotto le chiavi:N per il 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 consente di sostituire in modo dinamico il -replace testo usando il testo acquisito.

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

  • <input>: stringa in cui eseguire la ricerca
  • <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 <original> operandi e <substitute> sono soggetti a regole del motore delle espressioni regolari, ad esempio l'escape dei caratteri o le espressioni di sostituzione. Il criterio di sostituzione può essere costituito da una o più sostituzioni insieme a caratteri letterali.

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

Due modi per fare riferimento ai gruppi di acquisizione sono per numero e per 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

Avviso

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 come $ carattere letterale, usare $$ invece dei normali caratteri di escape. 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.

Vedi anche