Condividi tramite

about_Comparison_Operators

  • Articolo

Breve descrizione

Gli operatori di confronto in PowerShell possono confrontare due valori o filtrare elementi di una raccolta rispetto a 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 non uguale
  • -gt, , - -igt-cgt maggiore di
  • -ge, , - -ige-cge maggiore o uguale
  • -lt, , - -ilt-clt minore di
  • -le, , - -ile-cle minore o uguale

Matching

  • -like, , -clike - -ilikestringa corrisponde al modello con caratteri jolly
  • -notlike, , -cnotlike - -inotlikela stringa non corrisponde al modello con caratteri jolly
  • -match, , -imatch-cmatch - stringa corrisponde al modello regex
  • -notmatch, , -cnotmatch - -inotmatchla stringa non corrisponde al modello regex

Sostituzione

  • -replace, , -creplace - -ireplacesostituisce le stringhe corrispondenti a un modello regex

Containment

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

Tipo

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

Funzionalità comuni

I confronti tra stringhe sono senza distinzione tra maiuscole e minuscole, a meno che non si usi l'operatore con distinzione tra maiuscole e minuscole esplicite. Per rendere un operatore di confronto con 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 oggetto i dopo -. Ad esempio, -ieq è la versione senza distinzione tra maiuscole e minuscole di -eq.

I confronti tra stringhe usano InvariantCulture per confronti di 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 uguali 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 destro 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 variabile automatica a meno che il $Matches 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, -eq restituisce False. -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 filtrano.

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 lato sinistro per il confronto.

Ad esempio, la stringa '1.0' viene convertita in un 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 scalare o una raccolta. Tuttavia, il risultato del confronto non è garantito essere 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 paragonabili, è necessario implementare System.IEquatable<T> nella classe. Nell'esempio seguente viene illustrata 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 scoprire se sono Null. Tuttavia, se è necessario determinare se una variabile è $null, è necessario inserire $null sul lato sinistro dell'operatore di uguaglianza. Mettendolo sul lato destro non fa quello che ci si aspetta.

Si supponga $a ad esempio di essere una matrice contenente elementi Null:

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

I test seguenti non $a sono null.

$null -ne $a

True

Tuttavia, i filer out tutti gli elementi Null da $a:

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

1
2
4
6

-gt, -ge, -lt e -le

-gt, -ge, -lte -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 eliminano 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 esiste alcun simbolo su una tastiera QWERTY americana che viene ordinata dopo "a". Fornisce 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 paragonabili, questi operatori generano un errore non terminante.

Operatori corrispondenti

Gli operatori corrispondenti (-like, -notlike, -matche -notmatch) trovano elementi corrispondenti o che non corrispondono a un criterio specificato. Il criterio per -like e -notlike è un'espressione con caratteri jolly (contenente *, ?e [ ]), mentre -match e -notmatch accettano 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 -like operatori e -notlike restituiscono i membri come stringhe. La stringa restituita per un membro della raccolta da -like e -notlike è la stringa utilizzata per il confronto e viene ottenuta eseguendo il cast del membro in una stringa.

-like e -notlike

-likee si comportano in modo simile a -eq e -notlike-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 di tale 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 sull'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, contiene $Matches 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 dopo aver richiamato uno di questi operatori, è consigliabile verificare che la variabile $Matches sia stata impostata dalla chiamata dell'operatore corrente usando 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

Analogamente -matcha , 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 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 fare in modo che non faccia 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 dinamicamente il testo usando gruppi di acquisizione e sostituzioni. È possibile fare riferimento ai gruppi di acquisizione nella <substitute> stringa usando il segno di dollaro ($) prima dell'identificatore di 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 di inserire un carattere backtick (`) prima di esse.

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 $. Contenuto $$ 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

Quando l'oggetto <input> all'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 (-contains, -notcontains, -ine -notin) sono simili agli operatori di uguaglianza, ad eccezione del fatto che restituiscono sempre un valore booleano , anche quando l'input è una raccolta. 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 di grandi dimensioni, 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 (oggetto scalare) corrisponde a uno degli elementi nel 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 il contrario sintattico degli operatori e -notcontains-contains . -in restituisce True quando il lato <scalar-object> sinistro corrisponde a uno degli elementi della raccolta. -notin restituisce invece False .

Gli esempi seguenti eseguono la stessa operazione per gli -notcontains esempi, -contains 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