about_Arithmetic_Operators

Article
04/06/2024

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 hachage

6 + 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 nombres

6 - 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 fois
```
6 * 2       # result = 12
@("!") * 4  # result = @("!","!","!","!")
"!" * 3     # result = "!!!"
```
Division (/) - Divise les nombres
```
6 / 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