Informazioni sugli operatori di confronto
Breve descrizione
Descrive gli operatori che confrontano i valori in PowerShell.
Descrizione lunga
Gli operatori di confronto consentono di specificare le condizioni per confrontare i valori e trovare i valori corrispondenti ai modelli specificati. Per usare un operatore di confronto, specificare i valori da confrontare con un operatore che separa questi valori.
PowerShell include gli operatori di confronto seguenti:
| Tipo | Operatori | Descrizione |
|---|---|---|
| Uguaglianza | -eq | equals |
| -ne | non uguale | |
| -gt | maggiore di | |
| -ge | maggiore o uguale a | |
| -lt | minore di | |
| -le | minore o uguale a | |
| Matching | -like | Restituisce true quando la stringa corrisponde a caratteri jolly |
| pattern | ||
| -notlike | Restituisce true quando la stringa non corrisponde | |
| modello con caratteri jolly | ||
| -match | Restituisce true quando la stringa corrisponde a regex | |
| Modello; $matches contiene stringhe corrispondenti | ||
| -notmatch | Restituisce true quando la stringa non corrisponde | |
| modello regex; $matches contiene la corrispondenza | ||
| stringhe | ||
| Containment | -contains | Restituisce true quando il valore di riferimento è contenuto |
| in una raccolta | ||
| -notcontains | Restituisce true quando il valore di riferimento non è | |
| contenuto in una raccolta | ||
| -in | Restituisce true quando il valore di test contenuto in un | |
| collection | ||
| -notin | Restituisce true quando il valore di test non è contenuto | |
| in una raccolta | ||
| Sostituzione | -Sostituire | Sostituisce un modello di stringa |
| Tipo | -È | Restituisce true se entrambi gli oggetti sono uguali |
| tipo | ||
| -Is | Restituisce true se gli oggetti non sono uguali | |
| tipo |
Per impostazione predefinita, tutti gli operatori di confronto sono senza distinzione tra maiuscole e minuscole. Per rendere un operatore di confronto con distinzione tra maiuscole e minuscole, precedere il nome dell'operatore con un coggetto . Ad esempio, la versione con distinzione tra maiuscole e minuscole di -eq è -ceq. Per rendere esplicita la distinzione tra maiuscole e minuscole, precedere l'operatore con un ioggetto . Ad esempio, la versione senza distinzione tra maiuscole e minuscole esplicita di -eq è -ieq.
Quando l'input di 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 sono presenti corrispondenze in una raccolta, gli operatori di confronto non restituiscono alcun elemento.
Le eccezioni sono gli operatori di contenimento (, ), gli operatori In (, -notin-notcontains) e gli operatori di tipo (-is-contains-in, -isnot), che restituiscono sempre un valore booleano.
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 intero valore.
Esempio:
-eq
Descrizione: uguale a. Include un valore identico.
Esempio:
C:PS> 2 -eq 2
True
C:PS> 2 -eq 3
False
C:PS> 1,2,3 -eq 2
2
PS> "abc" -eq "abc"
True
PS> "abc" -eq "abc", "def"
False
PS> "abc", "def" -eq "abc"
abc
-ne
Descrizione: non uguale a. Include un valore diverso.
Esempio:
PS> "abc" -ne "def"
True
PS> "abc" -ne "abc"
False
PS> "abc" -ne "abc", "def"
True
PS> "abc", "def" -ne "abc"
def
-gt
Descrizione: maggiore di.
Esempio:
PS> 8 -gt 6
True
PS> 7, 8, 9 -gt 8
9
Nota
Questo non deve essere confuso con >, l'operatore maggiore di in molti altri linguaggi di programmazione. In PowerShell > viene usato per il reindirizzamento. Per altre informazioni, vedere About_redirection.
-ge
Descrizione: maggiore o uguale a.
Esempio:
PS> 8 -ge 8
True
PS> 7, 8, 9 -ge 8
8
9
-lt
Descrizione: minore di.
Esempio:
PS> 8 -lt 6
False
PS> 7, 8, 9 -lt 8
7
-le
Descrizione: minore o uguale a.
Esempio:
PS> 6 -le 8
True
PS> 7, 8, 9 -le 8
7
8
Operatori corrispondenti
Gli operatori like (-like e -notlike) trovano elementi che corrispondono o non corrispondono a un criterio specificato usando espressioni con caratteri jolly.
La sintassi è:
<string[]> -like <wildcard-expression>
<string[]> -notlike <wildcard-expression>
Gli operatori di corrispondenza (-match e -notmatch) trovano elementi che corrispondono o non corrispondono a un criterio specificato usando espressioni regolari.
Gli operatori di corrispondenza popolano la $Matches variabile automatica quando l'input (l'argomento sul lato sinistro) all'operatore è un singolo oggetto scalare. Quando l'input è scalare, gli -match operatori e -notmatch restituiscono un valore booleano e impostano il valore della $Matches variabile automatica sui componenti corrispondenti dell'argomento.
La sintassi è:
<string[]> -match <regular-expression>
<string[]> -notmatch <regular-expression>
-like
Descrizione: corrispondenza con il carattere jolly (*).
Esempio:
PS> "PowerShell" -like "*shell"
True
PS> "PowerShell", "Server" -like "*shell"
PowerShell
-notlike
Descrizione: non corrisponde al carattere jolly (*).
Esempio:
PS> "PowerShell" -notlike "*shell"
False
PS> "PowerShell", "Server" -notlike "*shell"
Server
-match
Descrizione: corrisponde a una stringa usando espressioni regolari. Quando l'input è scalare, popola la $Matches variabile automatica.
Gli operatori di corrispondenza eseguano la ricerca solo in stringhe. Non possono eseguire ricerche in matrici di numeri interi o altri oggetti.
Se l'input è una raccolta, gli -match operatori e -notmatch restituiscono i membri corrispondenti di tale raccolta, ma l'operatore non popola la $Matches variabile.
Ad esempio, il comando seguente invia una raccolta di stringhe all'operatore -match . L'operatore -match restituisce gli elementi della raccolta corrispondenti. Non popola la $Matches variabile automatica.
PS> "Sunday", "Monday", "Tuesday" -match "sun"
Sunday
PS> $Matches
PS>
Al contrario, il comando seguente invia una singola stringa all'operatore -match . L'operatore -match restituisce un valore booleano e popola la $Matches variabile automatica. La $Matches variabile automatica è una tabella Hash. Se non viene usato alcun raggruppamento o acquisizione, viene popolata una sola chiave.
La 0 chiave rappresenta tutto il testo corrispondente. Per altre informazioni sul raggruppamento e l'acquisizione tramite espressioni regolari, vedere about_Regular_Expressions.
PS> "Sunday" -match "sun"
True
PS> $Matches
Name Value
---- -----
0 Sun
È importante notare che la $Matches tabella hash conterrà solo la prima occorrenza di qualsiasi criterio di corrispondenza.
PS> "Banana" -match "na"
True
PS> $Matches
Name Value
---- -----
0 na
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
L'operatore -notmatch popola la $Matches variabile automatica quando l'input è scalare e il risultato è False, ovvero quando rileva una corrispondenza.
PS> "Sunday" -notmatch "rain"
True
PS> $matches
PS>
PS> "Sunday" -notmatch "day"
False
PS> $matches
Name Value
---- -----
0 day
-notmatch
Descrizione: non corrisponde a una stringa. Usa espressioni regolari. Quando l'input è scalare, popola la $Matches variabile automatica.
Esempio:
PS> "Sunday" -notmatch "sun"
False
PS> $matches
Name Value
---- -----
0 sun
PS> "Sunday", "Monday" -notmatch "sun"
Monday
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 non appena rilevano la prima corrispondenza. Gli operatori di uguaglianza valutano tutti gli input e quindi restituiscono tutte le corrispondenze nella raccolta.
-contains
Descrizione: Operatore di contenimento. Indica se una raccolta di valori di riferimento include un singolo valore di test. Restituisce sempre un valore booleano. Restituisce TRUE solo quando il valore di test corrisponde esattamente ad almeno uno dei valori di riferimento.
Quando il valore di test è una raccolta, l'operatore Contains utilizza l'uguaglianza dei riferimenti. Restituisce TRUE solo quando uno dei valori di riferimento è la stessa istanza dell'oggetto valore di test.
In una raccolta di dimensioni molto grandi, l'operatore -contains restituisce risultati più veloci rispetto all'operatore uguale a .
Sintassi:
<Reference-values> -contains <Test-value>
Esempi:
PS> "abc", "def" -contains "def"
True
PS> "Windows", "PowerShell" -contains "Shell"
False #Not an exact match
# Does the list of computers in $DomainServers include $ThisComputer?
PS> $DomainServers -contains $thisComputer
True
PS> "abc", "def", "ghi" -contains "abc", "def"
False
PS> $a = "abc", "def"
PS> "abc", "def", "ghi" -contains $a
False
PS> $a, "ghi" -contains $a
True
-notcontains
Descrizione: Operatore di contenimento. Indica se una raccolta di valori di riferimento include un singolo valore di test. Restituisce sempre un valore booleano. Restituisce TRUE quando il valore di test non corrisponde esattamente ad almeno uno dei valori di riferimento.
Quando il valore di test è una raccolta, l'operatore NotContains utilizza l'uguaglianza dei riferimenti.
Sintassi:
<Reference-values> -notcontains <Test-value>
Esempi:
PS> "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> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS> $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. Restituisce sempre come valore booleano. Restituisce TRUE solo quando il valore di test corrisponde esattamente ad almeno uno dei valori di riferimento.
Quando il valore di test è una raccolta, l'operatore In utilizza l'uguaglianza dei riferimenti. Restituisce TRUE solo quando uno dei valori di riferimento è la stessa istanza dell'oggetto valore di test.
L'operatore -in è stato introdotto in PowerShell 3.0.
Sintassi:
<Test-value> -in <Reference-values>
Esempi:
PS> "def" -in "abc", "def"
True
PS> "Shell" -in "Windows", "PowerShell"
False #Not an exact match
PS> "Windows" -in "Windows", "PowerShell"
True #An exact match
PS> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager"
False #Using reference equality
PS> $a = "Windows", "PowerShell"
PS> $a -in $a, "ServerManager"
True #Using reference equality
# Does the list of computers in $DomainServers include $ThisComputer?
PS> $thisComputer -in $domainServers
True
-notin
Descrizione: 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 utilizza l'uguaglianza dei riferimenti. Restituisce TRUE solo quando uno dei valori di riferimento è la stessa istanza dell'oggetto valore di test.
L'operatore -notin è stato introdotto in PowerShell 3.0.
Sintassi:
<Test-value> -notin \<Reference-values>
Esempi:
PS> "def" -notin "abc", "def"
False
PS> "ghi" -notin "abc", "def"
True
PS> "Shell" -notin "Windows", "PowerShell"
True #Not an exact match
PS> "Windows" -notin "Windows", "PowerShell"
False #An exact match
# Find unapproved verbs in the functions in my module
PS> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS> $MyVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS> $MyVerbs | where {$_ -notin $ApprovedVerbs}
ForEach
Sort
Tee
Where
Operatore replacement
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 le estensioni di tutti i file .txt in .log:
Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' }
La sintassi dell'operatore -replace è la seguente, in cui il <segnaposto originale> rappresenta i caratteri da sostituire e il <segnaposto sostitutivo> rappresenta i caratteri che li sostituiranno:
<input> <operator> <original>, <substitute>
Per impostazione predefinita, l'operatore -replace non fa distinzione tra maiuscole e minuscole. Per fare distinzione tra maiuscole e minuscole, usare -creplace. Per fare in modo che non faccia distinzione tra maiuscole e minuscole in modo esplicito, usare -ireplace.
Considera gli esempi che seguono:
PS> "book" -replace "B", "C"
Cook
"book" -ireplace "B", "C"
Cook
"book" -creplace "B", "C"
book
È anche possibile usare espressioni regolari per sostituire dinamicamente il testo usando gruppi di acquisizione e sostituzioni. Per altre informazioni, vedere about_Regular_Expressions.
Confronto tra tipi
Gli operatori di confronto dei tipi (-is e -isnot) vengono usati per determinare se un oggetto è un tipo specifico.
-È
Sintassi:
<object> -is <type reference>
Esempio:
PS> $a = 1
PS> $b = "1"
PS> $a -is [int]
True
PS> $a -is $b.GetType()
False
-Is
Sintassi:
<object> -isnot <type reference>
Esempio:
PS> $a = 1
PS> $b = "1"
PS> $a -isnot $b.GetType()
True
PS> $b -isnot [int]
True