about_Assignment_Operators
Description courte
Décrit comment utiliser des opérateurs pour affecter des valeurs à des variables.
Description longue
Les opérateurs d’affectation attribuent une ou plusieurs valeurs à une variable. Ils peuvent effectuer des opérations numériques sur les valeurs avant l’affectation.
PowerShell prend en charge les opérateurs d’affectation suivants.
| Opérateur | Description |
|---|---|
| = | Définit la valeur d’une variable sur 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 et |
| affecte ensuite le reste (module) à la variable. | |
| ++ | Augmente la valeur d’une variable, d’une propriété assignable ou |
| élément array par 1. | |
| -- | Diminue la valeur d’une variable, d’une propriété assignable ou |
| élément array par 1. |
Syntax
La syntaxe des opérateurs d’affectation est la suivante :
<assignable-expression> <assignment-operator> <value>
Les expressions assignables incluent des variables et des propriétés. La valeur peut être une valeur unique, un tableau de valeurs ou une commande, une expression ou une instruction.
Les opérateurs d’incrémentation et de décrémentation sont des opérateurs unaires. Chaque a des versions de préfixe et de postfix.
<assignable-expression><operator>
<operator><assignable-expression>
L’expression assignable doit être un nombre ou être convertible en nombre.
Affectation de valeurs
Les variables sont des espaces de 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 =(ASCII 61)égal . Par exemple, l’instruction suivante affecte la valeur PowerShell à la $MyShell variable :
$MyShell = "PowerShell"
Lorsque vous affectez une valeur à une variable dans PowerShell, la variable est créée si elle n’existe pas déjà. Par exemple, la première des deux instructions d’affectation suivantes crée la $a variable et affecte une valeur de 6 à $a. La deuxième instruction d’affectation affecte une valeur de 12 à $a. La première instruction crée une variable. La deuxième instruction ne modifie que sa valeur :
$a = 6
$a = 12
Les variables dans PowerShell n’ont pas de type de données spécifique, sauf si vous les castez. Lorsqu’une variable ne contient qu’un seul objet, la variable prend le type de données de cet objet. Lorsqu’une variable contient une collection d’objets, elle a le type de données System.Object. Par conséquent, vous pouvez 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
Étant donné que l’opérateur = d’affectation a une priorité inférieure à l’opérateur |de 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 $a variable :
$a = Get-Service | Sort-Object -Property 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 montre comment affecter zéro à la $a variable si la valeur de $b est inférieure à zéro. Il affecte la valeur de $b à si la valeur de $b n’est pas inférieure à $a zéro.
Opérateur d’affectation
L’opérateur d’assignation = affecte des valeurs à des 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 $a variable :
$a = 6
Pour affecter une valeur de chaîne à une variable, placez la valeur de chaîne entre 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 dans PowerShell. Tapez un signe @ at suivi de paires clé/valeur séparées par des points-virgules ; et entourées { }d’accolades . Par exemple, pour affecter une table de hachage à la $a variable, tapez :
$a = @{one=1; two=2; three=3}
Pour affecter des valeurs hexadécimales à une variable, précèdez la valeur par 0x.
PowerShell convertit la valeur hexadécimale (0x10) en valeur décimale (dans ce cas, 16) et affecte cette valeur à la $a variable. Par exemple, pour affecter une valeur de 0x10 à la $a variable, tapez :
$a = 0x10
Pour affecter une valeur exponentielle à une variable, tapez le nombre racine, la lettre eet un nombre qui représente un multiple de 10. Par exemple, pour affecter une valeur de 3,1415 à la puissance de 1 000 à la $a variable, tapez :
$a = 3.1415e3
PowerShell peut également convertir des kilo-octets KB, des mégaoctets MBet des gigaoctets GB en octets. Par exemple, pour affecter une valeur de 10 kilo-octets à la $a variable, tapez :
$a = 10kb
L’affectation par l’opérateur d’addition
L’opérateur += d’affectation par 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 chaîne et si la variable contient une valeur unique (scalaire) ou plusieurs valeurs (une collection).
L’opérateur += combine deux opérations. Tout d’abord, il ajoute, puis il attribue.
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 quantité située à droite 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 :
$a = 4
$a += 2
$a
6
Lorsque 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 :
$a = "Windows"
$a += " PowerShell"
$a
Windows PowerShell
Lorsque la valeur de la variable est un tableau, l’opérateur += ajoute les valeurs situées à droite de l’opérateur au tableau. Sauf si le tableau est explicitement typé par cast, vous pouvez ajouter n’importe quel type de valeur au tableau, comme suit :
$a = 1,2,3
$a += 2
$a
1
2
3
2
et
$a += "String"
$a
1
2
3
2
String
Lorsque 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. Toutefois, étant donné que 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 $a variable .
Ensuite, il 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 indiqué dans la sortie :
$a = @{a = 1; b = 2; c = 3}
$a += @{mode = "write"}
$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 $a variable. Cette commande échoue :
$a = @{a = 1; b = 2; c = 3}
$a += 1
You can add another hash table only to a hash table.
At line:1 char:6
+ $a += <<<< 1
Affectation par opérateur de soustraction
L’opérateur -= d’assignation par soustraction décrémente la valeur d’une variable 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 et ne peut pas être utilisé pour supprimer un élément d’une collection.
L’opérateur -= combine deux opérations. Tout d’abord, il soustrait, puis il assigne. 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 :
$a = 8
$a -= 2
$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 que vous souhaitez modifier. Dans l’exemple suivant, la valeur du troisième élément d’un tableau (élément 2) est réduite de 1 :
$a = 1,2,3
$a[2] -= 1
$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 pour affecter une valeur de $null ou "" à la variable.
$a = $null
Pour supprimer une valeur particulière d’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 :
$a = 1,2,3
$a
1
2
3
$a[1] = $null
$a
1
3
Pour supprimer une variable, utilisez l’applet de commande Remove-Variable . Cette méthode est utile lorsque la variable est explicitement castée en un type de données particulier et que vous souhaitez une variable non typée. La commande suivante supprime la $a variable :
Remove-Variable -Name a
L’affectation par l’opérateur de multiplication
L’opérateur *= d’affectation par 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 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 :
$a = 3
$a *= 4
$a
12
Dans ce cas, l’opérateur *= combine deux opérations. Tout d’abord, il se multiplie, puis il assigne. Par conséquent, les instructions suivantes sont équivalentes :
$a *= 2
$a = ($a * 2)
Lorsqu’une variable contient une valeur de chaîne, PowerShell ajoute le nombre spécifié de chaînes à la valeur, comme suit :
$a = "file"
$a *= 4
$a
filefilefilefile
Pour multiplier un élément d’un tableau, utilisez un index pour identifier l’élément que vous souhaitez 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’opérateur /= d’affectation par division divise une valeur numérique par la valeur spécifiée sur le 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. Tout d’abord, il divise, puis il assigne. 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 :
$a = 8
$a /=2
$a
4
Pour diviser un élément d’un tableau, utilisez un index pour identifier l’élément que vous souhaitez modifier. 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 module
L’affectation par l’opérateur %= modulus divise la valeur d’une variable par la valeur située à droite de l’opérateur. Ensuite, l’opérateur %= affecte le reste (appelé module) à la variable. Vous pouvez utiliser cet opérateur uniquement lorsqu’une variable contient une seule valeur numérique. 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. Tout 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 module d’un quotient :
$a = 7
$a %= 4
$a
3
Opérateurs d’incrémentation et de décrémentation
L’opérateur ++ incrémente augmente la valeur d’une variable de 1. Lorsque vous utilisez l’opérateur incrément dans une instruction simple, aucune valeur n’est retournée. Pour afficher le résultat, affichez la valeur de la variable, comme suit :
$a = 7
++$a
$a
8
Pour forcer le retour d’une valeur, placez la variable et l’opérateur entre parenthèses, comme suit :
$a = 7
(++$a)
8
L’opérateur incrément peut être placé avant (préfixe) ou après (postfix) une variable. La version de préfixe de l’opérateur incrémente une variable avant que sa valeur ne soit utilisée dans l’instruction, comme suit :
$a = 7
$c = ++$a
$a
8
$c
8
La version postfix 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 $c variables et $a ont des valeurs différentes, car la valeur est affectée à $c avant $a les modifications :
$a = 7
$c = $a++
$a
8
$c
7
L’opérateur -- décrémentation diminue la valeur d’une variable de 1. Comme avec l’opérateur incrément, aucune valeur n’est retournée lorsque vous utilisez l’opérateur dans une instruction simple. Utilisez des parenthèses pour retourner une valeur, comme suit :
$a = 7
--$a
$a
6
(--$a)
5
La version de préfixe de l’opérateur décrémente une variable avant que sa valeur ne soit utilisée dans l’instruction, comme suit :
$a = 7
$c = --$a
$a
6
$c
6
La version postfix de l’opérateur décrémente une variable une fois sa valeur utilisée dans l’instruction. Dans l’exemple suivant, les $d variables et $a ont des valeurs différentes, car la valeur est affectée à $d avant $a les modifications :
$a = 7
$d = $a--
$a
6
$d
7
Types Microsoft .NET
Par défaut, lorsqu’une variable n’a qu’une seule valeur, la valeur affectée à la variable détermine le type de données de la variable. Par exemple, la commande suivante crée une variable de type « Integer » (System.Int32) :
$a = 6
Pour rechercher le type .NET 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 méthode n’a aucun argument :
$a = 6
$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 guillemets, comme suit :
$a = "6"
$a.GetType().FullName
System.String
Si la première valeur affectée à la variable est une chaîne, PowerShell traite toutes les opérations comme des opérations de chaîne et caste les nouvelles valeurs en chaînes. Cela se produit dans l’exemple suivant :
$a = "file"
$a += 3
$a
file3
Si la première valeur est un entier, PowerShell traite toutes les opérations comme des opérations entières et caste les nouvelles valeurs en entiers. Cela se produit dans l’exemple suivant :
$a = 6
$a += "3"
$a
9
Vous pouvez caster une nouvelle variable scalaire en tant que type .NET en plaçant le nom de type entre crochets qui précèdent le nom de la variable ou la première valeur d’affectation. Lorsque vous castez une variable, vous pouvez déterminer les types de données qui peuvent être stockées dans la variable. Vous pouvez également déterminer le comportement de la variable lorsque vous la manipulez.
Par exemple, la commande suivante caste la variable en tant que type de chaîne :
[string]$a = 27
$a += 3
$a
273
L’exemple suivant caste la première valeur, au lieu de caster la variable :
$a = [string]27
Lorsque vous castez une variable en un type spécifique, la convention courante consiste à caster la variable, et non la valeur. Toutefois, vous ne pouvez pas recaster le type de données d’une variable existante si sa valeur ne peut pas être convertie en nouveau type de données. Pour modifier le type de données, vous devez remplacer sa valeur, comme suit :
$a = "string"
[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 <<<<
[int]$a = 3
En outre, lorsque vous précèdez un nom de variable avec 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 essayez d’attribuer une valeur incompatible avec le type existant et que vous ne remplacez pas explicitement le type, PowerShell affiche une erreur, comme illustré dans l’exemple suivant :
$a = 3
$a = "string"
[int]$a = 3
$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"
[string]$a = "string"
Dans PowerShell, les types de données de 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 de 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 caste la variable en tant string [] que type de tableau :
[string []] $a = "one", "two", "three"
Les variables PowerShell peuvent être n’importe quel type de données .NET. En outre, vous pouvez affecter n’importe quel type de données .NET complet disponible dans le processus actuel. Par exemple, la commande suivante spécifie un System.DateTime type de données :
[System.DateTime]$a = "5/31/2005"
Une valeur conforme au type de données sera attribuée à la System.DateTime variable. La valeur de la $a variable est la suivante :
Tuesday, May 31, 2005 12:00:00 AM
Affectation de plusieurs variables
Dans PowerShell, vous pouvez affecter des valeurs à plusieurs variables à l’aide d’une seule commande. Le premier élément de la valeur d’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, et ainsi de suite. C’est ce que l’on appelle l’assignation multiple.
Par exemple, la commande suivante affecte la valeur 1 à la $a variable, la valeur 2 à la $b variable et la valeur 3 à la $c variable :
$a, $b, $c = 1, 2, 3
Si la valeur d’affectation contient plus d’éléments que 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, PowerShell affecte la valeur 1 à la $a variable et la valeur 2 à la $b variable. Il affecte les valeurs 3, 4 et 5 à la $c variable.
Pour affecter les valeurs de la $c variable à trois autres variables, utilisez le format suivant :
$d, $e, $f = $c
Cette commande affecte la valeur 3 à la $d variable, la valeur 4 à la $e variable et la valeur 5 à la $f variable.
Si la valeur d’affectation contient moins d’éléments que les variables, la valeur $nullest affectée aux variables restantes. Par exemple, la commande suivante contient trois variables et deux valeurs :
$a, $b, $c = 1, 2
Par conséquent, PowerShell affecte la valeur 1 à la $a variable et la valeur 2 à la $b variable. La $c variable est $null.
Vous pouvez également affecter une valeur unique à plusieurs variables en chaînant les variables. Par exemple, la commande suivante affecte une valeur de « trois » aux quatre variables :
$a = $b = $c = $d = "three"
Applets de commande liées aux variables
En plus d’utiliser une opération d’affectation pour définir une valeur de variable, vous pouvez également utiliser l’applet de commande Set-Variable . Par exemple, la commande suivante utilise Set-Variable pour affecter un tableau de 1, 2, 3 à la $a variable.
Set-Variable -Name a -Value 1, 2, 3