about_Assignment_Operators

  • Article

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. Le signe égal (=) est l’opérateur d’affectation PowerShell. PowerShell a également les opérateurs d’affectation composée suivants : +=, , %=*=-=, ++, , --, . ??= Les opérateurs d’affectation composée effectuent des opérations sur les valeurs avant l’affectation.

Syntaxe

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. Chacun possède des versions de préfixe et de postfix.

  • <assignable-expression><operator>
  • <operator><assignable-expression>

La valeur de l’expression assignable doit être un nombre ou être convertible en nombre.

Utilisation de l’opérateur d’affectation

Les variables sont des espaces de mémoire nommés qui stockent les 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. 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 s’il 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 change uniquement 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 contient un seul objet, la variable prend le type de données de cet objet. Lorsqu’une variable contient une collection d’objets, la variable 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 commande à 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 affecte zéro à la $a variable si la valeur de $b la valeur est inférieure à zéro. Elle affecte la valeur à $b si la valeur de $b n’est pas inférieure à $a zéro.

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 @ à l’aide 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 $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 numéro 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 en octets GB . Par exemple, pour affecter une valeur de 10 kilo-octets à la $a variable, tapez :

$a = 10kb

Utilisation d’opérateurs d’affectation composée

Les opérateurs d’affectation composée effectuent des opérations numériques sur les valeurs avant l’affectation.

Important

Les opérateurs d’affectation composée n’utilisent pas d’étendue dynamique. La variable est toujours dans l’étendue actuelle.

Dans l’exemple suivant, la variable $x est définie dans l’étendue globale. Les accolades créent une nouvelle étendue. La variable $x à l’intérieur des accolades est une nouvelle instance et non une copie de la variable globale.

$x = 1 # Global scope
& { $x += 1; $x }

1

Lorsque vous utilisez l’opérateur d’affectation régulière, vous obtenez une copie de la variable à partir de l’étendue parente. Mais notez que $x dans l’étendue parente n’est pas modifiée.

$x = 1 # Global scope
& { $x = $x + 1; $x }
"Global `$x = $x"

2
Global $x = 1

Affectation par opérateur d’ajout

L’affectation par opérateur += d’ajout 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 de 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 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 par la quantité sur le 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 :

$a = 4
$a += 2
$a

6

Lorsque la valeur de la variable est une chaîne, la valeur du côté droit 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 du côté droit 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 à 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 efficacement 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

InvalidOperation:
Line |
   2 |  $a += 1
     |  ~~~~~~~
     | A hash table can only be added to another hash table.

Affectation par l’opérateur de soustraction

L’affectation par l’opérateur -= de soustraction décrémente la valeur d’une variable par la valeur 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. Tout d’abord, il soustrait, 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 :

$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 ou $null"" à 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 convertie 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

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 valeur est multipliée par la valeur du côté droit 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 multiplie, 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, 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’affectation par opérateur /= de division divise une valeur numérique par la valeur spécifiée à droite 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 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 :

$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

Affectation par l’opérateur modulus

L’affectation par l’opérateur %= modulus divise la valeur d’une variable par la valeur du côté droit de l’opérateur. Ensuite, l’opérateur %= affecte le reste (appelé module) à la variable. Vous ne pouvez utiliser cet opérateur que 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. Tout d’abord, il divise et détermine le reste, puis 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 ++ d’incrément augmente la valeur d’une variable de 1. Lorsque vous utilisez l’opérateur d’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 d’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 son utilisation 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 son utilisation dans l’instruction. Dans l’exemple suivant, les $c variables ont $a des valeurs différentes, car la valeur est affectée avant $c$a les modifications :

$a = 7
$c = $a++
$a

8

$c

7

L’opérateur -- de décrémentation diminue la valeur d’une variable de 1. 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 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 son utilisation 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 après son utilisation dans l’instruction. Dans l’exemple suivant, les $d variables ont $a des valeurs différentes, car la valeur est affectée avant $d$a les modifications :

$a = 7
$d = $a--
$a

6

$d

7

Opérateur d’affectation de fusion Null

L’opérateur d’assignation de fusion Null ??= assigne la valeur de son opérande droit à son opérande gauche uniquement si l’opérande gauche a la valeur Null. L’opérateur ??= n’évalue pas son opérande droit si l’opérande gauche a la valeur non Null.

$x = $null
$x ??= 100
$x

100

Pour plus d’informations, consultez l’opérateur De fusion Null.

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 qui a le type System.Int32 :

$a = 6

Pour rechercher le type .NET d’une variable, utilisez la méthode GetType et sa propriété FullName . 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 en tant qu’opérations de chaîne et convertit de 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 convertit de nouvelles valeurs en entiers. Cela se produit dans l’exemple suivant :

$a = 6
$a += "3"
$a

9

Vous pouvez convertir 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 définissez le type de données qui peut être stocké dans la variable.

Par exemple, la commande suivante convertit 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 convertir la variable :

$a = [string]27

Vous ne pouvez pas recastre le type de données d’une variable existante si sa valeur ne peut pas être convertie en nouveau type de données.

$a = "string"
[int]$a

InvalidArgument: Cannot convert value "string" to type "System.Int32". Error:
"The input string 'string' was not in a correct format."

Pour modifier le type de données, vous devez remplacer sa valeur, comme suit :

[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’affecter 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"

MetadataError:
Line |
   2 |  $a = "string"
     |  ~~~~~~~~~~~~~
     | Cannot convert value "string" to type "System.Int32". Error: "The input
string 'string' was not in a correct format."

[string]$a = "string"

Dans PowerShell, les types de données de variables qui contiennent plusieurs éléments d’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 convertit la variable en tant que string [] 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"

La variable reçoit une valeur conforme au System.DateTime type de données. 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. 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. Elle 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 de variables, les variables restantes sont affectées à la valeur $null. 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"

Outre l’utilisation d’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

Voir aussi