about_Operator_Precedence

  • Article

Description courte

Répertorie les opérateurs PowerShell dans l’ordre de priorité.

Description longue

Les opérateurs PowerShell vous permettent de construire des expressions simples, mais puissantes. Cette rubrique répertorie les opérateurs dans l’ordre de priorité. L’ordre de précédence est l’ordre dans lequel PowerShell évalue les opérateurs lorsque plusieurs opérateurs apparaissent dans la même expression.

Lorsque les opérateurs ont une priorité égale, PowerShell les évalue de gauche à droite lorsqu’ils apparaissent dans l’expression. Les exceptions sont les opérateurs d’assignation, les opérateurs de cast et les opérateurs de négation (!, -not, -bnot), qui sont évalués de droite à gauche.

Vous pouvez utiliser des boîtiers, tels que des parenthèses, pour remplacer l’ordre de priorité standard et forcer PowerShell à évaluer la partie fermée d’une expression avant une partie non fermée.

Dans la liste suivante, les opérateurs sont répertoriés dans l’ordre dans lequel ils sont évalués. Les opérateurs sur la même ligne, ou dans le même groupe, ont une priorité égale.

La colonne Opérateur répertorie les opérateurs. La colonne Référence répertorie la rubrique d’aide PowerShell dans laquelle l’opérateur est décrit. Pour afficher la rubrique, tapez get-help <topic-name>.

OPERATOR RÉFÉRENCE
$() @() () @{} about_Operators
. ?. (accès aux membres) about_Operators
:: (statique) about_Operators
[0] ?[0] (opérateur d’index) about_Operators
[int] (opérateurs de cast) about_Operators
-split (unaire) about_Split
-join (unaire) about_Join
, (opérateur virgule) about_Operators
++ -- about_Assignment_Operators
! -not about_Logical_Operators
.. (opérateur de plage) about_Operators
-f (opérateur de format) about_Operators
- (unaire/négatif) about_Arithmetic_Operators
* / % about_Arithmetic_Operators
+ - about_Arithmetic_Operators

Le groupe d’opérateurs suivant a une priorité égale. Leurs variantes respectant la casse et ne respectent pas explicitement la casse ont la même priorité.

OPERATOR RÉFÉRENCE
-split (binaire) about_Split
-join (binaire) about_Join
-is -isnot -as about_Type_Operators
-eq -ne -gt -ge -lt -le about_Comparison_Operators
-like -notlike about_Comparison_Operators
-match -notmatch about_Comparison_Operators
-in -notIn about_Comparison_Operators
-contains -notContains about_Comparison_Operators
-replace about_Comparison_Operators

La liste reprend ici avec les opérateurs suivants dans l’ordre de priorité :

OPERATOR RÉFÉRENCE
-band -bnot -bor -bxor -shr -shl about_Arithmetic_Operators
-and -or -xor about_Logical_Operators

Les éléments suivants ne sont pas des opérateurs vrais. Ils font partie de la syntaxe de commande de PowerShell, et non de la syntaxe d’expression. L’affectation est toujours la dernière action qui se produit.

SYNTAX RÉFÉRENCE
. (dot-source) about_Operators
& (appel) about_Operators
? <if-true> : <if-false> (Opérateur ternaire) about_Operators
?? (opérateur null-coalese) about_Operators
| (opérateur de pipeline) about_Operators
> >> 2> 2>> 2>&1 about_Redirection
&& || (opérateurs de chaîne de pipeline) about_Operators
= += -= *= /= %= ??= about_Assignment_Operators

Exemples

Les deux commandes suivantes montrent les opérateurs arithmétiques et l’effet de l’utilisation de parenthèses pour forcer PowerShell à évaluer la partie entourée de l’expression en premier.

PS> 2 + 3 * 4
14

PS> (2 + 3) * 4
20

L’exemple suivant obtient les fichiers texte en lecture seule à partir du répertoire local et les enregistre dans la $read_only variable.

$read_only = Get-ChildItem *.txt | Where-Object {$_.isReadOnly}

Il équivaut à l’exemple suivant.

$read_only = ( Get-ChildItem *.txt | Where-Object {$_.isReadOnly} )

Étant donné que l’opérateur de pipeline (|) a une priorité plus élevée que l’opérateur d’affectation (=), les fichiers que l’applet Get-ChildItem de commande obtient sont envoyés à l’applet Where-Object de commande pour le filtrage avant qu’elles ne soient affectées à la $read_only variable.

L’exemple suivant montre que l’opérateur d’index est prioritaire sur l’opérateur de cast.

Cette expression crée un tableau de trois chaînes. Ensuite, il utilise l’opérateur d’index avec la valeur 0 pour sélectionner le premier objet du tableau, qui est la première chaîne. Enfin, il convertit l’objet sélectionné en tant que chaîne. Dans ce cas, le cast n’a aucun effet.

PS> [string]@('Windows','PowerShell','2.0')[0]
Windows

Cette expression utilise des parenthèses pour forcer l’opération de cast à se produire avant la sélection d’index. Par conséquent, l’ensemble du tableau est casté sous la forme d’une chaîne (unique). Ensuite, l’opérateur d’index sélectionne le premier élément du tableau de chaînes, qui est le premier caractère.

PS> ([string]@('Windows','PowerShell','2.0'))[0]
W

Dans l’exemple suivant, étant donné que l’opérateur -gt (supérieur à) a une priorité plus élevée que l’opérateur -and (AND logique), le résultat de l’expression est FALSE.

PS> 2 -gt 4 -and 1
False

Il équivaut à l’expression suivante.

PS> (2 -gt 4) -and 1
False

Si l’opérateur -and-a une priorité plus élevée, la réponse est TRUE.

PS> 2 -gt (4 -and 1)
True

Toutefois, cet exemple illustre un principe important de gestion de la priorité des opérateurs. Lorsqu’une expression est difficile à interpréter, utilisez des parenthèses pour forcer l’ordre d’évaluation, même lorsqu’elle force la priorité de l’opérateur par défaut. Les parenthèses rendent vos intentions claires aux personnes qui lisent et gèrent vos scripts.

Voir aussi