Operatore PowerShell Like & Altro: Potenzia il Tuo Gioco di Scripting

Come molti altri linguaggi di programmazione, PowerShell dispone di vari operatori di confronto. Tuttavia, a differenza di altri linguaggi, questi operatori di confronto possono sembrare un po’ insoliti. Invece di `==`, si utilizza `eq`. Invece di `<>`, si usa `ne`. Può essere confusionario per i principianti. Esaminiamo l’operatore di confronto di PowerShell e altri operatori in questo articolo.PowerShell

Verifica dell’uguaglianza con gli operatori eq e ceq

Per verificare se un oggetto è uguale a un altro in PowerShell, si utilizza l’operatore eq. L’operatore eq confronta oggetti semplici di molti tipi come stringhe, valori booleani, interi, e così via. Quando viene utilizzato, l’operatore eq restituirà un valore booleano True o False a seconda del risultato.

L’operatore -eq necessita di due valori da confrontare. Supponiamo di assegnare una stringa a una variabile chiamata $string. Desideri confrontare il valore di questa variabile con il valore della stringa "PowerShell" per assicurarti che siano uguali.

Nell’esempio seguente, puoi vedere che stiamo assegnando il valore PowerShell alla variabile $string. Quindi, utilizzando l’operatore eq, l’esempio confronta il valore di $string con la stringa powershell. Abbastanza semplice, vero? Ma aspetta, non sono davvero la stessa cosa però.

PS> $string = "PowerShell"
PS> $string -eq "powershell"
True

Nota che = è un operatore di assegnazione e NON un operatore di confronto. Non puoi utilizzare = per confrontare un valore con un altro in PowerShell.

Testare la Sensibilità alle Maiuscole/Minuscole Con l’Operatore ceq

Nell’esempio sopra, nota come eq abbia restituito un valore booleano True anche quando la stringa non era esattamente la stessa. Questo comportamento avviene perché l’operatore eq non fa distinzione tra maiuscole e minuscole. Per testare l’uguaglianza sensibile alle maiuscole e minuscole, utilizza l’operatore ceq. L’operatore ceq è esattamente lo stesso di eq con l’eccezione di essere sensibile alle maiuscole e minuscole.

Puoi vedere un esempio di utilizzo di ceq nel seguente frammento di codice. Osserva come PowerShell rilevi la differenza tra maiuscole e minuscole.

PS> $string -ceq "PowerShell"
True 
PS> $string -ceq "powershell"
False

Testare per l’Ineguaglianza Con gli Operatori ne e cne

Come eq e ceq testano l’uguaglianza, PowerShell ha una coppia di operatori che fanno l’opposto esatto chiamati ne e cne. Come i loro corrispettivi, questi due operatori eseguono la stessa operazione ma in modo opposto.

PS> $string = "PowerShell"
PS> $string -ne "PowerShell"
False
PS> $string -cne "PowerShell"
False
PS> $string -cne "powershell"
True

Testare per Elementi in una Collezione

Di solito, gli operatori eq e ceq vengono utilizzati per valori scalari o singoli come stringhe, interi e valori booleani. Tuttavia, questi operatori possono anche trovare istanze di valori particolari contenuti all’interno di una collezione come un array.

Nota nell’esempio qui sotto che stiamo creando un array con 12 interi. Forse ti piacerebbe trovare tutte le istanze in quell’array che sono uguali al numero 9. Nessun problema, usa l’operatore eq contro l’array per restituire tutte le istanze dell’intero confrontato.

PS> $array =@(1,2,3,4,5,6,7,8,9,9,9,9)
PS> $array -eq 9
9
9
9
9
PS> ($array -eq 9).Count
4

Testare le Collezioni per Contenere Valori

Dato che hai appena imparato a utilizzare l’operatore eq per trovare istanze in array, facciamo un passo avanti e introduciamo gli operatori di “contenimento”. Questi operatori sono contains, notcontains, in e notin. Questi operatori restituiscono un valore booleano True o False se una collezione contiene un’istanza o meno.

Dai un’occhiata all’esempio seguente. In questo esempio, stiamo creando un array con nove interi. Se desideri una semplice risposta Sì/No su se quell’array contiene un certo intero, puoi ottenerla usando contains o notcontains.

PS> $array = @(2,4,5,6,8,8,9,9,9)
PS> $array -contains 9
True
PS> $array -notcontains 9
False
PS> $array -contains 5

Allo stesso modo, hai gli operatori in e notin. Questi operatori sono quasi identici a contains e notcontains con un’eccezione: il valore da confrontare è a sinistra invece che a destra.

$array = @(2,4,5,6,8,8,9,9,9)
9 -in $array
True
9 -notin $array
False

Testare “Maggiore di” con gli Operatori gt e ge

Cosa succede se hai bisogno di testare se un numero (un intero) è maggiore di un altro numero o forse maggiore o uguale a un altro numero? Useresti gli operatori gt e ge. Questi operatori confrontano gli interi.

Come gli altri operatori, anche questi restituiscono valori booleani True o False a seconda che un intero sia maggiore di un altro. Entrambi questi operatori testano se l’intero sinistro è maggiore o maggiore o uguale all’intero destro.

Nell’esempio sottostante, puoi vedere come si comportano ciascuno di questi operatori.

PS> 7 -gt 5
True
PS> 7 -gt 7
False
PS> 7 -ge 7
True

Similmente all’operatore eq che ti consente di trovare istanze nelle raccolte, puoi fare lo stesso con gli operatori ge e gt anche. PowerShell cerca in ogni elemento di una raccolta e confronta ciascun valore con quello fornito. Puoi vedere un ottimo esempio di questo qui sotto.

PS> $array =@(1,2,3,4,5,6,7,8,9,9,9,9)
PS> $array -gt 5
6
7
8
9
9
9
9
PS> $array -ge 5
5
6
7
8
9
9
9
9

Test “meno di” con gli operatori lt e le

Similmente agli operatori gt e ge, gli operatori lt e le svolgono la stessa funzione ma in modo opposto. Gli operatori lt e le confrontano due valori testando se l’intero sul lato sinistro è minore o minore o uguale all’intero sul lato destro.

Puoi vedere nell’esempio sottostante che la stessa funzionalità di confrontare ciascun valore in una raccolta si applica esattamente come per gt e ge.

PS> $array =@(1,2,3,4,5,6,7,8,9,10)
PS> $array -lt 5
1
2
3
4
PS> $array -le 5 
1
2
3
4
5

Corrispondenza basata su caratteri jolly con l’operatore Like di PowerShell

Finora, hai imparato come eseguire corrispondenze 1:1. Tutti gli operatori utilizzati finora confrontavano un valore intero con un altro, ma PowerShell ha un’altra carta da giocare. Puoi anche confrontare i valori basandoti su caratteri jolly o asterischi.

Supponiamo che tu conosca solo alcuni caratteri di una stringa. Non puoi usare eq perché eq richiede di conoscere l’intera stringa. Utilizzando l’operatore like di PowerShell, non è necessario conoscere l’intera stringa. Per testare se un valore è simile a un altro, puoi sostituire la parte che non conosci con un carattere jolly.

Come per gli altri operatori, questa stessa funzionalità può essere applicata anche alle collezioni.

Puoi vedere un esempio di operatore like di PowerShell e del suo “fratello” che fa distinzione tra maiuscole e minuscole, clike, di seguito.

PS> $string = "PowerShell"
PS> $string -like "*Shell"
True
PS> $array = @("PowerShell","Microsoft")
PS> $array -like "*Shell"
PowerShell
PS> $array -clike "*Shell"
PowerShell

L’operatore -notlike restituisce il valore booleano True se nessuna corrispondenza viene trovata e False se c’è una corrispondenza. Nel caso venga utilizzato su una collezione, restituirà tutti gli altri valori che non corrispondono al pattern fornito sul lato destro dell’operatore -notlike. Per aggiungere la sensibilità alle maiuscole e minuscole al pattern, utilizza l’operatore -cnotlike.

$string = "PowerShell" 
$string -notlike "*Shell"
False
$array = @("PowerShell","Microsoft")
$array -notlike "*Shell"
Microsoft
$array -cnotlike "*shell"
PowerShell
Microsoft

Corrispondenza basata su espressioni regolari

L’operatore simile a PowerShell e il suo relativo sono utili, ma non appena hai bisogno di corrispondenze più complesse, puoi immergerti nel profondo e oscuro mondo delle espressioni regolari (regex). Utilizzando gli operatori match e notmatch, puoi eseguire corrispondenze di stringhe estremamente complesse con le regex.

Similmente all’operatore simile a PowerShell, match e il suo opposto, notmatch, confrontano due stringhe restituendo un valore booleano True o False. Inoltre, come gli altri operatori, lo stesso comportamento può essere applicato per una raccolta, come dimostra l’esempio sottostante.

PS> $string = "PowerShell"
PS> $string -match "ow"
True 

PS> $array = @("PowerShell","Microsoft")
PS> $array -match "ow"
PowerShell

PS> $string = "PowerShell"
PS> $string -cmatch "po"
False
PS> $string -cmatch "Po"
True

PS> $array = @("PowerShell","Microsoft")
PS> $array -cmatch "Po"
PowerShell

Riassunto

In questo articolo hai appreso sull’operatore simile a PowerShell e su molti altri, e come utilizzare ciascun operatore per valori singoli e raccolte. Hai visto come l’output differisce in base all’operatore e se è uno scalare o una collezione.

Inoltre, hai visto anche operatori con sensibilità alle maiuscole, operatori di corrispondenza su come fare corrispondenza basata su espressioni regolari o caratteri jolly, e operatori di contenimento per testare se l’oggetto contiene un valore specifico o se un valore esiste in un oggetto specifico.

PowerShell Like

Source:
https://adamtheautomator.com/powershell-like/