about_Arithmetic_Operators
Aggiornamento: maggio 2014
Si applica a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Inserire l'introduzione qui.
ARGOMENTO
about_Arithmetic_Operators
DESCRIZIONE BREVE
Questo articolo descrive gli operatori che eseguono operazioni aritmetiche in Windows PowerShell®.
DESCRIZIONE LUNGA
Gli operatori aritmetici calcolano valori numerici. È possibile usare uno o più operatori aritmetici per aggiungere, sottrarre, moltiplicare e dividere valori e per calcolare il resto (modulo) di un'operazione di divisione.
Inoltre, l'operatore di addizione (+) e l'operatore di moltiplicazione (*) funzionano anche su stringhe, matrici e tabelle hash. L'operatore di addizione concatena l'input. L'operatore di moltiplicazione restituisce più copie dell'input. È possibile perfino combinare tipi di oggetto in un'istruzione aritmetica. Il metodo che viene utilizzato per valutare l'istruzione è determinato dal tipo di oggetto più a sinistra nell'espressione.
A partire da Windows PowerShell 2.0, tutti gli operatori aritmetici lavorano su numeri a 64 bit.
A partire da Windows PowerShell3.0, -shr (spostamento a destra) e -shl (spostamento a sinistra) vengono aggiunti per supportare operazioni aritmetiche bit per bit in Windows PowerShell.
Windows PowerShell supporta gli operatori aritmetici seguenti:
Operator Description Example
-------- ----------- -------
+ Adds integers; concatenates strings, 6+2
arrays, and hash tables. "file" + "name"
- Subtracts one value from another 6-2
value. (get-date).date - 1
- Makes a number a negative number. -6+2
-4
* Multiplies integers; copies strings 6*2
and arrays the specified number of "w" * 3
times.
/ Divides two values. 6/2
% Returns the remainder of a division 7%2
operation.
-shl Shift-left 100 -shl 2
-shr Shift-right 100 -shr 1
PRECEDENZA TRA GLI OPERATORI
Windows PowerShell elabora gli operatori aritmetici nell'ordine seguente:
Parentheses ()
- (for a negative number)
*, /, %
+, - (for subtraction)
Windows PowerShell elabora le espressioni 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 Windows PowerShell valuta le espressioni potrebbe differire dagli altri linguaggi di programmazione e di script 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 è 0, quindi l'istruzione assegna un valore $b[1], diverso da $b[0].
DIVISIONE E ARROTONDAMENTO
Quando il quoziente di un'operazione di divisione è un numero intero, Windows PowerShell arrotonda il valore al valore intero più vicino. Quando il valore è 5, viene arrotondato al valore intero pari più vicino.
Nell'esempio seguente viene mostrato l'effetto dell'arrotondamento al valore intero pari più vicino.
C:\PS> [int]( 5 / 2 )
2
C:\PS> [int]( 7 / 2 )
4
ADDIZIONE E MOLTIPLICAZIONE DI TIPI NON NUMERICI
È possibile aggiungere numeri, stringhe, matrici e tabelle hash. È anche possibile moltiplicare numeri, stringhe e matrici. Tuttavia, non è possibile moltiplicare 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 da entrambe le raccolte. Se si prova a concatenare le tabelle hash che hanno la stessa chiave, l'operazione ha esito negativo.
Ad esempio, i seguenti comandi creano due matrici e quindi le aggiungono:
C:\PS> $a = 1,2,3
C:\PS> $b = "A","B","C"
C:\PS> $a + $b
1
2
3
A
B
C
È anche possibile eseguire operazioni aritmetiche su oggetti di tipi diversi. L'operazione che Windows PowerShell esegue è determinata dal tipo di Microsoft .NET Framework dell'oggetto più a sinistra nell'operazione. Windows PowerShell prova a convertire tutti gli oggetti nell'operazione nel tipo di .NET Framework del primo oggetto. Se riesce a convertire gli oggetti, esegue l'operazione appropriata per il tipo di .NET Framework del primo oggetto. Se non riesce a convertire gli oggetti, l'operazione ha esito negativo.
Nell'esempio seguente viene illustrato l'uso degli operatori di addizione e moltiplicazione nelle operazioni che includono diversi tipi di oggetto:
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 che viene usato per valutare le istruzioni è determinato dall'oggetto più a sinistra, l'addizione e la moltiplicazione in Windows PowerShell non sono strettamente commutative. Ad esempio, (a + b) non sempre è uguale a (b + a) e (a * b) non è sempre uguale a (b * a).
Negli esempi seguenti viene illustrato questo principio:
C:\PS> "file" + 2
file2
C:\PS> 2 + "file"
Cannot convert value "file" to type "System.Int32". Error: "Input
string was not in a correct format."
At line:1 char:4
+ 2 + <<<< "file"
C:\PS> "file" * 3
filefilefile
C:\PS> 3 * "file"
Cannot convert value "file" to type "System.Int32". Error: "Input
string was not in a correct format."
At line:1 char:4
+ 3 * <<<< "file"
Le tabelle hash rappresentano un caso leggermente diverso. È possibile aggiungere tabelle hash. Ed è anche possibile aggiungere una tabella hash a una matrice. Tuttavia, non è possibile aggiungere qualsiasi altro tipo a una tabella hash.
Negli esempi seguenti viene illustrano come aggiungere tabelle hash tra loro e ad altri oggetti:
C:\PS> $hash1 = @{a=1; b=2; c=3}
C:\PS> $hash2 = @{c1="Server01"; c2="Server02"}
C:\PS> $hash1 + $hash2
Name Value
---- -----
c2 Server02
a 1
b 2
c1 Server01
c 3
C:\PS> $hash1 + 2
You can add another hash table only to a hash table.
At line:1 char:9
+ $hash1 + <<<< 2
C:\PS> 2 + $hash1
Cannot convert "System.Collections.Hashtable" to "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 singolo oggetto.
C:\PS> $array = 1,2,3
C:\PS> $array + $hash1
1
2
3
Name Value
---- -----
a 1
b 2
c 3
C:\PS> $sum = $array + $hash1
C:\PS> $sum.count
4
C:\PS> $sum[3]
Name Value
---- -----
a 1
b 2
c 3
PS C:\ps-test> $sum + $hash2
1
2
3
Name Value
---- -----
a 1
b 2
c 3
c2 Server02
Nell'esempio seguente viene illustrato che non è possibile aggiungere tabelle hash contenenti la stessa chiave:
C:\PS> $hash1 = @{a=1; b=2; c=3}
C:\PS> $hash2 = @{c="red"}
C:\PS> $hash1 + $hash2
Bad argument to operator '+': Item has already been added.
Key in dictionary: 'c' Key being added: 'c'.
At line:1 char:9
+ $hash1 + <<<< $hash2
Sebbene gli operatori di addizione sono molto utili, è possibile usare gli operatori di assegnazione per aggiungere elementi a matrici e tabelle hash. Per altre informazioni, vedere about_assignment_operators. Gli esempi seguenti usano 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
Name Value
---- -----
a 1
b 2
c 3
C:\PS> $hash1 += @{e = 5}
C:\PS> $hash1
Name Value
---- -----
a 1
b 2
e 5
c 3
Windows PowerShell seleziona automaticamente il tipo numerico di .NET Framework in grado di esprimere meglio il risultato senza perdita di 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 esteso per contenere il risultato, come nell'esempio seguente:
C:\PS> (512MB).GetType().FullName
System.Int32
C:\PS> (512MB * 512MB).GetType().FullName
System.Double
Il tipo di risultato non sarà necessariamente uguale a uno degli operandi. Nell'esempio seguente, non è possibile eseguire il cast del valore negativo in un valore intero senza segno e il valore intero senza segno è troppo grande affinché sia possibile eseguirne il casto in Int32:
C:\PS> ([int32]::minvalue + [uint32]::maxvalue).gettype().fullname
System.Int64
In questo esempio, Int64 è in grado di soddisfare entrambi i tipi.
Il tipo System.Decimal è un'eccezione. Se uno degli operandi presenta il tipo Decimale, il risultato sarà del tipo Decimale. Se il risultato è troppo grande per il tipo Decimale, non verrà eseguito il cast in Doppio. Al contrario, verrà generato un errore.
C:\PS> [Decimal]::maxvalue
79228162514264337593543950335
C:\PS> [Decimal]::maxvalue + 1
Value was either too large or too small for a Decimal.
At line:1 char:22
+ [Decimal]::maxvalue + <<<< 1
OPERATORI ARITMETICI E VARIABILI
È anche possibile usare gli operatori aritmetici con variabili. Gli operatori agiscono sui valori delle variabili. Negli esempi seguenti viene illustrato l'uso degli operatori aritmetici con 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 PowerShell2
OPERATORI ARITMETICI E COMANDI
In genere, si usano gli operatori aritmetici nelle espressioni con numeri, stringhe e matrici. Tuttavia, è possibile anche usare gli operatori aritmetici con oggetti che i comandi restituiscono e con le proprietà di tali oggetti.
Negli esempi seguenti viene illustrato come usare gli operatori aritmetici nelle espressioni con i comandi di Windows PowerShell:
C:\PS> get-date
Wednesday, January 02, 2008 1:28:42 PM
C:\PS> $day = new-timespan -day 1
C:\PS> get-date + $day
Thursday, January 03, 2008 1:34:52 PM
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 usare 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"
Cannot convert value "w" to type "System.Int32". Error: "Input string was not in a correct format."
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"}
Name Value
---- -----
3 Server03
2 Server02
1 Server01
0 LocalHost
C:\PS> $servers
Name Value
---- -----
2 Server02
1 Server01
0 LocalHost
C:\PS> $servers += @{3 = "Server03"} #Use assignment operator
C:\PS> $servers
Name Value
---- -----
3 Server03
2 Server02
1 Server01
0 LocalHost
OPERAZIONI ARITMETICHE BIT PER BIT IN WINDOWS POWERSHELL
Windows PowerShell supporta gli operatori -shl (spostamento a sinistra) e -shr (spostamento a destra) per operazioni aritmetiche bit per bit.
Questi operatori vengono introdotti in Windows PowerShell 3.0.
In un'operazione di spostamento a sinistra bit per bit, tutti i bit vengono spostati a sinistra di "n" posizioni, dove "n" è il valore dell'operando di destra. Un valore zero viene inserito in tali posizioni.
Quando l'operando sinistro è un valore intero (32 bit), i 5 bit inferiori dell'operando destro determinano il numero di bit dell'operando sinistro da spostare.
Quando l'operando sinistro è un valore Long (64 bit), i 6 bit inferiori dell'operando destro determinano il numero di bit dell'operando sinistro da spostare.
PS C:\> 21 -shl 1
42
00010101 (21)
00101010 (42)
PS C:\> 21 -shl 2
84
00010101 (21)
00101010 (42)
01010100 (84)
In un'operazione di spostamento a destra bit per bit, tutti i bit vengono spostati a destra di "n" posizioni, dove "n" è specificato dall'operando di destra. L'operatore di spostamento a destra (-shr) inserisce uno zero nella posizione più a sinistra durante lo spostamento a destra di un valore positivo o senza segno.
Quando l'operando sinistro è un valore intero (32 bit), i 5 bit inferiori dell'operando destro determinano il numero di bit dell'operando sinistro da spostare.
Quando l'operando sinistro è un valore Long (64 bit), i 6 bit inferiori dell'operando destro determinano il numero di bit dell'operando sinistro da spostare.
PS C:\> 21 -shr 1
10
00010101 (21)
00001010 (10)
PS C:\> 21 -shr 2
5
00010101 (21)
00001010 (10)
00000101 ( 5)
VEDERE ANCHE
about_arrays
about_assignment_operators
about_comparison_operators
about_hash_tables
about_operators
about_variables
Get-Date
Get-Date
New-TimeSpan