about_Comparison_Operators
Aggiornamento: maggio 2014
Si applica a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Inserire l'introduzione qui.
ARGOMENTO
about_Comparison_Operators
DESCRIZIONE BREVE
Descrive gli operatori che confrontano valori in Windows PowerShell®.
DESCRIZIONE LUNGA
Gli operatori di confronto consentono di specificare le condizioni per il confronto dei valori e la ricerca di valori che corrispondono ai modelli specificati. Per usare un operatore di confronto, specificare i valori da confrontare con un operatore che separa tali valori.
Windows PowerShell include gli operatori di confronto seguenti:
-eq
-ne
-gt
-ge
-lt
-le
-Like
-NotLike
-Match
-NotMatch
-Contains
-NotContains
-In
-NotIn
-Replace
Per impostazione predefinita, tutti gli operatori di confronto non distinguono tra maiuscole e minuscole. Affinché un operatore di confronto faccia distinzione tra maiuscole e minuscole, anteporre una "c" al nome dell'operatore. Ad esempio, la versione di "-eq" con distinzione tra maiuscole e minuscole è "-ceq". Per rendere esplicita la non distinzione tra maiuscole e minuscole, anteporre una "i" all'operatore. Ad esempio, la versione "-eq" che esplicitamente non distingue tra maiuscole e minuscole è "-ieq".
Quando l'input per un operatore è un valore scalare, gli operatori di confronto restituiscono un valore booleano. Quando l'input è una raccolta di valori, gli operatori di confronto restituiscono i valori corrispondenti. Se non esistono corrispondenze in una raccolta, gli operatori di confronto non restituiscono alcun valore.
Le eccezioni sono gli operatori di contenimento (-Contains, -NotContains), gli operatori In (-In, -NotIn) e gli operatori di tipo (-Is, -IsNot), che restituiscono sempre un valore booleano.
Windows PowerShell supporta gli operatori di confronto seguenti.
-eq
Descrizione: Uguale a. Include un valore identico.
Esempio:
PS C:\> "abc" -eq "abc"
True
PS C:\> "abc" -eq "abc", "def"
False
PS C:\> "abc", "def" -eq "abc"
abc
-ne
Descrizione: Non uguale a. Include un valore diverso.
Esempio:
PS C:\> "abc" -ne "def"
True
PS C:\> "abc" -ne "abc"
False
PS C:\> "abc" -ne "abc", "def"
True
PS C:\> "abc", "def" -ne "abc"
def
-gt
Descrizione: Maggiore di.
Esempio:
PS C:\> 8 -gt 6
True
PS C:\> 7, 8, 9 -gt 8
9
-ge
Descrizione: Maggiore o uguale a.
Esempio:
PS C:\> 8 -ge 8
True
PS C:\> 7, 8, 9 -ge 8
8
9
-lt
Descrizione: Minore di.
Esempio:
PS C:\> 8 -lt 6
False
PS C:\> 7, 8, 9 -lt 8
7
-le
Descrizione: Minore o uguale a.
Esempio:
PS C:\> 6 -le 8
True
PS C:\> 7, 8, 9 -le 8
7
8
-Like
Descrizione: Trova la corrispondeza usando il carattere jolly (*).
Esempio:
PS C:\> "Windows PowerShell" -like "*shell"
True
PS C:\> "Windows PowerShell", "Server" -like "*shell"
Windows PowerShell
-NotLike
Descrizione: Non trova la corrispondenza usando il carattere jolly (*).
Esempio:
PS C:\> "Windows PowerShell" -NotLike "*shell"
False
PS C:\> "Windows PowerShell", "Server" -NotLike "*shell"
Server
-Match
Descrizione: Trova la corrispondenza con una stringa usando espressioni regolari. Quando l'input è scalare, popola la variabile automatica $Matches.
Esempio:
PS C:\> "Sunday" -Match "sun"
True
PS C:\> $matches
Name Value
---- -----
0 Sun
PS C:\> "Sunday", "Monday" -Match "sun"
Sunday
-NotMatch
Descrizione: Non trova la corrispondenza con una stringa. Usa espressioni regolari. Quando l'input è scalare, popola la variabile automatica $Matches.
Esempio:
PS C:\> "Sunday" -NotMatch "sun"
False
PS C:\> $matches
Name Value
---- -----
0 sun
PS C:\> "Sunday", "Monday" -NotMatch "sun"
Monday
-Contains
Descrizione: Operatore di contenimento. Indica se una raccolta di valori di riferimento include un valore di test singolo. Restituisce sempre un valore booleano. Restituisce TRUE solo se il valore di test corrisponde esattamente ad almeno uno dei valori di riferimento.
Quando il valore di test è una raccolta, l'operatore di contenimento usa l'uguaglianza dei riferimenti. Restituisce TRUE solo se uno dei valori di riferimento è la stessa istanza dell'oggetto valore di test.
Sintassi:
<Reference-values> -Contains <Test-value>
Esempi:
PS C:\> "abc", "def" -Contains "def"
True
PS C:\> "Windows", "PowerShell" -Contains "Shell"
False #Not an exact match
# Does the list of computers in $domainServers
# include $thisComputer?
# -------------------------------------------
PS C:\> $domainServers -Contains $thisComputer
True
PS C:\> "abc", "def", "ghi" -Contains "abc", "def"
False
PS C:\> $a = "abc", "def"
PS C:\> "abc", "def", "ghi" -Contains $a
False
PS C:\> $a, "ghi" -Contains $a
True
-NotContains
Descrizione: Operatore di contenimento. Indica se una raccolta di valori di riferimento include un valore di test singolo. Restituisce sempre un valore booleano. Restituisce TRUE quando il valore di test non è una corrispondenza esatta per almeno uno dei valori di riferimento.
Quando il valore di test è una raccolta, l'operatore NotContains usa l'uguaglianza dei riferimenti.
Sintassi:
<Reference-values> -NotContains <Test-value>
Esempi:
PS C:\> "Windows", "PowerShell" -NotContains "Shell"
True #Not an exact match
# Get cmdlet parameters, but exclude common parameters
function get-parms ($cmdlet)
{
$Common = "Verbose", "Debug", "WarningAction", "WarningVariable", `
"ErrorAction", "ErrorVariable", "OutVariable", "OutBuffer"
$allparms = (Get-Command $Cmdlet).parametersets | foreach {$_.Parameters} | `
foreach {$_.Name} | Sort-Object | Get-Unique
$allparms | where {$Common -NotContains $_ }
}
# Find unapproved verbs in the functions in my module
# -------------------------------------------
PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS C:\> $myVerbs | where {$ApprovedVerbs -NotContains $_}
ForEach
Sort
Tee
Where
-In
Descrizione: Operatore In. Indica se un valore di test viene visualizzato in una raccolta di valori di riferimento. Restituito sempre come valore booleano. Restituisce TRUE solo se il valore di test corrisponde esattamente ad almeno uno dei valori di riferimento.
Quando il valore di test è una raccolta, l'operatore In usa l'uguaglianza dei riferimenti. Restituisce TRUE solo se uno dei valori di riferimento è la stessa istanza dell'oggetto valore di test.
L'operatore In è stato introdotto in Windows PowerShell 3.0.
Sintassi:
<Test-value> -in <Reference-values>
Esempi:
PS C:\> "def" -in "abc", "def"
True
PS C:\> "Shell" -in "Windows", "PowerShell"
False #Not an exact match
PS C:\> "Windows" -in "Windows", "PowerShell"
True #An exact match
PS C:\> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager"
False #Using reference equality
PS C:\> $a = "Windows", "PowerShell"
PS C:\> $a -in $a, "ServerManager"
True #Using reference equality
# Does the list of computers in $domainServers
# include $thisComputer?
# -------------------------------------------
PS C:\> $thisComputer -in $domainServers
True
-NotIn
Descrizione: Operatore NotIn. Indica se un valore di test viene visualizzato in una raccolta di valori di riferimento. Restituisce sempre un valore booleano. Restituisce TRUE quando il valore di test non è una corrispondenza esatta per almeno uno dei valori di riferimento.
Quando il valore di test è una raccolta, l'operatore In usa l'uguaglianza dei riferimenti. Restituisce TRUE solo se uno dei valori di riferimento è la stessa istanza dell'oggetto valore di test.
L'operatore NotIn è stato introdotto in Windows PowerShell 3.0.
Sintassi:
<Test-value> -NotIn <Reference-values>
Esempi:
PS C:\> "def" -NotIn "abc", "def"
False
PS C:\> "ghi" -NotIn "abc", "def"
True
PS C:\> "Shell" -NotIn "Windows", "PowerShell"
True #Not an exact match
PS C:\> "Windows" -NotIn "Windows", "PowerShell"
False #An exact match
# Find unapproved verbs in the functions in my module
# -------------------------------------------
PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS C:\> $myVerbs | where {$_ -NotIn $ApprovedVerbs}
ForEach
Sort
Tee
Where
-Replace
Descrizione: Operatore di sostituzione. Modifica gli elementi specificati di un valore
Esempio:
PS C:\> "Get-Process" -Replace "Get", "Stop"
Stop-Process
# Change all .GIF file name extension to .JPG
PS C:\> dir *.gif | foreach {$_ -Replace ".gif", ".jpg"}
OPERATORI DI UGUAGLIANZA
Gli operatori di uguaglianza (-eq, -ne) restituiscono il valore TRUE o le corrispondenze quando uno o più valori di input sono identici al modello specificato. L'intero modello deve corrispondere a un valore intero.
C:PS> 2 -eq 2
True
C:PS> 2 -eq 3
False
C:PS> 1,2,3 -eq 2
2
C:PS> "PowerShell" -eq "Shell"
False
C:PS> "Windows", "PowerShell" -eq "Shell"
C:PS>
PS C:\> "abc", "def", "123" -eq "def"
def
PS C:\> "abc", "def", "123" -ne "def"
abc
123
OPERATORI DI CONTENIMENTO
Gli operatori di contenimento (-Contains e -NotContains) sono simili agli operatori di uguaglianza. Tuttavia, gli operatori di contenimento restituiscono sempre un valore booleano, anche quando l'input è una raccolta.
Inoltre, a differenza degli operatori di uguaglianza, gli operatori di contenimento restituiscono un valore appena rilevano la prima corrispondenza. Gli operatori di uguaglianza valutano tutto l'input e restituiscono quindi tutte le corrispondenze nella raccolta. Negli esempi seguenti viene illustrato l'effetto dell'operatore -Contains:
C:PS> 1,2,3 -contains 2
True
C:PS> "PowerShell" -contains "Shell"
False
C:PS> "Windows", "PowerShell" -contains "Shell"
False
PS C:\> "abc", "def", "123" -contains "def"
True
PS C:\> "true", "blue", "six" -contains "true"
True
L'esempio seguente mostra la differenza tra operatori di contenimento e operatore di uguaglianza. Gli operatori di contenimento restituiscono un valore TRUE alla prima corrispondenza.
PS C:\> 1,2,3,4,5,4,3,2,1 -eq 2
2
2
PS C:\> 1,2,3,4,5,4,3,2,1 -contains 2
True
In una raccolta di dimensioni molto grandi, l'operatore -Contains restituisce risultati più velocemente rispetto all'operatore di uguaglianza.
Operatori di corrispondenza
Gli operatori di corrispondenza (-Match e -NotMatch) individuano gli elementi che corrispondono o non corrispondono a un modello specificato usando espressioni regolari.
La sintassi è:
<string[]> -Match <regular-expression>
<string[]> -NotMatch <regular-expression>
Gli esempi seguenti mostrano alcuni utilizzi dell'operatore -Match:
PS C:\> "Windows", "PowerShell" -Match ".shell"
PowerShell
PS C:\> (Get-Command Get-Member -Syntax) -Match "-view"
True
PS C:\> (Get-Command Get-Member -Syntax) -NotMatch "-path"
True
PS C:\> (Get-Content Servers.txt) -Match "^Server\d\d"
Server01
Server02
Gli operatori di corrispondenza effettuano ricerche solo nelle stringhe. Non possono cercare nelle matrici di numeri interi o altri oggetti.
Gli operatori -Match e -NotMatch popolano la variabile automatica $Matches quando l'input (l'argomento a sinistra) per l'operatore è un singolo oggetto scalare. Quando l'input è scalare, gli operatori -Match e -NotMatch restituiscono un valore booleano e impostano come valore della variabile automatica $Matches i componenti dell'argomento con corrispondenza.
Se l'input è una raccolta, gli operatori -Match e -NotMatch restituiscono i membri corrispondenti di tale raccolta ma l'operatore non popola la variabile $Matches.
Ad esempio, il comando seguente invia una raccolta di stringhe all'operatore -Match. L'operatore -Match restituisce gli elementi corrispondenti nella raccolta, ma popola la variabile automatica $Matches.
PS C:\> "Sunday", "Monday", "Tuesday" -Match "sun"
Sunday
PS C:\> $matches
PS C:\>
Al contrario, il comando seguente invia una singola stringa all'operatore -Match. L'operatore -Match restituisce un valore booleano e popola la variabile automatica $Matches.
PS C:\> "Sunday" -Match "sun"
True
PS C:\> $matches
Name Value
---- -----
0 Sun
L'operatore -NotMatch popola la variabile automatica $Matches quando l'input è scalare e il risultato è False, ossia quando rileva una corrispondenza.
PS C:\> "Sunday" -NotMatch "rain"
True
PS C:\> $matches
PS C:\>
PS C:\> "Sunday" -NotMatch "day"
False
PS C:\> $matches
PS C:\>
Name Value
---- -----
0 day
OPERATORE DI SOSTITUZIONE
L'operatore -Replace sostituisce tutto o parte di un valore con il valore specificato usando espressioni regolari. È possibile usare l'operatore -Replace per molte attività amministrative, ad esempio la ridenominazione dei file. Ad esempio, il comando seguente modifica in jpg le estensioni dei nomi di tutti i file con estensione gif:
Get-ChildItem | Rename-Item -NewName { $_ -Replace '.gif$','.jpg$' }
La sintassi dell'operatore -Replace è indicata di seguito, dove il segnaposto <original> rappresenta i caratteri da sostituire e il segnaposto <substitute> rappresenta i caratteri che li sostituiranno:
<input> <operator> <original>, <substitute>
Per impostazione predefinita l'operatore -Replace non distingue tra maiuscole e minuscole. Per distinguere tra maiuscole e minuscole, usare -cReplace. Per rendere esplicita la distinzione tra maiuscole e minuscole, usare -iReplace. Considerare gli esempi seguenti:
PS C:\> "book" -Replace "B", "C"
Cook
PS C:\> "book" -iReplace "B", "C"
Cook
PS C:\> "book" -cReplace "B", "C"
book
PS C:\> '<command:parameter required="false" variableLength="true" globbing="false"'`
| foreach {$_ -replace 'globbing="false"', 'globbing="true"'}
<command:parameter required="false" variableLength="true" globbing="true"
Operatori bit per bit
Windows PowerShell supporta gli operatori bit per bit standard, incluso AND bit per bit (-bAnd), gli operatori OR bit per bit inclusivi ed esclusivi (-bOr e -bXor) e NOT bit per bit (-bNot).
A partire da Windows PowerShell 2.0, tutti gli operatori bit per bit funzionano con valori Integer a 64 bit.
A partire da Windows PowerShell 3.0, sono stati introdotti -shr (spostamento a destra) e -shl (spostamento a sinistra) per supportare operazioni aritmetiche bit per bit in Windows PowerShell.
Windows PowerShell supporta gli operatori bit per bit seguenti.
Operator Description Example
-------- ---------------------- -------------------
-bAnd Bitwise AND PS C:\> 10 -band 3
2
-bOr Bitwise OR (inclusive) PS C:\> 10 -bor 3
11
-bXor Bitwise OR (exclusive) PS C:\> 10 -bxor 3
9
-bNot Bitwise NOT PS C:\> -bNot 10
-11
-shl Shift-left PS C:\> 100 -shl 2
400
-shr Shift-right PS C:\> 100 -shr 1
50
Gli operatori bit per bit agiscono sul formato binario di un valore. Ad esempio, la struttura di bit per il numero 10 è 00001010 (in base a 1 byte) e la struttura di bit per il numero 3 è 00000011. Quando si usa un operatore bit per bit per confrontare da 10 con 3, vengono confrontati i singoli bit in ogni byte.
In un'operazione AND bit per bit, il bit risultante è impostato su 1 solo quando entrambi i bit di input sono 1.
1010 (10)
0011 ( 3)
-------------- bAND
0010 ( 2)
In un'operazione OR bit per bit (inclusiva), il bit risultante è impostato su 1 quando uno o entrambi i bit di input sono 1. Il bit risultante è impostato su 0 solo quando entrambi i bit di input sono impostati su 0.
1010 (10)
0011 ( 3)
-------------- bOR (inclusive)
1011 (11)
In un'operazione OR bit per bit (esclusiva), il bit risultante è impostato su 1 solo quando un bit di input è 1.
1010 (10)
0011 ( 3)
-------------- bXOR (exclusive)
1001 ( 9)
L'operatore NOT è un operatore unario che produce il complemento binario del valore. Un bit 1 è impostato su 0 e un bit 0 è impostato su 1.
Ad esempio, il complemento binario di 0 è -1, l'intero senza segno massimo (0xffffffff), e il complemento binario di -1 è 0.
PS C:\> -bNOT 10
-11
0000 0000 0000 1010 (10)
------------------------- bNOT
1111 1111 1111 0101 (-11, xfffffff5)
In un'operazione di spostamento a sinistra bit per bit, tutti i bit vengono spostati a sinistra di "n" posizioni, dove "n" è il valore dell'operando di destra. Un valore zero viene inserito in tali posizioni.
Quando l'operando sinistro è un valore intero (32 bit), i 5 bit inferiori dell'operando destro determinano il numero di bit dell'operando sinistro da spostare.
Quando l'operando sinistro è un valore Long (64 bit), i 6 bit inferiori dell'operando destro determinano il numero di bit dell'operando sinistro da spostare.
PS C:\> 21 -shl 1
42
00010101 (21)
00101010 (42)
PS C:\> 21 -shl 2
84
00010101 (21)
00101010 (42)
01010100 (84)
In un'operazione di spostamento a destra bit per bit, tutti i bit vengono spostati a destra di "n" posizioni, dove "n" è specificato dall'operando di destra. L'operatore di spostamento a destra (-shr) inserisce uno zero nella posizione più a sinistra durante lo spostamento a destra di un valore positivo o senza segno.
Quando l'operando sinistro è un valore intero (32 bit), i 5 bit inferiori dell'operando destro determinano il numero di bit dell'operando sinistro da spostare.
Quando l'operando sinistro è un valore Long (64 bit), i 6 bit inferiori dell'operando destro determinano il numero di bit dell'operando sinistro da spostare.
PS C:\> 21 -shr 1
10
00010101 (21)
00001010 (10)
PS C:\> 21 -shr 2
5
00010101 (21)
00001010 (10)
00000101 ( 5)
VEDERE ANCHE
about_Operators
about_Regular_Expressions
about_Wildcards
Compare-Object
Foreach-Object
Where-Object