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