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




Argomenti della Guida