RUBRIQUE

about_Arithmetic_Operators

DESCRIPTION COURTE

Décrit les opérateurs qui exécutent des opérations arithmétiques

dans Windows 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,

ou bien calculer le reste (modulo) d'une division.

De plus, l'opérateur d'addition (+) et l'opérateur de

multiplication (*) s'appliquent également aux chaînes, aux

tableaux et aux tables de hachage. L'opérateur d'addition

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 situé le plus à gauche dans l'expression.

Windows PowerShell prend en charge les opérateurs arithmétiques

suivants :

Opérateur Description Exemple

-------- ----------- -------

+ Ajoute des entiers, ou concatène 6+2

des chaînes, des ableaux et des "fichier" + "nom"

 tables tde hachage.

- Soustrait une valeur d'une 6-2

autre valeur. (get-date).date - 1

- Convertit un nombre en nombre négatif. -6+2

-4

* Multiplie des entiers, ou copie des 6*2

chaînes et des tableaux le nombre "w" * 3

de fois spécifié.

/ Divise deux valeurs. 6/2

% Retourne le reste d'une division. 7%2

PRÉCÉDENCE DES OPÉRATEURS

Windows PowerShell traite les opérateurs arithmétiques dans

l'ordre suivant :

Parenthèses ()

- (pour un nombre négatif)

*, /, %

+, - (pour la soustraction)

Windows PowerShell traite les expressions de gauche à droite en

respectant les règles de précédence. Les exemples suivants montrent

l'effet des règles de précédence :

 C:\PS> 3+6/3*4

11

C:\PS> 10+4/2

12

C:\PS> (10+4)/2

C:\PS> (3+3)/ (1+1)

L'ordre dans lequel Windows PowerShell évalue les expressions

peut être différent de celui d'autres langages de programmation

et de script que vous avez utilisés. L'exemple suivant présente

une instruction d'affectation 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

Dans cet exemple, l'expression $a++ est évaluée avant $c[$a++].

L'évaluation de l'expression $a++ modifie la valeur de $a. La

variable $a de $b[$a] étant égale à 1, et non pas à 0,

l'instruction attribue une valeur à $b[1], et non pas à $b[0].

AJOUT ET MULTIPLICATION DE TYPES NON NUMÉRIQUES

Vous pouvez ajouter des nombres, des chaînes, des tableaux et des

tables de hachage. Vous avez également la possibilité de multiplier

des nombres, des chaînes et des 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 objet contenant les objets des deux collections est créé.

Si vous tentez de concaténer des tables de hachage ayant la

même clé, l'opération échoue.

Par exemple, les commandes suivantes créent deux tableaux, puis

les ajoutent :

C:\PS> $a = 1,2,3

C:\PS> $b = "A","B,"C"

C:\PS> $a + $b

C
Vous pouvez également exécuter des opérations arithmétiques sur

des objets de types différents. L'opération exécutée par Windows

PowerShell est déterminée par le type Microsoft .NET Framework

del'objet situé le plus à gauche dans l'opération.

Windows PowerShell tente de convertir tous les objets de

l'opération vers le type .NET Framework du premier

objet. S'il réussit à convertir les objets, il exécute

l'opération appropriée au type .NET Framework du premier objet.

S'il ne peut convertir aucun des objets, l'opération échoue.

L'exemple suivant illustre l'utilisation des opérateurs

d'addition et de multiplication dans des opérations incluant

différents types d'objets :

C:\PS> "fichier" + 16

fichier16

C:\PS> $array = 1,2,3

C:\PS> $array + 16

16

C:\PS> $array + "fichier"

fichier
 C:\PS> "fichier" * 3

fichierfichierfichier

Étant donné que la méthode utilisée pour évaluer les instructions est

déterminée par l'objet situé le plus à gauche, l'addition et la

multiplication ne sont pas strictement commutatives dans Windows

PowerShell. Par exemple, l'opération (a + b) n'est pas toujours

égale à (b + a) et l'opération (a * b) n'est pas toujours égale à (b * a).

Les exemples suivants illustrent ce principe :

C:\PS> "fichier" + 2

fichier2

C:\PS> 2 + "fichier"

Impossible de convertir la valeur " fichier " en type

" System.Int32 ". Erreur : " Le format de la chaîne d'entrée est

incorrect. "

À la ligne : 1 Caractère : 4

+ 2 + <<<< "fichier"

C:\PS> "fichier" * 3

fichierfichierfichier

C:\PS> 3 * "fichier"

Impossible de convertir la valeur " fichier " en type

" System.Int32 ". Erreur : " Le format de la chaîne d'entrée est

incorrect. "

À la ligne : 1 Caractère : 4

+ 3 * <<<< "fichier"
Les tables de hachage représentent un cas légèrement différent.

Vous pouvez ajouter des tables de hachage. En outre, une table

de hachage peut être ajoutée à un tableau. Toutefois, il est

impossible d'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

Vous ne pouvez ajouter une autre table de hachage qu'à une

table de hachage.

À la ligne : 1 Caractère : 9

+ $hash1 + <<<< 2
 C:\PS> 2 + $hash1

Impossible de convertir " System.Collections.Hashtable " en

" System.Int32 ".

À la ligne : 1 Caractère : 4

+ 2 + <<<< $hash1

Les exemples ci-dessous montrent que vous pouvez ajouter une

table de hachage à un tableau. La table de hachage entière est

ajoutée au tableau comme un objet unique.

C:\PS> $array = 1,2,3

C:\PS> $array + $hash1

Name Value

---- -----

a 1

b 2

c 3

C:\PS> $sum = $array + $hash1

C:\PS> $sum.count

C:\PS> $sum[3]

Name Value
 ---- -----

a 1

b 2

c 3

PS C:\ps-test> $sum + $hash2

Name Value

---- -----

a 1

b 2

c 3

c2 Server02

L'exemple suivant montre que vous ne pouvez pas ajouter les unes

aux autres des tables de hachage contenant la même clé :

C:\PS> $hash1 = @{a=1; b=2; c=3}

C:\PS> $hash2 = @{c="rouge"}

C:\PS> $hash1 + $hash2

Argument incorrect pour l'opérateur " + " : L'élément a déjà

été ajouté. Clé du dictionnaire : " c " Clé ajoutée : " c ".

À la ligne : 1 Caractère : 9

+ $hash1 + <<<< $hash2

Bien que les opérateurs d'addition soient très utiles, faites

appel aux opérateurs d'affectation pour ajouter des éléments aux

tables de hachage et aux tableaux. Pour plus d'informations, consultez

about_assignment_operators. Les exemples suivants utilisent l'opérateur

d'affectation += pour ajouter des éléments à un tableau :

C:\PS> $array

C:\PS> $array + "fichier"

fichier

C:\PS> $array

C:\PS> $array += "fichier"

C:\PS> $array

fichier

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

.NET Framework qui exprime le 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 étendu en fonction du 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, le type de la

valeur négative ne peut pas être converti (transtypage) 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 ou l'autre des

opérandes est de type Decimal, le résultat correspondra au type

Decimal. Si le résultat est trop grand pour le type Decimal, son

type ne sera pas converti (transtypage) vers le type Double. Au

lieu de cela, une erreur est générée.

C:\PS> [Decimal]::maxvalue

79228162514264337593543950335

C:\PS> [Decimal]::maxvalue + 1

La valeur était trop grande ou trop petite pour un Decimal.

À la ligne : 1 Caractère : 22

+ [Decimal]::maxvalue + <<<< 1
OPÉRATEURS ARITHMÉTIQUES ET VARIABLES

Vous pouvez également utiliser les opérateurs arithmétiques avec

des variables. Les opérateurs agissent sur les valeurs des

variables. Les exemples suivants illustrent l'utilisation des

opérateurs arithmétiques avec les 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 PowerShell 2

OPÉRATEURS ARITHMÉTIQUES ET COMMANDES

Les opérateurs arithmétiques sont généralement utilisés dans des

expressions avec des nombres, des chaînes et des tableaux.

Toutefois, vous pouvez également les employer 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 les commandes Windows

PowerShell :
 C:\PS> get-date

Mercredi 02 janvier 2008 13:28:42

C:\PS> $day = new-timespan -day 1

C:\PS> get-date + $day

Jeudi 03 janvier 2008 13: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

EXEMPLES

Les exemples suivants montrent comment utiliser les opérateurs

arithmétiques dans Windows PowerShell :

C:\PS> 1 + 1

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

C:\PS> w * 3

www

C:\PS> 3 * "w"

Impossible de convertir la valeur " w " en type " System.Int32 ".

Erreur : " Le format de la chaîne d'entrée est incorrect. "

À la ligne : 1 Caractère : 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 = "FichiersTest.txt"

C:\PS> $b = "C:\Logs\"

C:\PS> $b + $a

C:\Logs\FichiersTest.txt

C:\PS> $a = 1,2,3

C:\PS> $a + 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"} #Utiliser l'opérateur d'affectation

C:\PS> $servers

Name Value
 ---- -----

3 Server03

2 Server02

1 Server01

0 LocalHost

VOIR AUSSI

about_Arrays

about_Assignment_Operators

about_Comparison_Operators

about_Hash_Tables

about_Operators

about_Variables

Get-Date