about_Operators

  • Article

Description courte

Décrit les opérateurs pris en charge par PowerShell.

Description longue

Un opérateur est un élément de langage que vous pouvez utiliser dans une commande ou une expression. PowerShell prend en charge plusieurs types d’opérateurs pour vous aider à manipuler des valeurs.

Opérateurs arithmétiques

Utilisez des opérateurs arithmétiques (+, , -, */, %) pour calculer des valeurs dans une commande ou une expression. Avec ces opérateurs, vous pouvez ajouter, soustraire, multiplier ou diviser des valeurs et calculer le reste (module) d’une opération de division.

L’opérateur d’ajout concatène des éléments. L’opérateur de multiplication retourne le nombre spécifié de copies de chaque élément. Vous pouvez utiliser des opérateurs arithmétiques sur n’importe quel type .NET qui les implémente, tels que : Int, , StringDateTime, , Hashtableet Tableaux.

Les opérateurs au niveau du bit (-band, , -bor, -bxor-bnot, -shl) -shrmanipulent les modèles de bits dans les valeurs.

Pour plus d’informations, consultez about_Arithmetic_Operators.

Opérateurs d’assignation

Utilisez des opérateurs d’affectation (=, , +=, -=*=, /=%=) pour affecter, modifier ou ajouter des valeurs à des variables. Vous pouvez combiner des opérateurs arithmétiques avec une affectation pour affecter le résultat de l’opération arithmétique à une variable.

Pour plus d’informations, consultez about_Assignment_Operators.

Opérateurs de comparaison

Utilisez des opérateurs de comparaison (-eq, , -ne, -gt-lt, -le-ge) pour comparer les valeurs et les conditions de test. Par exemple, vous pouvez comparer deux valeurs de chaîne pour déterminer si elles sont égales.

Les opérateurs de comparaison incluent également des opérateurs qui recherchent ou remplacent des modèles dans du texte. Les opérateurs (-match, , -notmatch-replace) utilisent des expressions régulières et (-like, -notlike) utilisent des caractères génériques carte s *.

Les opérateurs de comparaison de l’isolement déterminent si une valeur de test apparaît dans un jeu de références (-in, -notin, -contains, -notcontains).

Les opérateurs de comparaison de type (-is, -isnot) déterminent si un objet est d’un type donné.

Pour plus d’informations, consultez about_Comparison_Operators.

Opérateurs logiques

Utilisez des opérateurs logiques (-and, , -or, -xor-not, !) pour connecter des instructions conditionnelles dans une seule condition complexe. Par exemple, vous pouvez utiliser un opérateur logique -and pour créer un filtre d’objet avec deux conditions différentes.

Pour plus d’informations, consultez about_Logical_Operators.

Opérateurs de redirection

Utilisez des opérateurs de redirection (>, , >>2>, 2>>et 2>&1) pour envoyer la sortie d’une commande ou d’une expression à un fichier texte. Les opérateurs de redirection fonctionnent comme l’applet Out-File de commande (sans paramètres), mais ils vous permettent également de rediriger la sortie d’erreur vers des fichiers spécifiés. Vous pouvez également utiliser l’applet de commande pour rediriger la Tee-Object sortie.

Pour plus d’informations, consultez about_Redirection

Opérateurs de fractionnement et de jointure

-join Les -split opérateurs divisent et combinent des sous-chaînes. L’opérateur -split fractionne une chaîne en sous-chaînes. L’opérateur -join concatène plusieurs chaînes en une seule chaîne.

Pour plus d’informations, consultez about_Split et about_Join.

Opérateurs de type

Utilisez les opérateurs de type (-is, , -isnot-as) pour rechercher ou modifier le type .NET d’un objet.

Pour plus d’informations, consultez about_Type_Operators.

Opérateurs unaires

Utilisez l’unaire ++ et -- les opérateurs pour incrémenter ou décrémenter des valeurs et - pour la négation. Par exemple, pour incrémenter la variable à partir de 9 , vous tapez $a++.10$a

Pour plus d’informations, consultez about_Arithmetic_Operators.

Opérateurs spéciaux

Les opérateurs spéciaux ont des cas d’usage spécifiques qui ne tiennent pas dans un autre groupe d’opérateurs. Par exemple, des opérateurs spéciaux vous permettent d’exécuter des commandes, de modifier le type de données d’une valeur ou de récupérer des éléments à partir d’un tableau.

Opérateur de regroupement ( )

Comme dans d’autres langages, (...) sert à remplacer la priorité des opérateurs dans les expressions. Par exemple : (1 + 2) / 3

Toutefois, dans PowerShell, il existe des comportements supplémentaires.

Regroupement d’expressions de résultat

(...) vous permet de laisser la sortie d’une commande participer à une expression. Par exemple :

PS> (Get-Item *.txt).Count -gt 10
True

Remarque

L’habillage d’une commande entre parenthèses entraîne la définition $truede la variable $? automatique sur , même lorsque la commande placée entre parenthèses est définie $?$falsesur . Par exemple, (Get-Item /Nosuch); $? renvoie de manière inattendue True. Pour plus d’informations sur $?, consultez about_Automatic_Variables.

Expressions groupées de piping

Lorsqu’il est utilisé comme premier segment d’un pipeline, l’encapsulation d’une commande ou d’une expression entre parenthèses provoque invariablement l’énumération du résultat de l’expression. Si les parenthèses encapsulent une commande, elle est exécutée jusqu’à la fin avec toutes les sorties collectées en mémoire avant que les résultats ne soient envoyés via le pipeline.

Par exemple, les sorties de ces instructions sont différentes :

PS> ConvertFrom-Json '["a", "b"]'   | ForEach-Object { "The value is '$_'" }

The value is 'a b'

PS> (ConvertFrom-Json '["a", "b"]') | ForEach-Object { "The value is '$_'" }

The value is 'a'
The value is 'b'

Le regroupement d’une expression avant le piping garantit également que le traitement d’objet par objet ultérieur ne peut pas interférer avec l’énumération utilisée par la commande pour produire sa sortie.

Par exemple, la canalisation de la sortie à partir de Get-ChildItem laquelle Rename-Item peut avoir des effets inattendus où un élément est renommé, puis découvert à nouveau et renommé une deuxième fois.

Instructions d’affectation de regroupement

Les instructions d’affectation non groupées ne génèrent pas de valeurs. Lors du regroupement d’une instruction d’affectation, la valeur de la variable affectée est transmise et peut être utilisée dans des expressions plus volumineuses. Par exemple :

PS> ($var = 1 + 2)
3
PS> ($var = 1 + 2) -eq 3
True

Encapsuler l’instruction entre parenthèses le transforme en expression qui génère la valeur de $var.

Ce comportement s’applique à tous les opérateurs d’affectation, y compris les opérateurs composés tels que +=, et les opérateurs d’incrément (++) et de décrémentation (--). Toutefois, l’ordre d’opération pour incrémenter et décrémenter dépend de leur position.

PS> $i = 0
PS> (++$i) # prefix
1
PS> $i = 0
PS> ($i++) # postfix
0
PS> $i
1

Dans le cas du préfixe, la valeur de $i l’élément est incrémentée avant d’être sortie. Dans le cas de postfix, la valeur de celle-ci $i est incrémentée après avoir été sortie.

Vous pouvez également utiliser cette technique dans le contexte d’une instruction conditionnelle, telle que l’instruction if .

if ($textFiles = Get-ChildItem *.txt) {
    $textFiles.Count
}

Dans cet exemple, si aucun fichier ne correspond, la Get-ChildItem commande ne renvoie rien et n’affecte rien à $textFiles, ce qui est considéré $false dans un contexte booléen. Si un ou plusieurs objets FileInfo sont affectés $textFiles, le conditionnel est évalué à $true. Vous pouvez utiliser la valeur de $textFiles l’instruction dans le corps de l’instruction if .

Remarque

Bien que cette technique soit pratique et concise, elle peut entraîner une confusion entre l’opérateur d’affectation (=) et l’opérateur de comparaison d’égalité (-eq).

Opérateur de sous-expression $( )

Retourne le résultat d’une ou plusieurs instructions. Pour un résultat unique, retourne une scalaire. Pour plusieurs résultats, retourne un tableau. Utilisez cette option lorsque vous souhaitez utiliser une expression dans une autre expression. Par exemple, pour incorporer les résultats de la commande dans une expression de chaîne.

PS> "Today is $(Get-Date)"
Today is 12/02/2019 13:15:20

PS> "Folder list: $((dir c:\ -dir).Name -join ', ')"
Folder list: Program Files, Program Files (x86), Users, Windows

Opérateur de sous-expression de tableau @( )

Retourne le résultat d’une ou plusieurs instructions sous forme de tableau. Le résultat est toujours un tableau de 0 ou plusieurs objets.

PS> $list = @(Get-Process | Select-Object -First 10; Get-Service | Select-Object -First 10 )
PS> $list.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array

PS> $list.Count
20
PS> $list = @(Get-Service | Where-Object Status -eq Starting )
PS> $list.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array

PS> $list.Count
0

Syntaxe littérale de table de hachage @{}

Comme pour la sous-expression de tableau, cette syntaxe est utilisée pour déclarer une table de hachage. Pour plus d’informations, consultez about_Hash_Tables.

Opérateur d’appel &

Exécute une commande, un script ou un bloc de script. L’opérateur d’appel, également appelé « opérateur d’appel », vous permet d’exécuter des commandes stockées dans des variables et représentées par des chaînes ou des blocs de script. L’opérateur d’appel s’exécute dans une étendue enfant. Pour plus d’informations sur les étendues, consultez about_Scopes.

Cet exemple stocke une commande dans une chaîne et l’exécute à l’aide de l’opérateur d’appel.

PS> $c = "get-executionpolicy"
PS> $c
get-executionpolicy
PS> & $c
AllSigned

L’opérateur d’appel n’analyse pas les chaînes. Cela signifie que vous ne pouvez pas utiliser de paramètres de commande dans une chaîne lorsque vous utilisez l’opérateur d’appel.

PS> $c = "Get-Service -Name Spooler"
PS> $c
Get-Service -Name Spooler
PS> & $c
& : The term 'Get-Service -Name Spooler' is not recognized as the name of a
cmdlet, function, script file, or operable program. Check the spelling of
the name, or if a path was included, verify that the path is correct and
try again.
At line:1 char:2
+ & $c
+  ~~
    + CategoryInfo          : ObjectNotFound: (Get-Service -Name Spooler:String) [], CommandNotFoundException
    + FullyQualifiedErrorId : CommandNotFoundException

L’applet de commande Invoke-Expression peut exécuter du code qui provoque des erreurs d’analyse lors de l’utilisation de l’opérateur d’appel.

PS> & "1+1"
&: The term '1+1' is not recognized as a name of a cmdlet, function, script
file, or executable program. Check the spelling of the name, or if a path was
included, verify that the path is correct and try again.
At line:1 char:2
+ & "1+1"
+  ~~~~~
    + CategoryInfo          : ObjectNotFound: (1+1:String) [], CommandNotFoundException
    + FullyQualifiedErrorId : CommandNotFoundException
PS> Invoke-Expression "1+1"
2

Vous pouvez exécuter un script à l’aide de son nom de fichier. Un fichier de script doit avoir une .ps1 extension de fichier à exécutable. Les fichiers qui ont des espaces dans leur chemin doivent être placés entre guillemets. Si vous essayez d’exécuter le chemin entre guillemets, PowerShell affiche le contenu de la chaîne entre guillemets au lieu d’exécuter le script. L’opérateur d’appel vous permet d’exécuter le contenu de la chaîne contenant le nom de fichier.

PS C:\Scripts> Get-ChildItem

    Directory: C:\Scripts


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
-a----        8/28/2018   1:36 PM             58 script name with spaces.ps1

PS C:\Scripts> ".\script name with spaces.ps1"
.\script name with spaces.ps1
PS C:\Scripts> & ".\script name with spaces.ps1"
Hello World!

Pour plus d’informations sur les blocs de script, consultez about_Script_Blocks.

Opérateur cast [ ]

Convertit ou limite les objets en type spécifié. Si les objets ne peuvent pas être convertis, PowerShell génère une erreur.

[DateTime] '2/20/88' - [DateTime] '1/20/88' -eq [TimeSpan] '31'

Un cast peut également être effectué lorsqu’une variable est affectée à l’aide de la notation de cast.

Opérateur virgule ,

En tant qu’opérateur binaire, la virgule crée un tableau ou ajoute au tableau en cours de création. En mode expression, en tant qu’opérateur unaire, la virgule crée un tableau avec un seul membre. Placez la virgule avant le membre.

$myArray = 1,2,3
$SingleArray = ,1
Write-Output (,1)

Étant donné que Write-Output vous attendez un argument, vous devez placer l’expression entre parenthèses.

Opérateur d’approvisionnement par points .

Exécute un script dans l’étendue actuelle afin que toutes les fonctions, alias et variables créées par le script soient ajoutées à l’étendue actuelle, en remplaçant les fonctions existantes. Les paramètres déclarés par le script deviennent des variables. Les paramètres pour lesquels aucune valeur n’a été donnée deviennent des variables sans valeur. Toutefois, la variable $args automatique est conservée.

. c:\scripts\sample.ps1 1 2 -Also:3

Remarque

L’opérateur d’approvisionnement par points est suivi d’un espace. Utilisez l’espace pour distinguer le point du symbole point (.) qui représente le répertoire actif.

Dans l’exemple suivant, le script Sample.ps1 dans le répertoire actif est exécuté dans l’étendue actuelle.

. .\sample.ps1

Opérateur de format -f

Met en forme des chaînes à l’aide de la méthode de format des objets de chaîne. Entrez la chaîne de format à gauche de l’opérateur et les objets à mettre en forme à droite de l’opérateur.

"{0} {1,-10} {2:N}" -f 1,"hello",[math]::pi

1 hello      3.14

Vous pouvez vider une valeur numérique avec le spécificateur personnalisé « 0 ». Le nombre de zéros suivant indique : la largeur maximale à laquelle remplir la chaîne mise en forme.

"{0:00} {1:000} {2:000000}" -f 7, 24, 365

07 024 000365

Si vous devez conserver les accolades ({}) dans la chaîne mise en forme, vous pouvez les échapper en doublant les accolades.

"{0} vs. {{0}}" -f 'foo'

foo vs. {0}

Pour plus d’informations, consultez la méthode String.Format et la mise en forme composite.

Opérateur d’index [ ]

Sélectionne des objets dans des collections indexées, telles que des tableaux et des tables de hachage. Les index de tableau sont de base zéro. Par conséquent, le premier objet est indexé en tant que [0]. Vous pouvez également utiliser des index négatifs pour obtenir les dernières valeurs. Les tables de hachage sont indexées par valeur de clé.

Étant donné une liste d’index, l’opérateur d’index retourne une liste de membres correspondant à ces index.

PS> $a = 1, 2, 3
PS> $a[0]
1
PS> $a[-1]
3
PS> $a[2, 1, 0]
3
2
1

(Get-HotFix | Sort-Object installedOn)[-1]

$h = @{key="value"; name="PowerShell"; version="2.0"}
$h["name"]

PowerShell

$x = [xml]"<doc><intro>Once upon a time...</intro></doc>"
$x["doc"]

intro
-----
Once upon a time...

Lorsqu’un objet n’est pas une collection indexée, l’utilisation de l’opérateur d’index pour accéder au premier élément retourne l’objet lui-même. Valeurs d’index au-delà du premier élément retourné $null.

PS> (2)[0]
2
PS> (2)[-1]
2
PS> (2)[1] -eq $null
True
PS> (2)[0,0] -eq $null
True

Opérateur de pipeline |

Envoie (« canaux ») la sortie de la commande qui l’précède à la commande qui la suit. Lorsque la sortie inclut plusieurs objets (une « collection »), l’opérateur de pipeline envoie les objets un à la fois.

Get-Process | Get-Member
Get-Service | Where-Object {$_.StartType -eq 'Automatic'}

Opérateur de plage ..

L’opérateur de plage peut être utilisé pour représenter un tableau d’entiers séquentiels. Les valeurs jointes par l’opérateur de plage définissent les valeurs de début et de fin de la plage.

1..10
$max = 10
foreach ($a in 1..$max) {Write-Host $a}

Vous pouvez également créer des plages dans l’ordre inverse.

10..1
5..-5 | ForEach-Object {Write-Output $_}

Les valeurs de début et de fin de la plage peuvent être n’importe quelle paire d’expressions qui évaluent un entier ou un caractère. Les points de terminaison de la plage doivent être convertibles en entiers 32 bits signés ([int32]). Les valeurs plus volumineuses provoquent une erreur. En outre, si la plage est capturée dans un tableau, la taille du tableau résultant est limitée à 268435448 (ou 256mb - 8). Il s’agit de la taille maximale d’un tableau dans .NET Framework.

Par exemple, vous pouvez utiliser les membres d’une énumération pour vos valeurs de début et de fin.

PS> enum Food {
      Apple
      Banana = 3
      Kiwi = 10
    }
PS> [Food]::Apple..[Food]::Kiwi
0
1
2
3
4
5
6
7
8
9
10

Important

La plage résultante n’est pas limitée aux valeurs de l’énumération. Au lieu de cela, il représente la plage de valeurs entre les deux valeurs fournies. Vous ne pouvez pas utiliser l’opérateur de plage pour représenter de manière fiable les membres d’une énumération.

Opérateur d’accès aux membres .

Accède aux propriétés et méthodes d’un objet. Le nom du membre peut être une expression.

$myProcess.peakWorkingSet
(Get-Process PowerShell).kill()
'OS', 'Platform' | Foreach-Object { $PSVersionTable. $_ }

À compter de PowerShell 3.0, lorsque vous utilisez l’opérateur sur un objet de collection de listes qui n’a pas le membre, PowerShell énumère automatiquement les éléments de cette collection et utilise l’opérateur sur chacun d’eux. Pour plus d’informations, consultez about_Member-Access_Enumeration.

Opérateur membre statique ::

Appelle les propriétés et méthodes statiques d’une classe .NET. Pour rechercher les propriétés et méthodes statiques d’un objet, utilisez le paramètre statique de l’applet Get-Member de commande. Le nom du membre peut être une expression.

[datetime]::Now
'MinValue', 'MaxValue' | Foreach-Object { [int]:: $_ }

Voir aussi