about_Comparison_Operators

  • Articolo

Descrizione breve

Gli operatori di confronto in PowerShell possono confrontare due valori o elementi di filtro di una raccolta con un valore di input.

Descrizione lunga

Gli operatori di confronto consentono di confrontare i valori o di trovare valori corrispondenti ai modelli specificati. PowerShell include gli operatori di confronto seguenti:

Uguaglianza

  • -eq, -ieq, - -ceq uguale a
  • -ne, -ine, - -cne diverso da
  • -gt, -igt, - -cgt maggiore di
  • -ge, -ige, - -cge maggiore o uguale a
  • -lt, -ilt, - -clt minore di
  • -le, -ile, - -cle minore o uguale a

Corrispondenza

  • -like, -ilike, , -clike - la stringa corrisponde al criterio con caratteri jolly
  • -notlike, , -inotlike- -cnotlike la stringa non corrisponde al modello con caratteri jolly
  • -match, -imatch, , -cmatch - stringa corrisponde al modello regex
  • -notmatch, -inotmatch, - -cnotmatch la stringa non corrisponde al modello regex

Sostituzione

  • -replace, -ireplace, -creplace - sostituisce le stringhe corrispondenti a un criterio regex

Contenimento

  • -contains, -icontains, -ccontains - la raccolta contiene un valore
  • -notcontains, -inotcontains, - -cnotcontains la raccolta non contiene un valore
  • -in - il valore si trova in una raccolta
  • -notin - il valore non si trova in una raccolta

Type

  • -is - entrambi gli oggetti sono dello stesso tipo
  • -isnot - gli oggetti non sono dello stesso tipo

Funzionalità comuni

I confronti tra stringhe non fanno distinzione tra maiuscole e minuscole, a meno che non si usi l'operatore esplicito con distinzione tra maiuscole e minuscole. Per fare in modo che un operatore di confronto faccia distinzione tra maiuscole e minuscole, aggiungere un oggetto c dopo .- Ad esempio, -ceq è la versione con distinzione tra maiuscole e minuscole di -eq. Per rendere esplicita la distinzione tra maiuscole e minuscole, aggiungere un elemento i dopo -. Ad esempio, -ieq è la versione senza distinzione tra maiuscole e minuscole in modo esplicito di -eq.

I confronti tra stringhe usano InvariantCulture per confronti con distinzione tra maiuscole e minuscole e senza distinzione tra maiuscole e minuscole. I confronti sono tra i punti di codice Unicode e non usano l'ordinamento delle regole di confronto specifiche delle impostazioni cultura. I risultati sono gli stessi indipendentemente dalle impostazioni cultura correnti.

Quando l'input di un operatore è un valore scalare , l'operatore restituisce un valore booleano . Quando l'input è una raccolta, l'operatore restituisce gli elementi della raccolta che corrispondono al valore di destra dell'espressione. Se nella raccolta non sono presenti corrispondenze, gli operatori di confronto restituiscono una matrice vuota. Ad esempio:

$a = (1, 2) -eq 3
$a.GetType().Name
$a.Count

Object[]
0

Esistono tuttavia alcune eccezioni:

  • Gli operatori di contenimento e tipo restituiscono sempre un valore booleano
  • L'operatore -replace restituisce il risultato di sostituzione
  • Gli -match operatori e -notmatch popolano anche la $Matches variabile automatica a meno che il lato sinistro dell'espressione non sia una raccolta.

Operatori di uguaglianza

-eq e -ne

Quando il lato sinistro è scalare, -eq restituisce True se il lato destro è equivalente, in caso contrario restituisce -eqFalse. -ne fa l'opposto; restituisce False quando entrambi i lati sono equivalenti; in caso contrario, -ne restituisce True.

Esempio:

2 -eq 2                 # Output: True
2 -eq 3                 # Output: False
"abc" -eq "abc"         # Output: True
"abc" -eq "abc", "def"  # Output: False
"abc" -ne "def"         # Output: True
"abc" -ne "abc"         # Output: False
"abc" -ne "abc", "def"  # Output: True

Quando il lato sinistro è una raccolta, -eq restituisce i membri che corrispondono al lato destro, mentre -ne li filtra.

Esempio:

1,2,3 -eq 2             # Output: 2
"abc", "def" -eq "abc"  # Output: abc
"abc", "def" -ne "abc"  # Output: def

Questi operatori elaborano tutti gli elementi della raccolta. Esempio:

"zzz", "def", "zzz" -eq "zzz"

zzz
zzz

L'operatore di uguaglianza può confrontare oggetti di tipi diversi. È importante comprendere che il valore sul lato destro del confronto può essere convertito nel tipo del valore sul lato sinistro per il confronto.

Ad esempio, la stringa '1.0' viene convertita in un numero intero da confrontare con il valore 1. In questo esempio viene restituito True.

PS> 1 -eq '1.0'
True

In questo esempio il valore 1 viene convertito in una stringa da confrontare con la stringa '1.0'. In questo esempio viene restituito False.

PS> '1.0' -eq 1
False

Gli operatori di uguaglianza accettano due oggetti, non solo una raccolta o scalare. Ma il risultato del confronto non è garantito che sia significativo per l'utente finale. Nell'esempio seguente viene illustrato il problema.

class MyFileInfoSet {
    [String]$File
    [Int64]$Size
}
$a = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$b = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$a -eq $b

False

In questo esempio sono stati creati due oggetti con proprietà identiche. Tuttavia, il risultato del test di uguaglianza è False perché sono oggetti diversi. Per creare classi confrontabili, è necessario implementare System.IEquatable<T> nella classe . L'esempio seguente illustra l'implementazione parziale di una classe MyFileInfoSet che implementa System.IEquatable<T> e ha due proprietà, File e Size. Il Equals() metodo restituisce True se le proprietà File e Size di due oggetti MyFileInfoSet sono uguali.

class MyFileInfoSet : System.IEquatable[Object] {
    [String]$File
    [Int64]$Size

    [bool] Equals([Object] $obj) {
        return ($this.File -eq $obj.File) -and ($this.Size -eq $obj.Size)
    }
}
$a = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$b = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$a -eq $b

True

Un esempio importante di confronto di oggetti arbitrari consiste nel determinare se sono Null. Tuttavia, se è necessario determinare se una variabile è $null, è necessario inserire $null sul lato sinistro dell'operatore di uguaglianza. Metterlo sul lato destro non fa quello che ti aspetti.

Ad esempio, si supponga di $a essere una matrice contenente elementi Null:

$a = 1, 2, $null, 4, $null, 6

I test $a seguenti non sono Null.

$null -ne $a

True

Il codice seguente, tuttavia, esegue il filer di tutti gli elementi Null da $a:

$a -ne $null # Output: 1, 2, 4, 6

1
2
4
6

-gt, -ge, -lt e -le

-gt-lt, -ge, e -le si comportano in modo molto simile. Quando entrambi i lati sono scalari restituiscono True o False a seconda della modalità di confronto tra i due lati:

Operatore Restituisce True quando...
-gt Il lato sinistro è maggiore
-ge Il lato sinistro è maggiore o uguale
-lt Il lato sinistro è più piccolo
-le Il lato sinistro è più piccolo o uguale

Negli esempi seguenti tutte le istruzioni restituiscono True.

8 -gt 6  # Output: True
8 -ge 8  # Output: True
6 -lt 8  # Output: True
8 -le 8  # Output: True

Nota

Nella maggior parte dei linguaggi di programmazione l'operatore maggiore di è >. In PowerShell questo carattere viene usato per il reindirizzamento. Per informazioni dettagliate, vedere about_Redirection.

Quando il lato sinistro è una raccolta, questi operatori confrontano ogni membro della raccolta con il lato destro. A seconda della logica, mantengono o ignorano il membro.

Esempio:

$a=5, 6, 7, 8, 9

Write-Output "Test collection:"
$a

Write-Output "`nMembers greater than 7"
$a -gt 7

Write-Output "`nMembers greater than or equal to 7"
$a -ge 7

Write-Output "`nMembers smaller than 7"
$a -lt 7

Write-Output "`nMembers smaller than or equal to 7"
$a -le 7

Test collection:
5
6
7
8
9

Members greater than 7
8
9

Members greater than or equal to 7
7
8
9

Members smaller than 7
5
6

Members smaller than or equal to 7
5
6
7

Questi operatori funzionano con qualsiasi classe che implementa System.IComparable.

Esempi:

# Date comparison
[DateTime]'2001-11-12' -lt [DateTime]'2020-08-01' # True

# Sorting order comparison
'a' -lt 'z'           # True; 'a' comes before 'z'
'macOS' -ilt 'MacOS'  # False
'MacOS' -ilt 'macOS'  # False
'macOS' -clt 'MacOS'  # True; 'm' comes before 'M'

Nell'esempio seguente viene illustrato che non è presente alcun simbolo su una tastiera QWERTY americana che viene ordinata dopo 'a'. Invia un set contenente tutti questi simboli all'operatore -gt per confrontarli con "a". L'output è una matrice vuota.

$a=' ','`','~','!','@','#','$','%','^','&','*','(',')','_','+','-','=',
   '{','}','[',']',':',';','"','''','\','|','/','?','.','>',',','<'
$a -gt 'a'
# Output: Nothing

Se i due lati degli operatori non sono ragionevolmente confrontabili, questi operatori generano un errore non irreversibile.

Operatori corrispondenti

Gli operatori corrispondenti (-like, -notlike, -matche -notmatch) trovano elementi che corrispondono o non corrispondono a un criterio specificato. Il criterio per -like e -notlike è un'espressione con caratteri jolly (contenente *, ?e [ ]) e -notmatch-match accettare un'espressione regolare (Regex).

La sintassi è:

<string[]> -like    <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match    <regular-expression>
<string[]> -notmatch <regular-expression>

Quando l'input di questi operatori è un valore scalare, restituiscono un valore booleano .

Quando l'input è una raccolta di valori, ogni elemento della raccolta viene convertito in una stringa per il confronto. Gli -match operatori e -notmatch restituiscono rispettivamente i membri corrispondenti e non corrispondenti. Tuttavia, gli operatori e -notlike restituiscono i -like membri come stringhe. La stringa restituita per un membro della raccolta da -like e -notlike è la stringa utilizzata dall'operatore utilizzato per il confronto e viene ottenuta eseguendo il cast del membro in una stringa.

-like e -notlike

-like e -notlike si comportano in modo analogo a -eq e -ne, ma il lato destro potrebbe essere una stringa contenente caratteri jolly.

Esempio:

"PowerShell" -like    "*shell"           # Output: True
"PowerShell" -notlike "*shell"           # Output: False
"PowerShell" -like    "Power?hell"       # Output: True
"PowerShell" -notlike "Power?hell"       # Output: False
"PowerShell" -like    "Power[p-w]hell"   # Output: True
"PowerShell" -notlike "Power[p-w]hell"   # Output: False

"PowerShell", "Server" -like "*shell"    # Output: PowerShell
"PowerShell", "Server" -notlike "*shell" # Output: Server

-match e -notmatch

-match e -notmatch usare espressioni regolari per cercare il criterio nei valori sul lato sinistro. Le espressioni regolari possono corrispondere a modelli complessi, ad esempio indirizzi di posta elettronica, percorsi UNC o numeri di telefono formattati. La stringa sul lato destro deve rispettare le regole delle espressioni regolari.

Esempi scalari:

# Partial match test, showing how differently -match and -like behave
"PowerShell" -match 'shell'        # Output: True
"PowerShell" -like  'shell'        # Output: False

# Regex syntax test
"PowerShell" -match    '^Power\w+' # Output: True
'bag'        -notmatch 'b[iou]g'   # Output: True

Se l'input è una raccolta, gli operatori restituiscono i membri corrispondenti della raccolta.

Esempi di raccolta:

"PowerShell", "Super PowerShell", "Power's hell" -match '^Power\w+'
# Output: PowerShell

"Rhell", "Chell", "Mel", "Smell", "Shell" -match "hell"
# Output: Rhell, Chell, Shell

"Bag", "Beg", "Big", "Bog", "Bug"  -match 'b[iou]g'
#Output: Big, Bog, Bug

"Bag", "Beg", "Big", "Bog", "Bug"  -notmatch 'b[iou]g'
#Output: Bag, Beg

-match e -notmatch supportano i gruppi di acquisizione regex. Ogni volta che vengono eseguiti nell'input scalare e il -match risultato è True oppure il -notmatch risultato è False, sovrascrive la $Matches variabile automatica. $Matches è una tabella Hash che ha sempre una chiave denominata '0', che archivia l'intera corrispondenza. Se l'espressione regolare contiene gruppi di acquisizione, $Matches contiene chiavi aggiuntive per ogni gruppo.

È importante notare che la $Matches tabella hash contiene solo la prima occorrenza di qualsiasi criterio di corrispondenza.

Esempio:

$string = 'The last logged on user was CONTOSO\jsmith'
$string -match 'was (?<domain>.+)\\(?<user>.+)'

$Matches

Write-Output "`nDomain name:"
$Matches.domain

Write-Output "`nUser name:"
$Matches.user

True

Name                           Value
----                           -----
domain                         CONTOSO
user                           jsmith
0                              was CONTOSO\jsmith

Domain name:
CONTOSO

User name:
jsmith

Quando il -match risultato è False o il -notmatch risultato è True o quando l'input è una raccolta, la $Matches variabile automatica non viene sovrascritta. Di conseguenza, conterrà il valore impostato in precedenza o $null se la variabile non è stata impostata. Quando si fa riferimento $Matches dopo aver richiamato uno di questi operatori, valutare la possibilità di verificare che la variabile sia stata impostata dalla chiamata dell'operatore corrente tramite un'istruzione condition.

Esempio:

if ("<version>1.0.0</version>" -match '<version>(.*?)</version>') {
    $Matches
}

Per informazioni dettagliate, vedere about_Regular_Expressions e about_Automatic_Variables.

Operatore Replacement

Sostituzione con espressioni regolari

Come -match, l'operatore -replace usa espressioni regolari per trovare il criterio specificato. A differenza di -match, tuttavia, sostituisce le corrispondenze con un altro valore specificato.

Sintassi:

<input> -replace <regular-expression>, <substitute>

L'operatore sostituisce tutto o parte di un valore con il valore specificato usando espressioni regolari. È possibile usare l'operatore per molte attività amministrative, ad esempio la ridenominazione dei file. Ad esempio, il comando seguente modifica le estensioni di file di tutti i .txt file in .log:

Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' }

Per impostazione predefinita, l'operatore -replace non fa distinzione tra maiuscole e minuscole. Per fare distinzione tra maiuscole e minuscole, usare -creplace. Per renderlo senza distinzione tra maiuscole e minuscole in modo esplicito, usare -ireplace.

Esempi:

"book" -ireplace "B", "C" # Case insensitive
"book" -creplace "B", "C" # Case-sensitive; hence, nothing to replace

Cook
book

A partire da PowerShell 7.2, quando l'operando di sinistra in un'istruzione -replace operator non è una stringa, tale operando viene convertito in una stringa. PowerShell esegue una conversione di stringhe senza distinzione tra impostazioni cultura.

Ad esempio, se le impostazioni cultura sono impostate su Francese (fr), la conversione della stringa sensibile alle impostazioni cultura del valore 1.2 è 1,2.

Prima di PowerShell 7.2:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12

In PowerShell 7.2 e versioni successive:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2

Sostituzioni di espressioni regolari

È anche possibile usare espressioni regolari per sostituire in modo dinamico il testo usando i gruppi di acquisizione e le sostituzioni. È possibile fare riferimento ai gruppi di acquisizione nella <substitute> stringa usando il simbolo di dollaro ($) prima dell'identificatore del gruppo.

Nell'esempio seguente l'operatore -replace accetta un nome utente sotto forma di DomainName\Username e converte nel Username@DomainName formato :

$SearchExp = '^(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$'
$ReplaceExp = '${Username}@${DomainName}'

'Contoso.local\John.Doe' -replace $SearchExp, $ReplaceExp

John.Doe@Contoso.local

Avviso

Il $ carattere ha ruoli sintattici sia in PowerShell che nelle espressioni regolari:

  • In PowerShell, tra virgolette doppie, definisce le variabili e funge da operatore di sottoespressione.
  • Nelle stringhe di ricerca Regex indica la fine della riga.
  • Nelle stringhe di sostituzione Regex indica i gruppi acquisiti. Assicurarsi di inserire le espressioni regolari tra virgolette singole o inserire un carattere backtick (`) prima di essi.

Ad esempio:

$1 = 'Goodbye'

'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe

'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe

$$ In Regex indica un valore letterale $. Nella $$ stringa di sostituzione per includere un valore letterale $ nella sostituzione risultante. Ad esempio:

'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1'  # Output: $1

Per altre informazioni, vedere about_Regular_Expressions e sostituzioni nelle espressioni regolari.

Sostituzione in una raccolta

<input> Quando per l'operatore -replace è una raccolta, PowerShell applica la sostituzione a ogni valore della raccolta. Ad esempio:

"B1","B2","B3","B4","B5" -replace "B", 'a'
a1
a2
a3
a4
a5

Sostituzione con un blocco di script

In PowerShell 6 e versioni successive, l'operatore -replace accetta anche un blocco di script che esegue la sostituzione. Il blocco di script viene eseguito una volta per ogni corrispondenza.

Sintassi:

<String> -replace <regular-expression>, {<Script-block>}

All'interno del blocco di script usare la $_ variabile automatica per accedere al testo di input sostituito e ad altre informazioni utili. Il tipo di classe di questa variabile è System.Text.RegularExpressions.Match.

Nell'esempio seguente ogni sequenza di tre cifre viene sostituita con gli equivalenti di caratteri. Il blocco di script viene eseguito per ogni set di tre cifre che deve essere sostituito.

"072101108108111" -replace "\d{3}", {return [char][int]$_.Value}

Hello

Operatori di contenimento

Gli operatori di contenimento (, , e -notin) sono simili agli operatori di uguaglianza, ad eccezione del fatto che restituiscono sempre un valore booleano, anche quando l'input è una -inraccolta. -notcontains-contains Questi operatori interrompono il confronto non appena rilevano la prima corrispondenza, mentre gli operatori di uguaglianza valutano tutti i membri di input. In una raccolta molto grande, questi operatori restituiscono più rapidamente rispetto agli operatori di uguaglianza.

-contains e -notcontains

Sintassi:

<Collection> -contains <scalar-object>
<Collection> -notcontains <scalar-object>

Questi operatori indicano se un set include un determinato elemento. -contains restituisce True quando il lato destro (scalare-oggetto) corrisponde a uno degli elementi del set. -notcontains restituisce invece False.

Esempi:

"abc", "def" -contains "def"                  # Output: True
"abc", "def" -notcontains "def"               # Output: False
"Windows", "PowerShell" -contains "Shell"     # Output: False
"Windows", "PowerShell" -notcontains "Shell"  # Output: True
"abc", "def", "ghi" -contains "abc", "def"    # Output: False
"abc", "def", "ghi" -notcontains "abc", "def" # Output: True

Esempi più complessi:

$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
                 "ContosoDHCP","ContosoWSUS"
$thisComputer  = "ContosoDC2"

$DomainServers -contains $thisComputer
# Output: True

Quando l'operando sul lato destro è una raccolta, questi operatori convertono il valore nella relativa rappresentazione di stringa prima di confrontarlo con la raccolta sul lato sinistro.

$a = "abc", "def"
"abc", "def", "ghi" -contains $a # Output: False

# The following statements are equivalent
$a, "ghi" -contains $a           # Output: True
"$a", "ghi" -contains $a         # Output: True
"abc def", "ghi" -contains $a    # Output: True

-in e -notin

Sintassi:

<scalar-object> -in <Collection>
<scalar-object> -notin <Collection>

Gli -in operatori e -notin sono stati introdotti in PowerShell 3 come inverso sintattico degli operatori e -notcontains-contains . -in restituisce True quando il lato <scalar-object> sinistro corrisponde a uno degli elementi dell'insieme. -notin restituisce invece False .

Gli esempi seguenti eseguono la stessa operazione degli esempi per -contains e -notcontains , ma vengono scritti con -in e -notin .

"def" -in "abc", "def"                  # Output: True
"def" -notin "abc", "def"               # Output: False
"Shell" -in "Windows", "PowerShell"     # Output: False
"Shell" -notin "Windows", "PowerShell"  # Output: True
"abc", "def" -in "abc", "def", "ghi"    # Output: False
"abc", "def" -notin "abc", "def", "ghi" # Output: True

Esempi più complessi:

$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
                 "ContosoDHCP","ContosoWSUS"
$thisComputer  = "ContosoDC2"

$thisComputer -in $DomainServers
# Output: True

Quando l'operando sul lato sinistro è una raccolta, questi operatori convertono il valore nella relativa rappresentazione di stringa prima di confrontarlo con la raccolta sul lato destro.

$a = "abc", "def"
$a -in "abc", "def", "ghi" # Output: False

# The following statements are equivalent
$a -in $a, "ghi"           # Output: True
$a -in "$a", "ghi"         # Output: True
$a -in "abc def", "ghi"    # Output: True

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>
<object> -isnot <type-reference>

Esempio:

$a = 1
$b = "1"
$a -is [int]           # Output: True
$a -is $b.GetType()    # Output: False
$b -isnot [int]        # Output: True
$a -isnot $b.GetType() # Output: True

Vedi anche