RUBRIQUE
about_assignment_operators
DESCRIPTION COURTE
Décrit comment utiliser des opérateurs pour affecter des valeurs aux
variables.
DESCRIPTION LONGUE
Les opérateurs d'affectation affectent une ou plusieurs valeurs à une
variable. Ils peuvent exécuter des opérations numériques sur les
valeurs avant l'affectation.
Windows PowerShell prend en charge les opérateurs d'affectation
suivants.
Opérateur Description
------- -----------
= Affecte à une variable la valeur spécifiée.
+= Augmente la valeur d'une variable de la valeur spécifiée
ou ajoute la valeur spécifiée à la valeur existante.
-= Diminue la valeur d'une variable de la valeur spécifiée.
*= Multiplie la valeur d'une variable par la valeur spécifiée
ou ajoute la valeur spécifiée à la valeur existante.
/= Divise la valeur d'une variable par la valeur spécifiée.
%= Divise la valeur d'une variable par la valeur spécifiée,
puis affecte le reste (modulo) à la variable.
++ Augmente d'une unité la valeur d'une variable, d'une
propriété affectable ou d'un élément de tableau.
-- Diminue d'une unité la valeur d'une variable, d'une
propriété affectable ou d'un élément de tableau.
SYNTAXE
La syntaxe des opérateurs d'affectation se présente comme suit :
<expression affectable> <opérateur d'affectation> <valeur>
Les expressions affectables incluent des variables et des propriétés.
La valeur peut correspondre à une valeur unique, un tableau de valeurs,
ou bien encore une commande, une expression ou une instruction.
Les opérateurs d'incrémentation et de décrémentation sont des
opérateurs unaires. Il existe des versions préfixée et suffixée
pour chacun de ces opérateurs.
<expression affectable><opérateur>
<opérateur><expression affectable>
L'expression affectable doit correspondre à un nombre ou être
convertible en nombre.
AFFECTATION DE VALEURS
Les variables sont des espaces mémoire nommés qui stockent des
valeurs. Vous stockez les valeurs dans des variables à l'aide de
l'opérateur d'affectation (=). La nouvelle valeur peut remplacer
la valeur existante de la variable ou une nouvelle valeur peut
être ajoutée à la valeur existante.
L'opérateur d'affectation de base est le signe égal (=) (ASCII 61).
Par exemple, l'instruction suivante affecte la valeur Windows
PowerShell à la variable $MyShell :
$MyShell = "Windows PowerShell"
Lorsque vous affectez une valeur à une variable dans Windows
PowerShell, la variable est créée si elle n'existe pas déjà.
Par exemple, la première des deux instructions d'affectation
ci-dessous crée la variable $a et affecte la valeur 6 à $a. La
deuxième instruction d'affectation affecte la valeur 12 à $a. La
première instruction crée une variable. La deuxième instruction
modifie uniquement sa valeur :
$a = 6
$a = 12
Dans Windows PowerShell, les variables ne sont pas associées à un
type de données spécifique à moins que vous ne procédiez à leur
transtypage. Lorsqu'une variable ne contient qu'un seul objet,
elle prend le type de données de cet objet. Lorsqu'une variable
contient une collection d'objets, elle est associée au type de données
System.Object. Par conséquent, vous pouvez affecter tout type d'objet
à la collection. L'exemple suivant montre que vous pouvez ajouter des
objets processus, des objets services, des chaînes et des entiers à une
variable sans générer d'erreur :
$a = get-process
$a += get-service
$a += "chaîne"
$a += 12
Étant donné que l'opérateur d'affectation (=) a une précédence
inférieure à celle de l'opérateur de pipeline (|), les
parenthèses ne sont pas obligatoires pour affecter le résultat
d'un pipeline de commande à une variable. Par exemple, la
commande suivante trie les services présents sur l'ordinateur,
puis affecte les services triés à la variable $a :
$a = get-service | sort name
Vous pouvez également affecter la valeur créée par une
instruction à une variable, comme dans l'exemple suivant :
$a = if ($b -lt 0) { 0 } else { $b }
Dans cet exemple, la valeur 0 est affectée à la variable $a si la
valeur de $b est inférieure à 0. Si la valeur de $b n'est pas
inférieure à zéro, elle est affectée à $a.
OPÉRATEUR D'AFFECTATION (=)
L'opérateur d'affectation (=) affecte des valeurs aux variables. Si la
variable a déjà une valeur, l'opérateur d'affectation (=) remplace cette
dernière sans avertissement.
L'instruction suivante affecte la valeur entière 6 à la variable $a :
$a = 6
Pour affecter une valeur de chaîne à une variable, placez cette
valeur entre guillemets, comme suit :
$a = "baseball"
Pour affecter un tableau (plusieurs valeurs) à une variable,
séparez les valeurs par des virgules, comme suit :
$a = "pomme", "orange", "citron", "raisin"
Pour affecter une table de hachage à une variable, utilisez la
notation de table de hachage standard dans Windows PowerShell.
Tapez une arobase (@) suivie de paires clé/valeur séparées par
des points-virgules (;) et placées entre accolades ({ }). Par
exemple, pour affecter une table de hachage à la variable $a, tapez :
$a = @{un=1; deux=2; trois=3}
Pour affecter une valeur hexadécimale à une variable, faites
précéder la valeur du préfixe " 0x ". Windows PowerShell
convertit la valeur hexadécimale (0x10) en valeur décimale (dans
ce cas, 16) et affecte cette dernière à la variable $a. Par
exemple, pour affecter la valeur 0x10 à la variable $a, tapez :
$a = 0x10
Pour affecter une valeur exponentielle à une variable, tapez le numéro
racine, la lettre " e " et un nombre qui représente un multiple de 10. Par
exemple, pour affecter la valeur 3,1415 à la puissance 1 000 à la
variable $a, tapez :
$a = 3,1415e3
Windows PowerShell permet également de convertir des kilo-octets
(Ko), des mégaoctets (Mo) et des gigaoctets (Go) en octets. Par
exemple, pour affecter la valeur 10 kilo-octets à la variable $a,
tapez :
$a = 10kb
AFFECTATION PAR OPÉRATEUR D'ADDITION (+=)
L'affectation par opérateur d'addition (+=) incrémente la valeur d'une
variable ou ajoute la valeur spécifiée à la valeur existante. L'action
varie selon que la variable est de type numérique ou chaîne, et qu'elle
contient une valeur unique (scalaire) ou plusieurs valeurs (collection).
L'opérateur += combine deux opérations. Il ajoute d'abord, puis
il affecte. Par conséquent, les instructions suivantes sont
équivalentes :
$a += 2
$a = ($a + 2)
Lorsque la variable contient une valeur numérique unique,
l'opérateur += incrémente la valeur existante de la valeur
figurant à droite de l'opérateur. L'opérateur affecte ensuite
la valeur résultante à la variable. L'exemple suivant montre comment
utiliser l'opérateur += pour augmenter la valeur d'une variable :
C:\PS> $a = 4
C:\PS> $a += 2
C:\PS> $a
6
Lorsque la valeur de la variable est une chaîne, la valeur figurant
à droite de l'opérateur est ajoutée à la chaîne, comme suit :
C:\PS> $a = "Windows"
C:\PS> $a +- " PowerShell"
C:\PS> $a
Windows PowerShell
Lorsque la valeur de la variable est un tableau, l'opérateur +=
ajoute les valeurs figurant à droite de l'opérateur au tableau.
À moins que le tableau ne soit explicitement typé par transtypage,
vous pouvez ajouter tout type de valeur au tableau, comme suit :
C:\PS> $a = 1,2,3
C:\PS> $a += 2
C:\PS> $a
1
2
3
2
C:\PS> $a += "Chaîne"
C:\PS> $a
1
2
3
2
String
Lorsque la valeur d'une variable correspond à une table de hachage,
l'opérateur += ajoute la valeur figurant à droite de l'opérateur
à la table de hachage. Toutefois, étant donné que le seul type
pouvant être ajouté à une table de hachage est une autre table
de hachage, toute autre affectation échoue.
Par exemple, la commande ci-dessous affecte une table de hachage à la
variable $a.
Elle utilise ensuite l'opérateur += pour ajouter une autre table
de hachage à la table de hachage existante ; de cette façon, une
nouvelle paire clé/valeur est ajoutée à la table de hachage
existante. Cette commande réussit, comme indiqué dans la sortie :
C:\PS> $a = @{a = 1; b = 2; c = 3}
C:\PS> $a += @{mode = "write"}
C:\PS> $a
Name Value
---- -----
a 1
b 2
mode write
c 3
La commande ci-dessous tente d'ajouter un entier (1) à la table
de hachage dans la variable $a. Cette commande échoue :
C:\PS> $a = @{a = 1; b = 2; c = 3}
C:\PS> $a += 1
Vous ne pouvez ajouter une autre table de hachage qu'à une
table de hachage.
À la ligne : 1 Caractère : 6
+ $a += <<<< 1
AFFECTATION PAR OPÉRATEUR DE SOUSTRACTION (-=)
L'affectation par opérateur de soustraction (-=) décrémente la
valeur d'une variable de la valeur spécifiée à droite de l'opérateur.
Cet opérateur ne peut pas être utilisé avec des variables de chaîne ni
servir à supprimer un élément d'une collection.
L'opérateur -= combine deux opérations. Il soustrait d'abord, puis il
affecte. Par conséquent, les instructions suivantes sont équivalentes :
$a -= 2
$a = ($a - 2)
L'exemple suivant montre comment utiliser l'opérateur -= pour
diminuer la valeur d'une variable :
C:\PS> $a = 8
C:\PS> $a -= 2
C:\PS> $a
6
Vous pouvez également utiliser l'opérateur d'affectation -= pour
diminuer la valeur d'un membre d'un tableau numérique. Pour ce faire,
spécifiez l'index de l'élément de tableau à modifier. Dans l'exemple
suivant, la valeur du troisième élément d'un tableau (élément 2) est
diminuée d'une unité :
C:\PS> $a = 1,2,3
C:\PS> $a[2] -= 1.
C:\PS> $a
1
2
2
Vous ne pouvez pas utiliser l'opérateur -= pour supprimer les
valeurs d'une variable. Pour supprimer toutes les valeurs
affectées à une variable, utilisez les applets de commande
Clear-Item ou Clear-Variable de façon à affecter la valeur $null
ou "" à la variable.
$a = $null
Pour supprimer une valeur particulière d'un tableau, utilisez
la notation sous forme de tableau de façon à affecter la valeur
$null à cet élément spécifique. Par exemple, l'instruction
suivante supprime la deuxième valeur (position d'index 1) d'un
tableau :
C:\PS> $a = 1,2,3
C:\PS> $a
1
2
3
C:\PS> $a[1] = $null
C:\PS> $a
1
3
Pour supprimer une variable, utilisez l'applet de commande
Remove-Variable. Cette méthode est utile lorsque le type de la
variable est explicitement converti (transtypage) en un type de
données particulier et que vous souhaitez obtenir une variable
non typée. La commande suivante supprime la variable $a :
remove-variable a
AFFECTATION PAR OPÉRATEUR DE MULTIPLICATION (*=)
L'affectation par opérateur de multiplication (*=) multiplie
une valeur numérique ou ajoute le nombre spécifié de copies
de la valeur de chaîne d'une variable.
Lorsqu'une variable contient une valeur numérique unique, cette
dernière est multipliée par la valeur figurant à droite de
l'opérateur. L'exemple suivant montre comment utiliser
l'opérateur *= pour multiplier la valeur d'une variable :
C:\PS> $a = 3
C:\PS> $a *= 4
C:\PS> $a
12
Dans ce cas, l'opérateur *= combine deux opérations. Il multiplie
d'abord, puis il affecte. Par conséquent, les instructions
suivantes sont équivalentes :
$a *= 2
$a = ($a * 2)
Lorsqu'une variable contient une valeur de chaîne, Windows
PowerShell ajoute le nombre spécifié de chaînes à la valeur,
comme suit :
C:\PS> $a = "fichier"
C:\PS> $a *= 4
C:\PS> $a
fichierfichierfichierfichier
Pour multiplier un élément d'un tableau, utilisez un index de façon à
identifier l'élément à multiplier. Par exemple, la commande suivante
multiplie le premier élément du tableau (position d'index 0) par 2 :
$a[0] *= 2
AFFECTATION PAR OPÉRATEUR DE DIVISION (/=)
L'affectation par opérateur de division (/=) divise une valeur
numérique par la valeur spécifiée à droite de l'opérateur. Cet
opérateur ne peut pas être utilisé avec des variables de chaîne.
L'opérateur /= combine deux opérations. Il divise d'abord, puis
il affecte. Par conséquent, les deux instructions suivantes sont
équivalentes :
$a /= 2
$a = ($a / 2)
Par exemple, la commande suivante utilise l'opérateur /= pour
diviser la valeur d'une variable :
C:\PS> $a = 8
C:\PS> $a /=2
C:\PS> $a
4
Pour diviser un élément d'un tableau, utilisez un index afin
d'identifier l'élément à modifier. Par exemple, la commande
suivante divise le deuxième élément du tableau (position
d'index 1) par 2 :
$a[1] /= 2
AFFECTATION PAR OPÉRATEUR MODULO (%=)
L'affectation par opérateur modulo (%=) divise la valeur d'une
variable par la valeur figurant à droite de l'opérateur.
L'opérateur %= affecte ensuite le reste (appelé " modulo ")
à la variable. Vous pouvez utiliser cet opérateur uniquement
lorsqu'une variable contient une valeur numérique unique. Vous ne
pouvez pas utiliser cet opérateur lorsqu'une variable contient
une variable de chaîne ou un tableau.
L'opérateur %= combine deux opérations. Il divise d'abord, puis
il détermine le reste, qu'il affecte ensuite à la variable. Par
conséquent, les instructions suivantes sont équivalentes :
$a %= 2
$a = ($a % 2)
L'exemple suivant montre comment utiliser l'opérateur %= pour
enregistrer le modulo d'un quotient :
C:\PS> $a = 7
C:\PS> $a %= 4
C:\PS> $a
3
OPÉRATEURS D'INCRÉMENTATION ET DE DÉCRÉMENTATION
L'opérateur d'incrémentation (++) augmente la valeur d'une
variable d'une unité. Lorsque vous l'utilisez dans une
instruction simple, aucune valeur n'est retournée.
Pour consulter le résultat, affichez la valeur de la variable,
comme suit :
C:\PS> $a = 7
C:\PS> ++$a
C:\PS> $a
8
Pour forcer le renvoi d'une valeur, placez la variable et
l'opérateur entre parenthèses, comme suit :
C:\PS> $a = 7
C:\PS> (++$a)
8
L'opérateur d'incrémentation peut être placé avant (préfixe) ou après
(suffixe) une variable. La version préfixée de l'opérateur incrémente une
variable avant que sa valeur ne soit utilisée dans l'instruction,
comme suit :
C:\PS> $a = 7
C:\PS> $c = ++$a
C:\PS> $a
8
C:\PS> $c
8
La version suffixée de l'opérateur incrémente une variable après
que sa valeur a été utilisée dans l'instruction. Dans l'exemple
suivant, les variables $c et $a ont des valeurs différentes, car
la valeur est affectée à $c avant que la variable $a ne soit
modifiée :
C:\PS> $a = 7
C:\PS> $c = $a++
C:\PS> $a
8
C:\PS> $c
7
L'opérateur de décrémentation (--) diminue la valeur d'une
variable d'une unité. Comme avec l'opérateur d'incrémentation,
aucune valeur n'est retournée lorsque vous utilisez l'opérateur
dans une instruction simple. Utilisez les parenthèses pour
retourner une valeur, comme suit :
C:\PS> $a = 7
C:\PS> --$a
C:\PS> $a
6
C:\PS> (--$a)
5
La version préfixée de l'opérateur décrémente une variable avant
que sa valeur ne soit utilisée dans l'instruction, comme suit :
C:\PS> $a = 7
C:\PS> $c = --$a
C:\PS> $a
6
C:\PS> $c
6
La version suffixée de l'opérateur décrémente une variable après
que sa valeur a été utilisée dans l'instruction. Dans l'exemple
suivant, les variables $d et $a ont des valeurs différentes, car
la valeur est affectée à $d avant que la variable $a ne soit
modifiée :
C:\PS> $a = 7
C:\PS> $d = $a--
C:\PS> $a
6
C:\PS> $d
7
TYPES MICROSOFT .NET FRAMEWORK
Par défaut, lorsqu'une variable ne comporte qu'une seule valeur,
la valeur qui lui est affectée détermine son type de données. Par
exemple, la commande suivante crée une variable de type entier
(System.Int32) :
$a = 6
Pour rechercher le type .NET Framework d'une variable, utilisez
la méthode GetType et sa propriété FullName, comme indiqué ci-dessous.
Veillez à inclure les parenthèses après le nom de la méthode GetType,
bien que l'appel de méthode ne comporte pas d'arguments :
C:\PS> $a = 6
C:\PS> $a.gettype().fullname
System.Int32
Pour créer une variable contenant une chaîne, affectez une valeur
de chaîne à la variable. Pour indiquer que la valeur est une
chaîne, placez-la entre guillemets, comme suit :
C:\PS> $a = "6"
C:\PS> $a.gettype().fullname
System.String
Si la première valeur affectée à la variable est une chaîne, Windows
PowerShell traite toutes les opérations comme des opérations sur des
chaînes et effectue une conversion de type (transtypage) des nouvelles
valeurs en chaînes. Ce cas est illustré par l'exemple suivant :
C:\PS> $a = "fichier"
C:\PS> $a += 3
C:\PS> $a
fichier3
Si la première valeur est un entier, Windows PowerShell traite
toutes les opérations comme des opérations sur des entiers et
effectue une conversion de type (transtypage) des nouvelles valeurs
en entiers. Ce cas est illustré par l'exemple suivant :
C:\PS> $a = 6
C:\PS> $a += "3"
C:\PS> $a
9
Vous pouvez effectuer une conversion de type d'une nouvelle variable
scalaire en n'importe quel type .NET Framework en plaçant le nom du
type entre crochets avant le nom de la variable ou la première valeur
d'affectation. Lorsque vous effectuez une conversion de type d'une
variable, vous avez la possibilité de déterminer les types de données
pouvant être stockés dans celle-ci. En outre, vous pouvez déterminer
le comportement de la variable lorsque vous la manipulez.
Par exemple, la commande suivante procède au transtypage de la
variable en type string :
C:\PS> [string]$a = 27
C:\PS> $a += 3
C:\PS> $a
273
Dans l'exemple suivant, un transtypage de la première valeur, et
non de la variable, est effectué :
$a = [string]27
Le transtypage d'une variable vers un type spécifique s'effectue
généralement en convertissant le type de la variable, et non celui
de la valeur. Toutefois, vous ne pouvez pas reconvertir le type de
données d'une variable existante si sa valeur ne peut pas être
convertie vers le nouveau type de données. Pour modifier le type de
données, vous devez remplacer sa valeur, comme suit :
C:\PS> $a = "chaîne"
C:\PS> [int]$a
Impossible de convertir la valeur " chaîne " en type
" System.Int32 ". Erreur : " Le format de la chaîne d'entrée est
incorrect. "
À la ligne : 1 Caractère : 8
+ [int]$a <<<<
C:\PS> [int]$a =3
En outre, lorsque vous faites précéder un nom de variable d'un type de
données, le type de cette variable est verrouillé à moins que vous ne
le remplaciez explicitement en spécifiant un autre type de données. Si
vous essayez d'affecter une valeur incompatible avec le type existant
et que vous ne remplacez pas explicitement le type, Windows
PowerShell affiche une erreur, comme indiqué dans l'exemple suivant :
C:\PS> $a = 3
C:\PS> $a = "chaîne"
C:\PS> [int]$a = 3
C:\PS> $a = "chaîne"
Impossible de convertir la valeur " chaîne " en type
" System.Int32 ". Erreur : " Le format de la chaîne d'entrée est
incorrect. "
À la ligne : 1 Caractère : 3
+ $a <<<< = "chaîne"
C:\PS> [string]$a = "chaîne"
Dans Windows PowerShell, les types de données des variables contenant
plusieurs éléments dans un tableau sont traités différemment des types
de données des variables contenant un élément unique. À moins qu'un type
de données ne soit spécifiquement affecté à une variable tableau, le
type de données est toujours System.Object []. Ce type de données est
propre aux tableaux.
Vous pouvez parfois remplacer le type par défaut en spécifiant un
autre type. Par exemple, la commande suivante procède au transtypage
de la variable en type de tableau string [] :
[string []] $a = "un", "deux", "trois"
Les variables Windows PowerShell peuvent comporter n'importe quel
type de données .NET Framework. En outre, vous pouvez affecter tout
type de données .NET Framework complet qui est disponible dans le
processus actuel. Par exemple, la commande suivante spécifie un type
de données System.DateTime :
[system.datetime]$a = "31/05/2005"
La valeur affectée à la variable sera conforme au type de données
System.DateTime. La valeur de la variable $a est la suivante :
Mardi 31 mai 2005 12:00:00
AFFECTATION DE VALEURS À PLUSIEURS VARIABLES
Dans Windows PowerShell, vous pouvez affecter des valeurs à
plusieurs variables en utilisant une seule commande. Le
premier élément de la valeur d'affectation est affecté
à la première variable, le deuxième élément à la deuxième
variable, le troisième élément à la troisième variable,
et ainsi de suite. Par exemple, la commande suivante affecte
la valeur 1 à la variable $a, la valeur 2 à la variable $b
et la valeur 3 à la variable $c :
C:\PS> $a, $b, $c = 1, 2, 3
Si la valeur d'affectation contient plus d'éléments qu'il n'y a
de variables, toutes les valeurs restantes sont affectées à la
dernière variable. Par exemple, la commande suivante contient
trois variables et cinq valeurs :
$a, $b, $c = 1, 2, 3, 4, 5
Par conséquent, Windows PowerShell affecte la valeur 1 à la variable
$a et la valeur 2 à la variable $b. Il affecte les valeurs 3, 4 et
5 à la variable $c. Pour affecter les valeurs de la variable $c
à trois autres variables, utilisez le format suivant :
$d, $e, $f = $c
Cette commande affecte la valeur 3 à la variable $d, la valeur 4 à la
variable $e et la valeur 5 à la variable $f.
Vous avez également la possibilité d'affecter une seule valeur à
plusieurs variables en les chaînant. Par exemple, la commande suivante
affecte la valeur " trois " aux quatre variables :
$a = $b = $c = $d = "trois"
APPLETS DE COMMANDE LIÉES AUX VARIABLES
Outre une opération d'affectation, vous pouvez également utiliser
l'applet de commande Set-Variable pour définir la valeur d'une
variable. Par exemple, la commande suivante utilise Set-Variable pour
affecter un tableau 1, 2, 3 à la variable $a.
Set-Variable -name a -value 1, 2, 3
VOIR AUSSI
about_Arrays
about_Hash_Tables
about_Variables
Clear-Variable
Remove-Variable
Set-Variable