about_Arithmetic_Operators
Mis à jour: mai 2014
S'applique à: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Insérez l'introduction ici.
RUBRIQUE
about_Arithmetic_Operators
DESCRIPTION COURTE
Décrit les opérateurs qui effectuent des opérations arithmétiques dans Windows PowerShell®.
DESCRIPTION DÉTAILLÉE
Les opérateurs arithmétiques calculent des valeurs numériques. Vous pouvez utiliser un ou plusieurs opérateurs arithmétiques pour ajouter, soustraire, multiplier et diviser des valeurs, ainsi que pour calculer le reste (modulo) d'une opération de division.
En outre, l'opérateur d'addition (+) et l'opérateur de multiplication (*) fonctionnent aussi sur les chaînes, les tableaux et les tables de hachage. L'opérateur d'addition concatène l'entrée. L'opérateur de multiplication renvoie plusieurs copies de l'entrée. Vous pouvez même combiner des types d'objets dans une instruction arithmétique. La méthode utilisée pour évaluer l'instruction est déterminée par le type de l'objet le plus à gauche dans l'expression.
Depuis Windows PowerShell 2.0, tous les opérateurs arithmétiques fonctionnent sur les nombres 64 bits.
Depuis Windows PowerShell 3.0, -shr (décalage vers la droite) et -shl (décalage vers la gauche) sont ajoutés pour prendre en charge les opérations arithmétiques au niveau du bit dans Windows PowerShell.
Windows PowerShell prend en charge les opérateurs arithmétiques suivants :
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
PRIORITÉ DES OPÉRATEURS
Windows PowerShell traite les opérateurs arithmétiques dans l'ordre suivant :
Parentheses ()
- (for a negative number)
*, /, %
+, - (for subtraction)
Windows PowerShell traite les expressions de gauche à droite selon les règles de priorité. Les exemples suivants illustrent les conséquences des règles de priorité :
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'ordre dans lequel Windows PowerShell évalue les expressions peut différer des autres langages de programmation et de script que vous avez utilisés. L'exemple suivant illustre une instruction d'assignation complexe.
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
Dans cet exemple, l'expression $a++ est analysée avant $c[$a++]. L'analyse de $a++ change la valeur de $a. La variable $a dans $b[$a] étant égale à 1, pas à 0, l'instruction assigne une valeur à $b[1], pas à $b[0].
DIVISION ET ARRONDI
Lorsque le quotient d'une opération de division est un entier, Windows PowerShell arrondit la valeur à l'entier le plus proche. Lorsque la valeur est .5, elle est arrondie à l'entier pair le plus proche.
L'exemple suivant illustre l'arrondi à l'entier pair le plus proche.
C:\PS> [int]( 5 / 2 )
2
C:\PS> [int]( 7 / 2 )
4
AJOUT ET MULTIPLICATION DE TYPES NON NUMÉRIQUES
Vous pouvez ajouter des nombres, des chaînes, des tableaux et des tables de hachage. Et vous pouvez multiplier des nombres, des chaînes et des tableaux. Cependant, vous ne pouvez pas multiplier des tables de hachage.
Lorsque vous ajoutez des chaînes, des tableaux ou des tables de hachage, les éléments sont concaténés. Lorsque vous concaténez des collections, telles que des tableaux ou des tables de hachage, un nouvel objet est créé qui contient les objets des deux collections. Si vous essayez de concaténer des tables de hachage qui possèdent la même clé, l'opération échoue.
Par exemple, les commandes suivantes créent deux tableaux et les ajoutent :
C:\PS> $a = 1,2,3
C:\PS> $b = "A","B","C"
C:\PS> $a + $b
1
2
3
A
B
C
Vous pouvez également effectuer des opérations arithmétiques sur des objets de types différents. L'opération que Windows PowerShell exécute est déterminée par le type Microsoft .NET Framework de l'objet le plus à gauche de l'opération. Windows PowerShell tente de convertir tous les objets de l'opération dans le type .NET Framework du premier objet. Si elle réussit à convertir les objets, elle effectue l'opération appropriée pour le type .NET Framework du premier objet. Si elle ne peut pas convertir les objets, l'opération échoue.
L'exemple suivant illustre l'utilisation des opérateurs d'addition et de multiplication dans les opérations qui incluent différents types d'objets :
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
Comme la méthode utilisée pour évaluer des instructions est déterminée par l'objet le plus à gauche, l'addition et la multiplication dans Windows PowerShell ne sont pas strictement commutatives. Par exemple, (a + b) n'est pas toujours égal à (b + a) et (a * b) n'est pas toujours égal à (b * a).
Les exemples suivants illustrent ce principe :
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"
Les tables de hachage sont un cas légèrement différent. Vous pouvez ajouter des tables de hachage. Et vous pouvez ajouter une table de hachage à un tableau. Cependant, vous ne pouvez pas ajouter un autre type à une table de hachage.
Les exemples suivants montrent comment ajouter des tables de hachage les unes aux autres et à d'autres objets :
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
Les exemples suivants montrent que vous pouvez ajouter une table de hachage à un tableau. La totalité de la table de hachage est ajoutée au tableau comme objet unique.
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
L'exemple suivant montre que vous ne pouvez pas ajouter des tables de hachage qui contiennent la même clé :
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
Bien que les opérateurs d'addition soient très utiles, préférez les opérateurs d'assignation pour ajouter des éléments à des tableaux et à des tables de hachage. Pour plus d'informations, consultez about_assignment_operators. Les exemples suivants utilisent l'opérateur d'assignation += pour ajouter des éléments à un tableau :
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 sélectionne automatiquement le type numérique du .NET Framework qui reflète au mieux le résultat sans perte de précision. Par exemple :
C:\PS> 2 + 3.1
5.1
C:\PS> (2). GetType().FullName
System.Int32
C:\PS> (2 + 3.1).GetType().FullName
System.Double
Si le résultat d'une opération est trop grand pour le type, le type du résultat est élargi pour recevoir le résultat, comme dans l'exemple suivant :
C:\PS> (512MB).GetType().FullName
System.Int32
C:\PS> (512MB * 512MB).GetType().FullName
System.Double
Le type du résultat ne sera pas nécessairement identique à celui de l'un des opérandes. Dans l'exemple suivant, la valeur négative ne peut pas être convertie en entier non signé et l'entier non signé est trop grand pour être converti en Int32 :
C:\PS> ([int32]::minvalue + [uint32]::maxvalue).gettype().fullname
System.Int64
Dans cet exemple, Int64 peut prendre en charge les deux types.
Le type System.Decimal est une exception. Si l'un des opérandes est de type Decimal, le résultat sera du même type. Si le résultat est trop grand pour le type Decimal, il ne sera pas converti en type Double. En revanche, une erreur se produit.
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
OPÉRATEURS ARITHMÉTIQUES ET VARIABLES
Vous pouvez aussi utiliser des opérateurs arithmétiques avec des variables. Les opérateurs agissent sur les valeurs des variables. Les exemples suivants illustrent l'utilisation d'opérateurs arithmétiques avec des variables :
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
OPÉRATEURS ARITHMÉTIQUES ET COMMANDES
En général, vous utilisez les opérateurs arithmétiques dans les expressions avec des nombres, des chaînes et des tableaux. Cependant, vous pouvez aussi utiliser les opérateurs arithmétiques avec les objets que les commandes retournent et avec les propriétés de ces objets.
Les exemples suivants montrent comment utiliser les opérateurs arithmétiques dans les expressions avec des commandes 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
EXEMPLES
Les exemples suivants montrent comment utiliser les opérateurs arithmétiques dans Windows PowerShell :
PS> 1 + 1
2
PS> 1 - 1
0
PS> -(6 + 3)
-9
PS> 6 * 2
12
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
ARITHMÉTIQUE AU NIVEAU DU BIT DANS WINDOWS POWERSHELL
Windows PowerShell prend en charge les opérateurs -shr (décalage vers la droite) et -shl (décalage vers la gauche) pour l'arithmétique au niveau du bit.
Ces opérateurs ont été introduits dans Windows PowerShell 3.0.
Dans une opération de décalage vers la gauche au niveau du bit, tous les bits sont déplacés de « n » places vers la gauche, où « n » désigne la valeur de l'opérande de droite. Un zéro est inséré à la place.
Lorsque l'opérande de gauche est un nombre entier (32 bits), les 5 bits de poids faible de l'opérande de droite déterminent le nombre de bits déplacés de l'opérande de gauche.
Lorsque l'opérande de gauche est un nombre de type Long (64 bits), les 6 bits de poids faible de l'opérande de droite déterminent le nombre de bits déplacés de l'opérande de gauche.
PS C:\> 21 -shl 1
42
00010101 (21)
00101010 (42)
PS C:\> 21 -shl 2
84
00010101 (21)
00101010 (42)
01010100 (84)
Dans une opération de décalage vers la droite au niveau du bit, tous les bits sont déplacés de « n » places vers la droite, où « n » est spécifié par l'opérande de droite. L'opérateur de décalage vers la droite (-shr) insère un zéro dans l'emplacement le plus à gauche lors du déplacement d'une valeur positive ou non signée vers la droite.
Lorsque l'opérande de gauche est un nombre entier (32 bits), les 5 bits de poids faible de l'opérande de droite déterminent le nombre de bits déplacés de l'opérande de gauche.
Lorsque l'opérande de gauche est un nombre de type Long (64 bits), les 6 bits de poids faible de l'opérande de droite déterminent le nombre de bits déplacés de l'opérande de gauche.
PS C:\> 21 -shr 1
10
00010101 (21)
00001010 (10)
PS C:\> 21 -shr 2
5
00010101 (21)
00001010 (10)
00000101 ( 5)
VOIR AUSSI
about_arrays
about_assignment_operators
about_comparison_operators
about_hash_tables
about_operators
about_variables
Get-Date
Get-Date
New-TimeSpan