ARGOMENTO
    about_Arithmetic_Operators

DESCRIZIONE BREVE
    Descrive gli operatori che eseguono operazioni aritmetiche in Windows 
    PowerShell.

DESCRIZIONE DETTAGLIATA

    Gli operatori aritmetici calcolano valori numerici. È possibile 
    utilizzare uno o più operatori aritmetici per sommare, sottrarre, 
    moltiplicare e dividere valori e per calcolare il resto di 
    un'operazione di divisione.

    Inoltre, anche l'operatore di addizione (+) e di moltiplicazione 
    (*) operano su stringhe, matrici e tabelle hash. L'operatore di 
    addizione concatena l'input. Restituisce inoltre più copie 
    dell'input. È inoltre possibile combinare tipi di oggetto in 
    un'istruzione aritmetica.
    Il metodo utilizzato per valutare l'istruzione viene determinato 
    dal tipo di oggetto più a sinistra nell'espressione.

    In Windows PowerShell sono supportati gli operatori aritmetici 
    seguenti:


    Operatore  Descrizione                             Esempio
    --------  -----------                              -------
    +         Aggiunge valori interi; concatena        6+2
              stringhe, matrici e tabelle hash.        "file" + "nome"

    -         Sottrae un valore da un altro valore.    6-2 
                                                       (get-date) .date - 1

    -         Rende un numero negativo.                -6+2
                                                       -4

    *         Moltiplica valori interi; copia          6*2
              stringhe e matrici per il numero         "w" * 3
              di volte specificato.     
                   
    /         Divide due valori.                       6/2

    %         Restituisce il resto di un'operazione    7%2
              di divisione.     
 
 

    PRECEDENZA TRA GLI OPERATORI
    In Windows PowerShell gli operatori aritmetici vengono eseguiti 
    nell'ordine seguente:

        Parentesi ()
        - (per un numero negativo)
        *, /, %
        +, - (per la sottrazione)


    In Windows PowerShell le espressioni vengono elaborate da 
    sinistra a destra in base alle regole di precedenza. Negli esempi 
    seguenti viene illustrato l'effetto delle regole di precedenza: 

        C:\PS> 3+6/3*4 
        11

        C:\PS> 10+4/2
        12

        C:\PS> (10+4)/2
        7

        C:\PS> (3+3)/ (1+1)
        3
 
    L'ordine in cui vengono valutate le espressioni di Windows 
    PowerShell potrebbe differire rispetto ad altri linguaggi di 
    programmazione e scripting utilizzati. Nell'esempio seguente 
    viene illustrata un'istruzione di assegnazione complicata.

        C:\PS> $a = 0
        C:\PS> $b = 1,2
        C:\PS> $c = -1,-2
        
        C:\PS> $b[$a] = $c[$a++]
        
        C:\PS> $b
        1
        -1

    In questo esempio, l'espressione $a++ viene valutata prima di 
    $c[$a++]. La valutazione di $a++ modifica il valore di $a. La 
    variabile $a in $b [$a] è uguale a 1, non a 0, pertanto 
    l'istruzione assegna un valore $b[1], non $b[0].



    ADDIZIONE E MOLTIPLICAZIONE DI TIPI NON NUMERICI
    È possibile aggiungere numeri, stringhe, matrici e tabelle hash. 
    È inoltre possibile moltiplicare numeri, stringhe e matrici. Non 
    è tuttavia possibile moltiplicare le tabelle hash.

    Quando si aggiungono stringhe, matrici o tabelle hash, gli 
    elementi vengono concatenati. Quando si concatenano raccolte, ad 
    esempio matrici o tabelle hash, viene creato un nuovo oggetto che 
    contiene gli oggetti di entrambe le raccolte. Se si tenta di 
    concatenare tabelle hash che dispongono della stessa chiave, 
    l'operazione ha esito negativo.

    Ad esempio, nei comandi seguenti vengono create due matrici, che 
    vengono successivamente aggiunte:


	C:\PS> $a = 1,2,3
	C:\PS> $b = "A","B,"C"
	C:\PS> $a + $b
	1
	2
	3
	A
	B
	C
 

    È inoltre possibile eseguire operazioni aritmetiche su oggetti di 
    tipi diversi. L'operazione eseguita da Windows PowerShell viene 
    determinata dal tipo Microsoft .NET Framework dell'oggetto più a 
    sinistra nell'operazione.
    Windows PowerShell tenta di convertire tutti gli oggetti 
    nell'operazione nel tipo .NET Framework del primo 
    oggetto. Se la conversione degli oggetti ha esito positivo, viene 
    eseguita l'operazione adatta al tipo .NET Framework del primo 
    oggetto. Se la conversione di uno qualsiasi degli oggetti ha 
    esito negativo, l'operazione non riesce. 

    Nell'esempio seguente viene illustrato l'utilizzo degli operatori 
    di addizione e moltiplicazione nelle operazioni che includono 
    tipi di oggetti diversi:


        C:\PS> "file" + 16
        file16

        C:\PS> $array = 1,2,3
        C:\PS> $array + 16
        1
        2
        3
        16

	C:\PS> $array + "file"
        1
        2
        3
        file

        C:\PS> "file" * 3
        filefilefile
 
    Poiché il metodo utilizzato per valutare le istruzioni viene 
    determinato dall'oggetto più a sinistra, l'addizione e la 
    moltiplicazione in Windows PowerShell non sono necessariamente 
    commutative. Ad esempio, (a + b) non è sempre uguale a (b + a) e 
    (a * b) non è sempre uguale a (b * a).

    Questo principio è dimostrato negli esempi seguenti:

        C:\PS> "file" + 2
        file2

        C:\PS> 2 + "file"
        Impossibile convertire il valore "file" nel tipo 
        "System.Int32". Errore: "Stringa di input non in formato 
        corretto."
        At line:1 char:4
        + 2 + <<<< "file"

        C:\PS> "file" * 3
        filefilefile

        C:\PS> 3 * "file"
        Impossibile convertire il valore "file" nel tipo 
        "System.Int32". Errore: "Stringa di input non in formato 
        corretto."
        At line:1 char:4
        + 3 * <<<< "file"
 

    Le tabelle hash rappresentano un caso leggermente diverso. È possibile 
    aggiungere le tabelle hash. È inoltre possibile aggiungere una 
    tabella hash a una matrice. Tuttavia, non è possibile aggiungere 
    alcun altro tipo a una tabella hash. 

    Negli esempi seguenti viene illustrato come aggiungere le tabelle 
    hash le une alle altre e ad altri oggetti:


        C:\PS> $hash1 = @{a=1; b=2; c=3}
        C:\PS> $hash2 = @{c1="Server01"; c2="Server02"}
        C:\PS> $hash1 + $hash2

        Nome                           Valore
        ----                           -----
        c2                             Server02 
                                       1
        b                              2
        c1                             Server01 
                                       3


        C:\PS> $hash1 + 2
        È possibile aggiungere un'altra tabella hash solo a una 
        tabella hash.
        At line:1 char:9
        + $hash1 + <<<< 2


        C:\PS> 2 + $hash1
        Impossibile convertire "System.Collections.Hashtable" in 
        "System.Int32".
        At line:1 char:4
        + 2 + <<<< $hash1
 

    Negli esempi seguenti viene illustrato che è possibile aggiungere 
    una tabella hash a una matrice. L'intera tabella hash viene 
    aggiunta alla matrice come un oggetto singolo.


        C:\PS> $array = 1,2,3
        C:\PS> $array + $hash1
        1
        2
        3

        Nome                           Valore
        ----                           -----
        a                              1
        b                              2
        c                              3


        C:\PS> $sum = $array + $hash1
        C:\PS> $sum.count
        4

        C:\PS> $sum[3]
        Nome                           Valore
        ----                           -----
        a                              1
        b                              2
        c                              3


        PS C:\ps-test> $sum + $hash2
        1
        2
        3

        Nome                           Valore
        ----                           -----
        a                              1
        b                              2
        c                              3
        c2                             Server02 

    Nell'esempio seguente viene illustrato che non è possibile 
    aggiungere tabelle hash che contengono la stessa chiave:

        C:\PS> $hash1 = @{a=1; b=2; c=3}
        C:\PS> $hash2 = @{c="red"}
        C:\PS> $hash1 + $hash2
        Argomento errato per l'operatore '+': l'elemento è già stato 
        aggiunto. Chiave nel dizionario: 'c'    Chiave da aggiungere: 'c'.
        At line:1 char:9
        + $hash1 + <<<< $hash2
 


    Sebbene gli operatori di addizione siano molto utili, utilizzare 
    gli operatori di assegnazione per aggiungere elementi a tabelle 
    hash e matrici. Per ulteriori informazioni, vedere about_assignmen
    t_operators. Negli esempi seguenti viene utilizzato l'operatore 
    di assegnazione += per aggiungere elementi a una matrice:

        C:\PS> $array
        1
        2
        3

        C:\PS> $array + "file"
        1
        2
        3
        file

        C:\PS> $array
        1
        2
        3

        C:\PS> $array += "file"
        C:\PS> $array
        1
        2
        3
        file

        C:\PS> $hash1

        Nome                           Valore
        ----                           -----
        a                              1
        b                              2
        c                              3

        C:\PS> $hash1 += @{e = 5}
        C:\PS> $hash1

        Nome                           Valore
        ----                           -----
        a                              1
        b                              2
        e                              5
        c                              3
 

    Windows PowerShell seleziona automaticamente il tipo numerico 
    .NET Framework che esprime meglio il risultato senza perdere 
    precisione. Ad esempio:

        C:\PS> 2 + 3.1
        5.1
        C:\PS> (2). GetType().FullName
        System.Int32
        C:\PS> (2 + 3.1).GetType().FullName
        System.Double

    Se il risultato di un'operazione è troppo grande per il tipo, il 
    tipo del risultato viene convertito nel tipo di dati più grande 
    in grado di contenere il risultato, come nell'esempio seguente: 

        C:\PS> (512MB).GetType().FullName
        System.Int32
        C:\PS> (512MB * 512MB).GetType().FullName
        System.Double

    Il tipo del risultato non corrisponderà necessariamente a uno 
    degli operandi. Nell'esempio seguente non è possibile eseguire il 
    cast del valore negativo a un valore intero senza segno e il 
    valore intero senza segno è troppo grande perché ne venga 
    eseguito il cast a Int32:

        C:\PS> ([int32]::minvalue + [uint32]::maxvalue).gettype().fullname
        System.Int64

    In questo esempio, Int64 può contenere entrambi i tipi.

    Il tipo System.Decimal è un'eccezione. Se il tipo di un operando 
    è Decimal, il risultato sarà di tipo Decimal. Se il risultato è 
    troppo grande per il tipo Decimal, non verrà eseguito il cast a 
    Double. Verrà invece restituito un errore.
    
        C:\PS> [Decimal]::maxvalue
        79228162514264337593543950335
        C:\PS> [Decimal]::maxvalue + 1
        Il valore era troppo grande o troppo piccolo per un tipo Decimal.
        At line:1 char:22
        + [Decimal]::maxvalue + <<<< 1


    OPERATORI ARITMETICI E VARIABILI
    È inoltre possibile utilizzare gli operatori aritmetici con le 
    variabili. Gli operatori intervengono sui valori delle variabili. 
    Negli esempi seguenti viene illustrato l'utilizzo degli operatori 
    aritmetici con le variabili:

        C:\PS> $intA = 6 
        C:\PS> $intB = 4 
        C:\PS> $intA + $intB 

        10 


        C:\PS> $a = "Windows " 
        C:\PS> $b = "PowerShell " 
        C:\PS> $c = 2 
	C:\PS> $a + $b + $c

        Windows PowerShell 2 


    OPERATORI ARITMETICI E COMANDI
    In genere, gli operatori aritmetici vengono utilizzati nelle 
    espressioni con numeri, stringhe e matrici. Tuttavia, è possibile 
    utilizzarli anche con gli oggetti restituiti dai comandi e con le 
    proprietà di tali oggetti.

    Negli esempi seguenti viene illustrato come utilizzare gli 
    operatori aritmetici in espressioni con comandi di Windows PowerShell:


	C:\PS> get-date
	mercoledì 02 gennaio 2008 1.28.42


	C:\PS> $day = new-timespan -day 1
	C:\PS> get-date + $day
	giovedì 03 gennaio 2008 1.34.52


	C:\PS> get-process | where {($_.ws * 2) -gt 50mb}
	Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName    
	-------  ------    -----      ----- -----   ------     -- -----------
	   1896      39    50968      30620   264 1,572.55   1104 explorer
	  12802      78   188468      81032   753 3,676.39   5676 OUTLOOK
	    660       9    36168      26956   143    12.20    988 powershell
	    561      14     6592      28144   110 1,010.09    496 services
	   3476      80    34664      26092   234 ...45.69    876 svchost
	    967      30    58804      59496   416   930.97   2508 WINWORD

ESEMPI
    Negli esempi seguenti viene illustrato come utilizzare gli 
    operatori aritmetici in Windows PowerShell:

	C:\PS> 1 + 1
	2 

	C:\PS> 1 - 1 
	0 

	C:\PS> -(6 + 3) 
	-9 

	C:\PS> 6 * 2 
	12 

	C:\PS> 7 / 2 
	3.5 

	C:\PS> 7 % 2 
	1 

	C:\PS> w * 3 
	www 

	C:\PS> 3 * "w" 
	Impossibile convertire il valore "w" nel tipo "System.Int32". Errore: 
	"Stringa di input non in formato corretto." 
	At line:1 char:4 
	+ 3 * <<<< "w" 

	PS C:\ps-test> "Windows" + " " + "PowerShell" 
	Windows PowerShell 

	PS C:\ps-test> $a = "Windows" + " " + "PowerShell" 
	PS C:\ps-test> $a 
	Windows PowerShell 

	C:\PS> $a[0] 
	W 

	C:\PS> $a = "TestFiles.txt" 
	C:\PS> $b = "C:\Logs\" 
	C:\PS> $b + $a 
	C:\Logs\TestFiles.txt 

	C:\PS> $a = 1,2,3 
	C:\PS> $a + 4 
	1 
	2 
	3 
	4 

	C:\PS> $servers = @{0 = "LocalHost"; 1 = "Server01"; 2 = "Server02"} 
	C:\PS> $servers + @{3 = "Server03"} 
	Nome Valore 
	---- ----- 
	3 Server03 
	2 Server02 
	1 Server01 
	0 LocalHost 

	C:\PS> $servers 
	Nome Valore 
	---- ----- 
	2 Server02 
	1 Server01 
	0 LocalHost 

	C:\PS> $servers += @{3 = "Server03"} #Utilizzare l'operatore di 
	assegnazione 
	C:\PS> $servers 
	Nome Valore 
	---- ----- 
	3 Server03 
	2 Server02 
	1 Server01 
	0 LocalHost 


VEDERE ANCHE
    about_arrays
    about_assignment_operators
    about_comparison_operators
    about_hash_tables
    about_operators
    about_variables
    Get-Date
    New-TimeSpan




Argomenti della Guida