about_Assignment_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_assignment_operators
DESCRIPTION COURTE
Décrit comment utiliser des opérateurs pour affecter des valeurs aux variables.
DESCRIPTION DÉTAILLÉE
Les opérateurs d’affectation affectent une ou plusieurs valeurs à une variable. Ils peuvent effectuer des opérations numériques sur les valeurs avant l’affectation.
Windows PowerShell® prend en charge les opérateurs d’affectation suivants.
Operator Description
------- -----------
= Sets the value of a variable to the specified value.
+= Increases the value of a variable by the specified value, or
appends the specified value to the existing value.
-= Decreases the value of a variable by the specified value.
*= Multiplies the value of a variable by the specified value, or
appends the specified value to the existing value.
/= Divides the value of a variable by the specified value.
%= Divides the value of a variable by the specified value and
then assigns the remainder (modulus) to the variable.
++ Increases the value of a variable, assignable property, or
array element by 1.
-- Decreases the value of a variable, assignable property, or
array element by 1.
SYNTAXE
La syntaxe des opérateurs d’affectation est la suivante :
<assignable-expression> <assignment-operator> <value>
Les expressions qui peuvent être affectées incluent des variables et des propriétés. La valeur peut être une valeur unique, un tableau de valeurs, ou bien une commande, une expression ou une instruction.
Les opérateurs d’incrémentation et de décrémentation sont des opérateurs unaires. Chacun a une version préfixe et une version suffixe.
<assignable-expression><operator>
<operator><assignable-expression>
L’expression qui peut être affectée doit être un nombre ou doit être convertible en un 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 vous pouvez ajouter une nouvelle valeur à la valeur existante.
L’opérateur d’affectation de base est le signe égal (=) (code ASCII 61). Par exemple, l’instruction suivante affecte la valeur Windows PowerShell à la variable $MyShell :
$MyShell = "Windows PowerShell"
Quand vous affectez une valeur à une variable dans Windows PowerShell, la variable est créée si elle n’existait pas déjà. Par exemple, la première des deux instructions d’affectation suivantes crée la variable $a et lui affecte la valeur 6. La deuxième instruction d’affectation affecte la valeur 12 à $a. La première instruction crée une variable. La deuxième instruction modifie seulement sa valeur :
$a = 6
$a = 12
Les variables dans Windows PowerShell n’ont pas un type de données spécifique, sauf si vous effectuez une conversion de leur type (transtypage). Quand une variable contient un seul objet, la variable prend le type de données de cet objet. Quand une variable est constituée d’une collection d’objets, la variable a le type de données System.Object. Vous pouvez donc affecter n’importe quel type d’objet à la collection. L’exemple suivant montre que vous pouvez ajouter des objets de processus, des objets de service, des chaînes et des entiers à une variable sans générer d’erreur :
$a = get-process
$a += get-service
$a += "string"
$a += 12
Comme l’opérateur d’affectation (=) a une priorité inférieure à celle de l’opérateur pipeline (|), les parenthèses ne sont pas nécessaires pour affecter le résultat d’un pipeline de commandes à une variable. Par exemple, la commande suivante trie les services 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 }
Cet exemple affecte 0 à la variable $a si la valeur de $b est inférieur à 0. Il affecte la valeur de $b à $a if la valeur de $b n’est pas inférieure à zéro.
L’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 la valeur 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 la valeur de chaîne entre des guillemets, comme suit :
$a = "baseball"
Pour affecter un tableau (plusieurs valeurs) à une variable, séparez les valeurs par des virgules, comme suit :
$a = "apple", "orange", "lemon", "grape"
Pour affecter une table de hachage à une variable, utilisez la notation de table de hachage standard de Windows PowerShell. Tapez un signe arobase (@) suivi de paires clé/valeur séparées par des points-virgules (;) et placées entre des accolades ({}). Par exemple, pour affecter une table de hachage à la variable $a, tapez :
$a = @{one=1; two=2; three=3}
Pour affecter des valeurs hexadécimales à une variable, faites précéder la valeur de « 0x ». Windows PowerShell convertit la valeur hexadécimale (0x10) en une valeur décimale (dans ce cas 16) et affecte la valeur à la variable $a. Par exemple, pour affecter une valeur de 0x10 à la variable $a, tapez :
$a = 0x10
Pour affecter une valeur exponentielle à une variable, tapez le nombre de la racine, la lettre « e » et un nombre représentant 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 peut également convertir des kilo-octets (Ko), des mégaoctets (Mo) et des gigaoctets (Go) en octets. Par exemple, pour affecter une valeur de 10 kilo-octets à la variable $a, tapez :
$a = 10kb
L’AFFECTATION PAR L’OPÉRATEUR D’ADDITION (+=)
L’affectation par l’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 a un type numérique ou un type chaîne, et selon qu’elle contient une valeur unique (un scalaire) ou plusieurs valeurs (une collection).
L’opérateur += combine deux opérations. Il additionne d’abord, puis il affecte. Par conséquent, les instructions suivantes sont équivalentes :
$a += 2
$a = ($a + 2)
Quand la variable contient une seule valeur numérique, l’opérateur += incrémente la valeur existante de la quantité spécifiée du côté droit de l’opérateur. Ensuite, l’opérateur affecte 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
Quand la valeur de la variable est une chaîne, la valeur située à 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
Quand la valeur de la variable est un tableau, l’opérateur += ajoute les valeurs situées du côté droit de l’opérateur au tableau. Sauf si le tableau est explicitement typé par transtypage, vous pouvez ajouter n’importe quel 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 += "String"
C:\PS> $a
1
2
3
2
String
Quand la valeur d’une variable est une table de hachage, l’opérateur += ajoute la valeur située à droite de l’opérateur à la table de hachage. Cependant, comme le seul type que vous pouvez ajouter à une table de hachage est une autre table de hachage, toutes les autres affectations échouent.
Par exemple, la commande suivante affecte une table de hachage à la variable $a. Ensuite, elle utilise l’opérateur += pour ajouter une autre table de hachage à la table de hachage existante, en ajoutant une nouvelle paire clé/valeur à la table de hachage existante. Cette commande réussit, comme le montre 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 suivante 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
You can add another hash table only to a hash table.
At line:1 char:6
+ $a += <<<< 1
AFFECTATION PAR L’OPÉRATEUR DE SOUSTRACTION (-=)
L’affectation par l’opérateur de soustraction (-=) décrémente la valeur d’une variable de la valeur qui est spécifiée sur le côté droit de l’opérateur. Cet opérateur ne peut pas être utilisé avec des variables de chaîne, et il ne peut pas être utilisé pour 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 du tableau que vous voulez modifier. Dans l’exemple suivant, la valeur du troisième élément d’un tableau (élément 2) est diminuée de 1 :
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 qui sont affectées à une variable, utilisez les applets de commande Clear-Item ou Clear-Variable pour affecter une valeur $null ou "" à la variable.
$a = $null
Pour supprimer une valeur particulière dans un tableau, utilisez la notation de tableau pour affecter une valeur $null à l’élément particulier. 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 quand la variable est explicitement convertie en un type de données particulier et que vous voulez une variable non typée. La commande suivante supprime la variable $a :
remove-variable a
L’AFFECTATION PAR L’OPÉRATEUR DE MULTIPLICATION (*=)
L’affectation par l’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.
Quand une variable contient une seule valeur numérique, cette valeur est multipliée par la valeur située à droite de l’opérateur. Par exemple, 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)
Quand une variable contient une valeur de chaîne, Windows PowerShell ajoute à la valeur le nombre spécifié de chaînes, comme suit :
C:\PS> $a = "file"
C:\PS> $a *= 4
C:\PS> $a
filefilefilefile
Pour multiplier un élément d’un tableau, utilisez un index pour identifier l’élément que vous voulez multiplier. Par exemple, la commande suivante multiplie le premier élément du tableau (position d’index 0) par 2 :
$a[0] *= 2
L’AFFECTATION PAR L’OPÉRATEUR DE DIVISION (/=)
L’affectation par l’opérateur de division (/ =) divise une valeur numérique par la valeur qui est spécifiée du côté droit de l’opérateur. L’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 pour identifier l’élément que vous voulez changer. Par exemple, la commande suivante divise le deuxième élément du tableau (position d’index 1) par 2 :
$a[1] /= 2
L’AFFECTATION PAR L’OPÉRATEUR DE MODULO (%=)
L’affectation par l’opérateur de modulo (%=) divise la valeur d’une variable par la valeur située du côté droit de l’opérateur. Ensuite, l’opérateur %= affecte le reste (appelé le modulo) à la variable. Vous pouvez utiliser cet opérateur seulement quand la variable contient une seule valeur numérique. Vous ne pouvez pas utiliser cet opérateur quand une variable contient une variable de chaîne ou un tableau.
L’opérateur %= combine deux opérations. D’abord, il divise et détermine le reste, puis il affecte le reste à 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
LES OPÉRATEURS D’INCRÉMENTATION ET DE DÉCRÉMENTATION
L’opérateur d’incrémentation (++) augmente de 1 la valeur d’une variable. Quand vous utilisez l’opérateur d’incrémentation dans une instruction simple, aucune valeur n’est retournée. Pour voir 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 retour d’une valeur, placez la variable et l’opérateur entre des 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éfixe de l’opérateur incrémente une variable avant que sa valeur 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 suffixe de l’opérateur incrémente une variable une fois 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 $a change :
C:\PS> $a = 7
C:\PS> $c = $a++
C:\PS> $a
8
C:\PS> $c
7
L’opérateur de décrémentation (--) diminue de 1 la valeur d’une variable. Comme avec l’opérateur d’incrément, aucune valeur n’est retournée quand vous utilisez l’opérateur dans une instruction simple. Utilisez des 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éfixe de l’opérateur décrémente une variable avant que sa valeur 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 suffixe de l’opérateur décrémente une variable une fois 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 $a change :
C:\PS> $a = 7
C:\PS> $d = $a--
C:\PS> $a
6
C:\PS> $d
7
TYPES DE MICROSOFT .NET FRAMEWORK
Par défaut, quand une variable n’a qu’une seule valeur, la valeur qui est affectée à la variable détermine le type de données de la variable. Par exemple, la commande suivante crée une variable qui a le 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 suit. Veillez à inclure les parenthèses après le nom de la méthode GetType, même si l’appel de la méthode n’a pas d’arguments :
C:\PS> $a = 6
C:\PS> $a.gettype().fullname
System.Int32
Pour créer une variable qui contient une chaîne, affectez une valeur de chaîne à la variable. Pour indiquer que la valeur est une chaîne, placez-la entre des 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 de chaîne et convertit les nouvelles valeurs en chaînes. Ceci se produit dans l’exemple suivant :
C:\PS> $a = "file"
C:\PS> $a += 3
C:\PS> $a
file3
Si la première valeur est un entier, Windows PowerShell traite toutes les opérations comme des opérations d’entiers et convertit les nouvelles valeurs en entiers. Ceci se produit dans l’exemple suivant :
C:\PS> $a = 6
C:\PS> $a += "3"
C:\PS> $a
9
Vous pouvez convertir le type d’une nouvelle variable scalaire en n’importe quel type .NET Framework en plaçant le nom du type entre des crochets devant le nom de la variable ou devant la première la valeur de la première affectation. Quand vous convertissez le type d’une variable, vous pouvez déterminer les types des données qui peuvent être stockées dans la variable. Vous pouvez aussi déterminer comment la variable se comporte quand vous la manipulez.
Par exemple, la commande suivante convertit le type de la variable en un type chaîne :
C:\PS> [string]$a = 27
C:\PS> $a += 3
C:\PS> $a
273
L’exemple suivant convertit le type de la première valeur, au lieu de convertir le type de la variable :
$a = [string]27
Quand vous convertissez le type d’une variable en un type spécifique, la convention courante est de convertir le type de la variable, et non pas de la valeur. Cependant, vous ne pouvez pas convertir à nouveau le type de données d’une variable existante si sa valeur ne peut pas être convertie dans le nouveau type de données. Pour changer le type de données, vous devez remplacer sa valeur, comme suit :
C:\PS> $a = "string"
C:\PS> [int]$a
Cannot convert value "string" to type "System.Int32". Error: "Input
string was not in a correct format."
At line:1 char:8
+ [int]$a <<<<
C:\PS> [int]$a =3
En outre, quand vous faites précéder un nom de variable par un type de données, le type de cette variable est verrouillé, sauf si vous remplacez explicitement le type en spécifiant un autre type de données. Si vous tentez d’affecter une valeur qui n’est pas compatible avec le type existant et que vous ne remplacez pas explicitement le type, Windows PowerShell affiche une erreur, comme le montre l’exemple suivant :
C:\PS> $a = 3
C:\PS> $a = "string"
C:\PS> [int]$a = 3
C:\PS> $a = "string"
Cannot convert value "string" to type "System.Int32". Error: "Input
string was not in a correct format."
At line:1 char:3
+ $a <<<< = "string"
C:\PS> [string]$a = "string"
Dans Windows PowerShell, les types de données des variables qui contiennent plusieurs éléments dans un tableau sont gérés différemment des types de données des variables qui contiennent un seul élément. Sauf si un type de données est spécifiquement affecté à une variable tableau, le type de données est toujours System.Object []. Ce type de données est spécifique aux tableaux.
Parfois, vous pouvez remplacer le type par défaut en spécifiant un autre type. Par exemple, la commande suivante convertit le type de la variable en un type tableau [] de chaînes :
[string []] $a = "one", "two", "three"
Les variables Windows PowerShell peuvent être de n’importe quel type de données .NET Framework. En outre, vous pouvez affecter n’importe quel 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 = "5/31/2005"
Une valeur conforme au type de données System.DateTime sera affectée à la variable. La valeur de la variable $a peut être la suivante :
Tuesday, May 31, 2005 12:00:00 AM
AFFECTATION DE PLUSIEURS VARIABLES
Dans Windows PowerShell, vous pouvez affecter des valeurs à plusieurs variables à l’aide d’une seule commande. Le premier élément de la valeur de l’affectation est affecté à la première variable, le deuxième élément est affecté à la deuxième variable, le troisième élément à la troisième variable, etc. 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 de l’affectation contient plus d’éléments que le nombre 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
Windows PowerShell affecte donc 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 pouvez également affecter une seule valeur à plusieurs variables en chaînant les variables. Par exemple, la commande suivante affecte la valeur « trois » aux quatre variables :
$a = $b = $c = $d = "three"
APPLETS DE COMMANDE RELATIVES AUX VARIABLES
En plus d’utiliser une opération d’affectation pour définir la valeur d’une variable, vous pouvez également utiliser l’applet de commande Set-Variable. Par exemple, la commande suivante utilise Set-Variable pour affecter un tableau contenant 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