ARGOMENTO
about_Comparison_Operators
DESCRIZIONE BREVE
Descrive gli operatori che confrontano i valori in Windows PowerShell.
DESCRIZIONE DETTAGLIATA
Gli operatori di confronto consentono di specificare le
condizioni per il confronto e l'individuazione di valori che
corrispondono a modelli specificati. Per utilizzare un operatore
di confronto, specificare i valori da confrontare, separati
dall'operatore.
Per impostazione predefinita, tutti gli operatori di confronto
non rilevano la distinzione tra maiuscole e minuscole. Per fare
in modo che un operatore di confronto rilevi la distinzione tra
maiuscole e minuscole, anteporre "c" al nome dell'operatore.
Ad esempio, la versione con distinzione tra maiuscole e minuscole
di "-eq" è "-ceq". Per rendere esplicita la mancanza di
distinzione tra maiuscole e minuscole, anteporre "i"
all'operatore. Ad esempio, la versione esplicitamente senza
distinzione tra maiuscole e minuscole di "-eq" è "ieq".
Tutti gli operatori di confronto eccetto gli operatori di
contenimento (-contains, -notcontains) e gli operatori di tipo
(-is, -isnot) restituiscono un valore booleano quando l'input per
l'operatore (il valore a sinistra dell'operatore) è un valore
singolo (valore scalare). Quando l'input è una raccolta di valori, gli
operatori di contenimento e gli operatori di tipo restituiscono i valori
corrispondenti. Se non sono presenti corrispondenze in una raccolta,
questi operatori non restituiscono alcun valore. Gli operatori di
contenimento e di tipo restituiscono sempre un valore booleano.
In Windows PowerShell sono supportati gli operatori di confronto
seguenti.
-eq
Descrizione: Uguale a. Include un valore identico.
Esempio:
C:\PS> "abc", "def" -eq "abc"
abc
-ne
Descrizione: Diverso da. Include un valore diverso.
Esempio:
C:\PS> "abc", "def" -ne "abc"
def
-gt
Descrizione: Maggiore di.
Esempio:
C:\PS> 8 -gt 6
True
-ge
Descrizione: Maggiore di o uguale a.
Esempio:
C:\PS> 8 -ge 8
True
-lt
Descrizione: Minore di.
Esempio:
C:\PS> 8 -lt 6
False
-le
Descrizione: Minore di o uguale a.
Esempio:
C:\PS> 6 -le 8
True
-like
Descrizione: Corrispondenza mediante il carattere jolly (*).
Esempio:
C:\PS> "Windows PowerShell" -like "*shell"
True
-notlike
Descrizione: Nessuna corrispondenza mediante il carattere jolly (*).
Esempio:
C:\PS> "Windows PowerShell" -notlike "*shell"
False
-match
Descrizione: Corrispondenza con una stringa mediante
espressioni regolari. Quando l'input è scalare, viene compilata
la variabile automatica $Matches.
Esempio:
C:\PS> "Sunday" -match "sun"
True
C:\PS> $matches
Name Value
---- -----
0 sun
-notmatch
Descrizione: Nessuna corrispondenza con una stringa. Vengono
utilizzate espressioni regolari.
Quando l'input è scalare, viene compilata la variabile
automatica $Matches.
Esempio:
C:\PS> "Sunday" -notmatch "sun"
False
C:\PS> $matches
Name Value
---- -----
0 sun
-contains
Descrizione: Operatore di contenimento. Include un valore
identico che non fa parte di un valore. Restituisce sempre un valore
booleano.
Esempio:
C:PS> "abc", "def" -contains "def"
True
-notcontains
Descrizione: Operatore di contenimento. Non include un valore
identico. Restituisce sempre un valore booleano.
Esempio:
C:PS> "Windows", "PowerShell" -notcontains "Shell"
True
-replace
Descrizione: Operatore Replace. Modifica gli elementi
specificati di un valore.
Esempio:
C:\PS> "Get-Process" -replace "Get", "Stop"
Stop-Process
Operatori di uguaglianza
Gli operatori di uguaglianza (-eq, -ne) restituiscono un 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.
Negli esempi seguenti viene illustrato l'effetto dell'operatore
equal to:
C:PS> 1,2,3 -eq 2
2
C:PS> "PowerShell" -eq "Shell"
False
C:PS> "Windows", "PowerShell" -eq "Shell"
C:PS>
C:\PS> "abc", "def", "123" -eq "def"
def
Operatori di contenimento
Gli operatori di contenimento (-contains e -notcontains) sono
simili agli operatori di uguaglianza. Tuttavia, tali operatori
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 non appena
viene rilevata la prima corrispondenza. Gli operatori di uguaglianza
valutano tutto l'input, quindi restituiscono 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
C:\PS> "abc", "def", "123" -contains "def"
True
C:\PS> "true", "blue", "six" -contains "true"
True
Nell'esempio seguente viene illustrata la differenza tra gli
operatori di contenimento e l'operatore di uguaglianza. Gli
operatori di contenimento restituiscono il valore TRUE alla prima
corrispondenza.
C:\PS> 1,2,3,4,5,4,3,2,1 -eq 2
2
2
C:\PS> 1,2,3,4,5,4,3,2,1 -contains 2
True
In una raccolta di grandi dimensioni, l'operatore -contains
restituisce i risultati più rapidamente rispetto all'operatore di
uguaglianza.
Operatori di corrispondenza
Gli operatori di corrispondenza (-match e -notmatch) trovano
elementi che corrispondono o non corrispondono a un modello
specificato mediante espressioni regolari.
La sintassi è la seguente:
<string[]> -match <espressione-regolare>
<string[]> -notmatch <espressione-regolare>
Negli esempi seguenti vengono illustrati alcuni utilizzi
dell'operatore -match:
C:\PS> "Windows", "PowerShell" -match ".shell"
PowerShell
C:\PS> (get-command get-member -syntax) -match "-view"
True
C:\PS> (get-command get-member -syntax) -notmatch "-path"
True
C:\PS> (get-content servers.txt) -match "^Server\d\d"
Server01
Server02
Gli operatori di corrispondenza cercano solo nelle stringhe.
Non possono effettuare ricerche in matrici di valori interi o
in altri oggetti.
Gli operatori -match e -notmatch compilano la variabile
automatica $Matches quando l'input (l'argomento di sinistra)
per l'operatore è un singolo oggetto scalare. Quando l'input è
scalare, gli operatori -match e -notmatch restituiscono un
valore booleano e impostano il valore della variabile
automatica $Matches sui componenti corrispondenti dell'argomento.
Se l'input è una raccolta, gli operatori -match e -notmatch
restituiscono i membri corrispondenti di tale raccolta, ma non
compilano la variabile $Matches.
Ad esempio, nel comando seguente viene inviata una raccolta di
stringhe all'operatore -match. L'operatore -match restituisce
gli elementi nella raccolta corrispondente, ma non compila la
variabile automatica $Matches.
C:\PS> "Sunday", "Monday", "Tuesday" -match "sun"
Sunday
C:\PS> $matches
C:\PS>
Invece, nel comando seguente viene inviata una singola stringa
all'operatore match. L'operatore -match restituisce un valore
booleano e compila la variabile automatica $Matches.
C:\PS> "Sunday" -match "sun"
True
C:\PS> $matches
Name Value
---- -----
0 Sun
L'operatore -notmatch compila la variabile automatica $Matches
quando l'input è scalare e il risultato è False, ovvero quando viene
rilevata una corrispondenza.
C:\PS> "Sunday" -notmatch "rain"
True
C:\PS> $matches
C:\PS>
C:\PS> "Sunday" -notmatch "day"
False
C:\PS> $matches
C:\PS>
Name Value
---- -----
0 day
Operatore di sostituzione
L'operatore -replace sostituisce interamente o in parte un
valore con il valore specificato mediante espressioni regolari.
È possibile utilizzare l'operatore -replace per molte attività
amministrative, ad esempio la ridenominazione di file. Nel comando
seguente, ad esempio, vengono modificate le estensioni di tutti i
file gif in jpg:
Get-ChildItem | Rename-Item -NewName { $_ -replace
'.gif$','.jpg$' }
La sintassi dell'operatore -replace è la seguente, dove il
segnaposto <originale> rappresenta i caratteri da sostituire e
il segnaposto <sostitutivo> rappresenta i caratteri che li
sostituiranno:
<input> <operatore> <originale>, <sostitutivo>
Per impostazione predefinita, l'operatore -replace non rileva
la distinzione tra maiuscole e minuscole. Per fare in modo che
la rilevi, utilizzare -creplace. Per rendere esplicita la
mancanza di distinzione tra maiuscole e minuscole, utilizzare
ireplace. Si considerino gli esempi seguenti:
C:\PS> "book" -replace "B", "C"
Cook
C:\PS> "book" -ireplace "B", "C"
Cook
C:\PS> "book" -creplace "B", "C"
book
Operatori bit per bit
Windows PowerShell supporta gli operatori bit per bit standard,
inclusi gli operatori -AND bit per bit (-band) e gli operatori
-OR bit per bit inclusivi ed esclusivi (-bor e -bxor). A
partire da Windows PowerShell 2.0, tutti gli operatori bit per bit
funzionano con valori interi a 64 bit.
In Windows PowerShell sono supportati gli operatori bit per bit
seguenti.
Operatore Descrizione Esempio
-------- ---------------------- -------------------
-band AND bit per bit C:\PS> 10 -band 3
2
-bor OR bit per bit (inclusivo) C:\PS> 10 -bor 3
11
-bxor OR bit per bit (esclusivo) C:\PS> 10 -bxor 3
9
Gli operatori bit per bit intervengono sul formato binario di
un valore. La struttura di bit per il numero 10 è, ad esempio,
00001010 (basata su un byte), mentre per il numero 3 è
00000011. Se si utilizza un operatore bit per bit per
confrontare 10 e 3, vengono confrontati i singoli bit di ogni byte.
In un'operazione AND bit per bit, il bit risultante viene
impostato su 1 solo quando entrambi i bit di input sono 1.
00001010 (10)
00000011 ( 3)
------------------ bAND
00000010 ( 2)
In un'operazione OR bit per bit (inclusiva), il bit risultante viene
impostato su 1 quando entrambi i bit di input sono 1. Il bit
risultante viene impostato su 0 solo quando entrambi i bit di input
vengono impostati su 0.
00001010 (10)
00000011 ( 3)
------------------ bOR (inclusivo)
00001011 (11)
In un'operazione OR bit per bit (esclusiva), il bit risultante viene
impostato su 1 solo quando un bit di input è 1.
00001010 (10)
00000011 ( 3)
------------------ bXOR (esclusivo)
00001001 ( 9)
VEDERE ANCHE
about_Operators
about_Regular_Expressions
about_Wildcards
Compare-Object