about_Arithmetic_Operators
Description courte
Décrit les opérateurs qui effectuent des arithmétiques dans PowerShell.
Description longue
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 et calculer le reste (module) d’une opération de division.
L’opérateur d’addition (+
) et l’opérateur de multiplication (*
) opèrent également sur des chaînes, des tableaux et des tables de hachage. L’opérateur d’ajout concatène l’entrée.
L’opérateur de multiplication retourne 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 de l’expression.
À compter de PowerShell 2.0, tous les opérateurs arithmétiques fonctionnent sur des nombres 64 bits.
À compter de PowerShell 3.0, les -shr
éléments (shift-right) et -shl
(maj-left) sont ajoutés pour prendre en charge l’arithmétique au niveau du bit dans PowerShell. Les opérateurs au niveau du bit fonctionnent uniquement sur les types entiers.
PowerShell prend en charge les opérateurs arithmétiques suivants :
Ajout (
+
) : ajoute des nombres, concatène des chaînes, des tableaux et des tables de hachage6 + 2 # result = 8 "file" + "name" # result = "filename" @(1, "one") + @(2.0, "two") # result = @(1, "one", 2.0, "two") @{"one" = 1} + @{"two" = 2} # result = @{"one" = 1; "two" = 2}
Soustraction (
-
) - Soustrait ou annule les nombres6 - 2 # result = 4 - -6 # result = 6 (Get-Date).AddDays(-1) # Yesterday's date
Multiplication (
*
) : multiplier des nombres ou copier des chaînes et des tableaux le nombre spécifié de fois6 * 2 # result = 12 @("!") * 4 # result = @("!","!","!","!") "!" * 3 # result = "!!!"
Division (
/
) - Divise les nombres6 / 2 # result = 3
Modulus (
%
) : retourne le reste d’une opération de division.7 % 2 # result = 1
AND au niveau du bit (
-band
)5 -band 3 # result = 1
Not au niveau du bit (
-bnot
)-bnot 5 # result = -6
OR au niveau du bit (
-bor
)5 -bor 0x03 # result = 7
XOR au niveau du bit (
-bxor
)5 -bxor 3 # result = 6
Déplace les bits vers la gauche (
-shl
)102 -shl 2 # result = 408
Déplace les bits vers la droite (
-shr
)102 -shr 2 # result = 25
Priorité des opérateurs
PowerShell traite les opérateurs arithmétiques dans l’ordre suivant :
Priorité | Opérateur | Description |
---|---|---|
1 | () |
Parenthèses |
2 | - |
Pour un nombre négatif ou un opérateur unaire |
3 | * , , / % |
Pour la multiplication et la division |
4 | + , - |
Pour l’addition et la soustraction |
5 | -band , -bnot |
Pour les opérations au niveau du bit |
5 | -bor , -bxor |
Pour les opérations au niveau du bit |
5 | -shr , -shl |
Pour les opérations au niveau du bit |
PowerShell traite les expressions de gauche à droite en fonction des règles de précédence. Les exemples suivants montrent l’effet des règles de précédence :
3+6/3*4 # result = 11
3+6/(3*4) # result = 3.5
(3+6)/3*4 # result = 12
L’ordre dans lequel PowerShell évalue les expressions peut différer d’autres langages de programmation et de script que vous avez utilisés. L’exemple suivant montre une instruction d’affectation compliquée.
$a = 0
$b = @(1,2)
$c = @(-1,-2)
$b[$a] = $c[$a++]
Dans cet exemple, l’expression $a++
est évaluée avant $b[$a]
. L’évaluation $a++
modifie la valeur d’après $a
son utilisation dans l’instruction $c[$a++]
, mais avant d’être utilisée dans $b[$a]
. $a
Variable en égal $b[$a]
1
, et non 0
. Par conséquent, l’instruction affecte une valeur à $b[1]
, et non $b[0]
.
Le code ci-dessus équivaut à :
$a = 0
$b = @(1,2)
$c = @(-1,-2)
$tmp = $c[$a]
$a = $a + 1
$b[$a] = $tmp
Division et arrondi
Lorsque le quotient d’une opération de division est un entier, PowerShell arrondit la valeur à l’entier le plus proche. Lorsque la valeur est .5
, elle arrondit à l’entier pair le plus proche.
L’exemple suivant montre l’effet de l’arrondi à l’entier pair le plus proche.
PS> [int]( 5 / 2 ) # Result is rounded down
2
PS> [int]( 7 / 2 ) # Result is rounded up
4
Vous pouvez utiliser la [Math]
classe pour obtenir un comportement d’arrondi différent.
PS> [int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero)
3
PS> [int][Math]::Ceiling(5 / 2)
3
PS> [int][Math]::Floor(5 / 2)
2
Pour plus d’informations, consultez la méthode Math.Round .
Conversion de type en fonction du résultat
PowerShell sélectionne automatiquement le type numérique .NET qui exprime le mieux le résultat sans perdre de précision. Par exemple :
2 + 3.1
(2).GetType().FullName
(2 + 3.1).GetType().FullName
5.1
System.Int32
System.Double
Si le résultat d’une opération est trop volumineux pour le type, le type du résultat est étendu pour prendre en charge le résultat, comme dans l’exemple suivant :
(512MB).GetType().FullName
(512MB * 512MB).GetType().FullName
System.Int32
System.Double
Le type du résultat n’est pas toujours le même que 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 volumineux pour être converti en Int32
:
([int32]::minvalue + [uint32]::maxvalue).gettype().fullname
System.Int64
Dans cet exemple, Int64
peut prendre en charge les deux types.
Le System.Decimal
type est une exception. Si l’un des opérandes a le type Decimal , le résultat est de type Décimal . Tout résultat trop volumineux pour la valeur décimale est une erreur.
PS> [Decimal]::maxvalue
79228162514264337593543950335
PS> [Decimal]::maxvalue + 1
RuntimeException: Value was either too large or too small for a Decimal.
Perte potentielle de précision
Chaque fois que vous avez un résultat qui dépasse la plage du type, vous risquez de perdre la précision en raison de la conversion de type. Par exemple, l’ajout d’une taille suffisamment grande [long]
et [int]
entraîne la conversion [double]
des opérandes en . Dans cet exemple, 9223372036854775807
est la valeur maximale d’un [long]
entier.
L’ajout à la valeur dépasse la plage de [long]
.
PS> (9223372036854775807 + 2).GetType().FullName
System.Double
Caster le résultat pour [ulong]
produire un résultat incorrect, car les opérandes ont été cochés en [double]
premier.
PS> [ulong](9223372036854775807 + 2)
9223372036854775808
La définition de la plus grande valeur comme [ulong]
première évite le problème et produit le résultat correct.
PS> 9223372036854775807ul + 2
9223372036854775809
Toutefois, dépassement de la plage de [ulong]
résultats dans un [double]
.
PS> ([ulong]::MaxValue + 1).GetType().FullName
System.Double
Arithmétique Bigint
Lorsque vous effectuez des opérations arithmétiques sur [bigint]
des nombres, PowerShell utilise convertit tous les opérandes en , ce qui entraîne la troncation de valeurs non entières [bigint]
. Par exemple, la [double]
valeur 1.9
est tronquée 1
en cas de conversion en [bigint]
.
PS> [bigint]1 / 1.9
1
PS> 1 / [bigint]1.9
1
Ce comportement est différent du comportement d’autres types numériques. Dans cet exemple, une [int]
division par un [double]
résultat dans un [double]
. La conversion 1.9
en [int]
arrondit la valeur jusqu’à 2
.
PS> 1 / 1.9
0.526315789473684
PS> 1 / [int]1.9
0.5
Ajout et multiplication de types non numériques
Vous pouvez ajouter des nombres, des chaînes, des tableaux et des tables de hachage. Vous pouvez également multiplier les nombres, les chaînes et les tableaux. Toutefois, vous ne pouvez pas multiplier les 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 ont la même clé, l’opération échoue.
Par exemple, les commandes suivantes créent deux tableaux, puis les ajoutent :
$a = 1,2,3
$b = "A","B","C"
$a + $b
1
2
3
A
B
C
Vous pouvez également effectuer des opérations arithmétiques sur des objets de différents types. L’opération effectuée par PowerShell est déterminée par le type Microsoft .NET de l’objet le plus à gauche de l’opération. PowerShell tente de convertir tous les objets de l’opération en type .NET du premier objet. S’il réussit à convertir les objets, il effectue l’opération appropriée au type .NET du premier objet. Si elle ne parvient pas à convertir l’un des objets, l’opération échoue.
Les exemples suivants illustrent l’utilisation des opérateurs d’ajout et de multiplication dans les opérations qui incluent différents types d’objets.
$array = 1,2,3
$red = [ConsoleColor]::Red
$blue = [ConsoleColor]::Blue
"file" + 16 # result = "file16"
$array + 16 # result = 1,2,3,16
$array + "file" # result = 1,2,3,"file"
$array * 2 # result = 1,2,3,1,2,3
"file" * 3 # result = "filefilefile"
$blue + 3 # result = Red
$red - 3 # result = Blue
$blue - $red # result = -3
+ '123' # result = 123
Étant donné que la méthode utilisée pour évaluer les instructions est déterminée par l’objet le plus à gauche, l’ajout et la multiplication dans PowerShell ne sont pas strictement commutatives. Par exemple, (a + b)
n’est pas toujours égal (b + a)
et (ab)
n’est pas toujours égal (ba)
à .
Les exemples suivants illustrent ce principe :
PS> "file" + 16
file16
PS> 16 + "file"
InvalidArgument: can't convert value "file" to type "System.Int32". Error:
"Input string wasn't in a correct format."
Les tables de hachage sont un cas légèrement différent. Vous pouvez ajouter des tables de hachage à une autre table de hachage, tant que les tables de hachage ajoutées n’ont pas de clés en double.
L’exemple suivant montre comment ajouter des tables de hachage les unes aux autres.
$hash1 = @{a=1; b=2; c=3}
$hash2 = @{c1="Server01"; c2="Server02"}
$hash1 + $hash2
Name Value
---- -----
c2 Server02
a 1
b 2
c1 Server01
c 3
L’exemple suivant génère une erreur, car l’une des clés est dupliquée dans les deux tables de hachage.
$hash1 = @{a=1; b=2; c=3}
$hash2 = @{c1="Server01"; c="Server02"}
$hash1 + $hash2
OperationStopped:
Line |
3 | $hash1 + $hash2
| ~~~~~~~~~~~~~~~
| Item has already been added. Key in dictionary: 'c' Key being added: 'c'
En outre, vous pouvez ajouter une table de hachage à un tableau ; et, la table de hachage entière devient un élément dans le tableau.
$array1 = @(0, "Hello World", [datetime]::Now)
$hash1 = @{a=1; b=2}
$array2 = $array1 + $hash1
$array2
0
Hello World
Monday, June 12, 2017 3:05:46 PM
Key : a
Value : 1
Name : a
Key : b
Value : 2
Name : b
Toutefois, vous ne pouvez pas ajouter d’autre type à une table de hachage.
$hash1 + 2
InvalidOperation: A hash table can only be added to another hash table.
Bien que les opérateurs d’ajout soient très utiles, utilisez les opérateurs d’affectation pour ajouter des éléments aux tables et tableaux de hachage. Pour plus d’informations, consultez about_assignment_operators. Les exemples suivants utilisent l’opérateur d’affectation +=
pour ajouter des éléments à un tableau :
$array = @()
(0..2).foreach{ $array += $_ }
$array
0
1
2
Opérateurs et variables arithmétiques
Vous pouvez également 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 :
PS> $intA = 6
PS> $intB = 4
PS> $intA + $intB
10
PS> $a = "Power"
PS> $b = "Shell"
PS> $a + $b
PowerShell
Opérateurs et commandes arithmétiques
En règle générale, vous utilisez les opérateurs arithmétiques dans les expressions avec des nombres, des chaînes et des tableaux. Toutefois, vous pouvez également utiliser des opérateurs arithmétiques avec les objets retournés par les commandes et avec les propriétés de ces objets.
Les exemples suivants montrent comment utiliser les opérateurs arithmétiques dans des expressions avec des commandes PowerShell :
(Get-Date) + (New-TimeSpan -day 1)
L’opérateur de parenthèse force l’évaluation de l’applet Get-Date
de commande et l’évaluation de l’expression New-TimeSpan -Day 1
d’applet de commande, dans cet ordre. Les deux résultats sont ensuite ajoutés à l’aide de l’opérateur +
.
Get-Process | Where-Object { ($_.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
Dans l’expression ci-dessus, chaque espace de travail de processus ($_.ws
) est multiplié par 2
; et, le résultat, comparé 50mb
à pour voir s’il est supérieur à cela.
Opérateurs de bits
PowerShell prend en charge les opérateurs au niveau du bit standard, notamment bitwise-AND (-band
), les opérateurs bitwise-OR inclusifs et exclusifs (-bor
et -bxor
) et not au niveau du bit (-bnot
).
À compter de PowerShell 2.0, tous les opérateurs au niveau du bit fonctionnent avec des entiers 64 bits.
À partir de PowerShell 3.0, les -shr
éléments (maj-droite) et -shl
(maj-left) sont introduits pour prendre en charge l’arithmétique au niveau du bit dans PowerShell.
PowerShell prend en charge les opérateurs au niveau du bit suivants.
Opérateur | Description | Expression | Résultats |
---|---|---|---|
-band |
ET au niveau du bit | 10 -band 3 |
2 |
-bor |
OR au niveau du bit (inclusif) | 10 -bor 3 |
11 |
-bxor |
OR au niveau du bit (exclusif) | 10 -bxor 3 |
9 |
-bnot |
NOT au niveau du bit | -bNot 10 |
-11 |
-shl |
Test de | 102 -shl 2 |
408 |
-shr |
Test de | 102 -shr 1 |
51 |
Les opérateurs au niveau du bit agissent sur le format binaire d’une valeur. Par exemple, la structure de bits du nombre 10 est 00001010 (basée sur 1 octet) et la structure de bits pour le nombre 3 est 00000011. Lorsque vous utilisez un opérateur au niveau du bit pour comparer 10 à 3, les bits individuels de chaque octet sont comparés.
Dans une opération AND au niveau du bit, le bit obtenu est défini sur 1 uniquement lorsque les deux bits d’entrée sont 1.
1010 (10)
0011 ( 3)
-------------- bAND
0010 ( 2)
Dans une opération OR (inclusive) au niveau du bit, le bit obtenu est défini sur 1 lorsque les deux bits d’entrée sont 1. Le bit obtenu est défini sur 0 uniquement lorsque les deux bits d’entrée sont définis sur 0.
1010 (10)
0011 ( 3)
-------------- bOR (inclusive)
1011 (11)
Dans une opération OR (exclusive) au niveau du bit, le bit obtenu est défini sur 1 uniquement lorsqu’un bit d’entrée est 1.
1010 (10)
0011 ( 3)
-------------- bXOR (exclusive)
1001 ( 9)
L’opérateur NOT au niveau du bit est un opérateur unaire qui produit le complément binaire de la valeur. Un peu de 1 est défini sur 0 et un peu de 0 est défini sur 1.
Par exemple, le complément binaire de 0 est -1, l’entier non signé maximal (0xFFFFFFFF) et le complément binaire de -1 est 0.
-bNot 10
-11
0000 0000 0000 1010 (10)
------------------------- bNOT
1111 1111 1111 0101 (-11, 0xFFFFFFF5)
Dans une opération shift-left au niveau du bit, tous les bits sont déplacés « n » à gauche, où « n » est la valeur de l’opérande droit. Un zéro est inséré à l’emplacement.
Expression | Résultats | Résultat binaire |
---|---|---|
21 -shl 0 |
21 | 0001 0101 |
21 -shl 1 |
42 | 0010 1010 |
21 -shl 2 |
84 | 0101 0100 |
Dans une opération shift-right au niveau du bit, tous les bits sont déplacés « n » à droite, où « n » est spécifié par l’opérande droit. L’opérateur maj-droite (-shr
) copie le bit de signe à gauche le plus à gauche lors du déplacement d’une valeur signée. Pour les valeurs non signées, un zéro est inséré dans la position la plus à gauche.
Expression | Résultats | Binaire | Hex |
---|---|---|---|
21 -shr 0 |
21 | 00010101 | 0x15 |
21 -shr 1 |
10 | 00001010 | 0x0A |
21 -shr 2 |
5 | 00000101 | 0x05 |
21 -shr 31 |
0 | 00000000 | 0x00 |
21 -shr 32 |
21 | 00010101 | 0x15 |
21 -shr 64 |
21 | 00010101 | 0x15 |
21 -shr 65 |
10 | 00001010 | 0x0A |
21 -shr 66 |
5 | 00000101 | 0x05 |
[int]::MaxValue -shr 1 |
1073741823 | 00111111111111111111111111111111 | 0x3FFFFFFF |
[int]::MinValue -shr 1 |
-1073741824 | 11000000000000000000000000000000 | 0xC0000000 |
-1 -shr 1 |
-1 | 11111111111111111111111111111111 | 0xFFFFFFFF |
(-21 -shr 1) |
-11 | 11111111111111111111111111110101 | 0xFFFFFFF5 |
(-21 -shr 2) |
-6 | 11111111111111111111111111111010 | 0xFFFFFFF4 |
Voir aussi
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour