about_Operators
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 .
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
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.
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.
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. Vous pouvez l’utiliser pour générer des chaînes contenant la commande, les paramètres et les arguments dont vous avez besoin, puis appeler la chaîne comme s’il s’agissait d’une commande. Les chaînes que vous créez doivent suivre les mêmes règles d’analyse qu’une commande que vous tapez sur la ligne de commande. Pour plus d’informations, consultez about_Parsing.
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.
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.
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 d’arrière-plan &
Exécute le pipeline avant qu’il ne soit en arrière-plan, dans un travail PowerShell. Cet opérateur agit de la même manière que l’opérateur de contrôle UNIX (&), qui exécute la commande avant qu’elle ne soit asynchrone en tant que travail.
Cet opérateur est fonctionnellement équivalent à Start-Job. Par défaut, l’opérateur en arrière-plan démarre les travaux dans le répertoire de travail actuel de l’appelant qui a démarré les tâches parallèles. L’exemple suivant illustre l’utilisation de base de l’opérateur de travail en arrière-plan.
Get-Process -Name pwsh &
Cette commande est fonctionnellement équivalente à l’utilisation suivante de Start-Job:
Start-Job -ScriptBlock {Get-Process -Name pwsh}
Tout comme Start-Job, l’opérateur d’arrière-plan & retourne un Job objet. Cet objet peut être utilisé avec Receive-Job et Remove-Job, comme si vous aviez utilisé Start-Job pour démarrer le travail.
$job = Get-Process -Name pwsh &
Receive-Job $job -Wait
NPM(K) PM(M) WS(M) CPU(s) Id SI ProcessName
------ ----- ----- ------ -- -- -----------
0 0.00 221.16 25.90 6988 988 pwsh
0 0.00 140.12 29.87 14845 845 pwsh
0 0.00 85.51 0.91 19639 988 pwsh
Remove-Job $job
L’opérateur & d’arrière-plan est également un terminateur d’instruction, tout comme l’opérateur de contrôle UNIX ampersand (&). Cela vous permet d’appeler des commandes supplémentaires après l’opérateur d’arrière-plan & . L’exemple suivant illustre l’appel de commandes supplémentaires après l’opérateur & d’arrière-plan.
$job = Get-Process -Name pwsh & Receive-Job $job -Wait
NPM(K) PM(M) WS(M) CPU(s) Id SI ProcessName
------ ----- ----- ------ -- -- -----------
0 0.00 221.16 25.90 6988 988 pwsh
0 0.00 140.12 29.87 14845 845 pwsh
0 0.00 85.51 0.91 19639 988 pwsh
Cela équivaut au script suivant :
$job = Start-Job -ScriptBlock {Get-Process -Name pwsh}
Receive-Job $job -Wait
Si vous souhaitez exécuter plusieurs commandes, chacune dans son propre processus en arrière-plan, mais sur une seule ligne, placez & simplement entre et après chacune des commandes.
Get-Process -Name pwsh & Get-Service -Name BITS & Get-CimInstance -ClassName Win32_ComputerSystem &
Pour plus d’informations sur les travaux PowerShell, consultez about_Jobs.
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
Fournir l’accès à la fonctionnalité de mise en forme composite .NET. Une chaîne de format composite se compose d’un texte fixe mélangé à des espaces réservés indexés, appelés éléments de format. Ces éléments de format correspondent aux objets de la liste.
Chaque élément de format prend la forme suivante et comprend les composants suivants :
{index[,alignment][:formatString]}
Les accolades correspondantes ({ et }) sont obligatoires.
L'opération de mise en forme produit une chaîne résultante qui se compose du texte fixe d'origine mélangé à la représentation sous forme de chaîne des objets de la liste. Pour plus d’informations, consultez Mise en forme composite.
Entrez la chaîne de format composite sur le côté 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}
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érateurs && de chaîne de pipeline et ||
Exécutez de manière conditionnelle le pipeline de droite en fonction de la réussite du pipeline de gauche.
# If Get-Process successfully finds a process called notepad,
# Stop-Process -Name notepad is called
Get-Process notepad && Stop-Process -Name notepad
# If npm install fails, the node_modules directory is removed
npm install || Remove-Item -Recurse ./node_modules
Pour plus d’informations, consultez About_Pipeline_Chain_Operators.
Opérateur de plage ..
L’opérateur de plage peut être utilisé pour représenter un tableau d’entiers séquentiels ou de caractères. Les valeurs jointes par l’opérateur de plage définissent les valeurs de début et de fin de la plage.
Remarque
La prise en charge des plages de caractères a été ajoutée dans PowerShell 6.
Plages de nombres
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 à [int]::MaxValue - 56. Il s’agit de la taille maximale d’un tableau dans .NET.
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.
Plages de caractères
Pour créer une plage de caractères, placez les caractères entre guillemets.
PS> 'a'..'f'
a
b
c
d
e
f
PS> 'F'..'A'
F
E
D
C
B
A
Si vous attribuez une plage de caractères à une chaîne, elle est traitée de la même façon en affectant un tableau de caractères à une chaîne.
PS> [string]$s = 'a'..'e'
$s
a b c d e
$a = 'a', 'b', 'c', 'd', 'e'
$a
a b c d e
Les caractères du tableau sont joints à une chaîne. Les caractères sont séparés par la valeur de la $OFS variable de préférence. Pour plus d’informations, consultez about_Preference_Variables.
L’ordre des caractères du tableau est déterminé par la valeur ASCII du caractère. Par exemple, les valeurs ASCII de c X 99 et 88, respectivement. Cette plage serait présentée dans l’ordre inverse.
PS> 'c'..'X'
c
b
a
`
_
^
]
\
[
Z
Y
X
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]:: $_ }
Opérateur ternaire ? <if-true> : <if-false>
Vous pouvez utiliser l’opérateur ternaire comme remplacement de l’instruction if-else dans des cas conditionnels simples.
Pour plus d’informations, consultez about_If.
Opérateur de coalescence Null ??
L’opérateur de coalescence Null ?? retourne la valeur de son opérande gauche s’il n’est pas Null. Dans le cas contraire, il évalue l’opérande droit et retourne son résultat. L’opérateur ?? n’évalue pas son opérande droit si l’opérande gauche a la valeur non Null.
$x = $null
$x ?? 100
100
Dans l’exemple suivant, l’opérande droit n’est pas évalué.
[string] $todaysDate = '1/10/2020'
$todaysDate ?? (Get-Date).ToShortDateString()
1/10/2020
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
Dans l’exemple suivant, l’opérande droit n’est pas évalué.
[string] $todaysDate = '1/10/2020'
$todaysDate ??= (Get-Date).ToShortDateString()
$todaysDate
1/10/2020
Opérateurs conditionnels Null ?. et ?[]
Remarque
Cette fonctionnalité a été déplacée d’expérimentale à standard dans PowerShell 7.1.
Un opérateur conditionnel Null n’applique une opération d'accès à un membre, ?., ou d'accès à un élément, ?[], à son opérande que si cet opérande a la valeur non Null ; sinon, il retourne la valeur Null.
Étant donné que PowerShell permet à ? de faire partie du nom de la variable, la spécification formelle du nom de la variable est requise pour l’utilisation de ces opérateurs. Vous devez utiliser des accolades ({}) autour des noms de variables comme ${a} ou quand ? fait partie du nom ${a?}de la variable.
Remarque
La syntaxe du nom de variable de ${<name>} ne doit pas être confondue avec l’opérateur $() de sous-expression. Pour plus d’informations, consultez la section Nom de variable about_Variables.
Dans l’exemple suivant, la valeur de PropName est retournée.
$a = @{ PropName = 100 }
${a}?.PropName
100
L’exemple suivant retourne null sans essayer d’accéder au nom de membre PropName.
$a = $null
${a}?.PropName
Dans cet exemple, la valeur de l’élément indexé est retournée.
$a = 1..10
${a}?[0]
1
L’exemple suivant retourne null sans essayer d’accéder à l’élément indexé.
$a = $null
${a}?[0]
