about_Language_Keywords
Mis à jour: mai 2014
S'applique à: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
RUBRIQUE
about_Language_Keywords
DESCRIPTION COURTE
Décrit les mots clés dans le langage de script Windows PowerShell®.
DESCRIPTION DÉTAILLÉE
Windows PowerShell possède les mots clés de langage suivants. Pour plus d'informations, consultez la rubrique about pour le mot clé et les informations à la suite du tableau.
Keyword Reference
------- ---------
Begin about_Functions, about_Functions_Advanced
Break about_Break, about_Trap
Catch about_Try_Catch_Finally
Continue about_Continue, about_Trap
Data about_Data_Sections
Do about_Do, about_While
DynamicParam about_Functions_Advanced_Parameters
Else about_If
Elseif about_If
End about_Functions, about_Functions_Advanced_Methods
Exit Described in this topic.
Filter about_Functions
Finally about_Try_Catch_Finally
For about_For
ForEach about_ForEach
From Reserved for future use.
Function about_Functions, about_Functions_Advanced
If about_If
In about_ForEach
InlineScript about_InlineScript
Parallel about_Parallel, about_ForEach-Parallel
Param about_Functions
Process about_Functions, about_Functions_Advanced
Return about_Return
Sequence about_Sequence
Switch about_Switch
Throw about_Throw, about_Functions_Advanced_Methods
Trap about_Trap, about_Break, about_Try_Catch_Finally
Try about_Try_Catch_Finally
Until about_Do
While about_While, about_Do
Workflow about_Workflows
MOTS CLÉS DE LANGAGE
Begin
-----
Spécifie une partie du corps d'une fonction, ainsi que les mots clés DynamicParam, Process et End. La liste d'instructions Begin s'exécute une fois avant la réception d'objets du pipeline.
Syntaxe :
function <name> {
DynamicParam {<statement list>}
begin {<statement list>}
process {<statement list>}
end {<statement list>}
}
Break
-----
Provoque la sortie d'une boucle d'un script.
Syntaxe :
while (<condition>) {
<statements>
...
break
...
<statements>
}
Catch
-----
Spécifie une liste d'instructions à exécuter si une erreur se produit dans la liste d'instructions Try associée. Un type d'erreur requiert des crochets. La deuxième paire de crochets indique que le type d'erreur est facultatif.
Syntaxe :
try {<statement list>}
catch [[<error type>]] {<statement list>}
Continue
--------
Provoque l'arrêt de l'exécution d'une boucle par un script et son retour à la condition. Si la condition est remplie, le script recommence la boucle.
Syntaxe :
while (<condition>) {
<statements>
...
continue
...
<statements>
}
Data
----
Dans un script, définit une section qui isole les données de la logique de script. Peut également inclure des instructions If et certaines commandes limitées.
Syntaxe :
data <variable> [-supportedCommand <cmdlet-name>] {<permitted content>}
Do
--
Utilisé avec le mot clé While ou Until comme construction de bouclage. Windows PowerShell exécute la liste d'instructions au moins une fois, à la différence d'une boucle qui utilise While.
Syntaxe :
do {<statement list>} while (<condition>)
do {<statement list>} until (<condition>)
DynamicParam
------------
Spécifie une partie du corps d'une fonction, ainsi que les mots clés Begin, Process et End. Les paramètres dynamiques sont ajoutés au moment de l'exécution.
Syntaxe :
function <name> {
DynamicParam {<statement list>}
begin {<statement list>}
process {<statement list>}
end {<statement list>}
}
Else
----
Utilisé avec le mot clé If pour spécifier la liste d'instructions par défaut.
Syntaxe :
if (<condition>) {<statement list>}
else {<statement list>}
Elseif
------
Utilisé avec les mots clés If et Else pour spécifier des conditions supplémentaires. Le mot clé Else est facultatif.
Syntaxe :
if (<condition>) {<statement list>}
elseif (<condition>) {<statement list>}
else {<statement list>}
End
---
Spécifie une partie du corps d'une fonction, ainsi que les mots clés DynamicParam, Begin et End. La liste d'instructions End s'exécute une fois après la réception de tous les objets du pipeline.
Syntaxe :
function <name> {
DynamicParam {<statement list>}
begin {<statement list>}
process {<statement list>}
end {<statement list>}
}
Exit
----
Provoque la sortie de Windows PowerShell d'un script ou d'une instance Windows PowerShell.
Quand vous exécutez « powershell.exe –File <chemin d'accès à un script> », vous pouvez uniquement affecter une valeur différente de zéro à la variable %ERRORLEVEL% à l'aide de l'instruction exit. Dans l'exemple suivant, l'utilisateur définit la valeur de variable de niveau d'erreur 4 en tapant « exit 4 ».
C:\Users\bruce\documents\test>type test.ps1
1
2
3
exit 4
C:\Users\bruce\documents\test>powershell -file ./test.ps1
1
2
3
C:\Users\bruce\documents\test>echo %ERRORLEVEL%
4
Quand vous utilisez powershell.exe avec le paramètre File, le fichier .ps1 (script) lui-même doit inclure des instructions pour la gestion des erreurs ou des exceptions qui se produisent pendant l'exécution du script. Vous devez uniquement utiliser l'instruction exit pour indiquer l'état du script après l'exécution.
Syntaxe :
exit
exit <exit code>
Filter
------
Spécifie une fonction dans laquelle la liste d'instructions s'exécute une fois pour chaque objet d'entrée. Elle a le même effet qu'une fonction qui contient uniquement un bloc Process.
Syntaxe :
filter <name> {<statement list>}
Finally
-------
Définit une liste d'instructions qui s'exécute après les instructions qui sont associées à Try et Catch. Une liste d'instructions Finally s'exécute même si vous appuyez sur CTRL+C pour quitter un script ou si vous utilisez le mot clé Exit dans le script.
Syntaxe :
try {<statement list>}
catch [<error type] {<statement list>}
finally {<statement list>}
For
---
Définit une boucle à l'aide d'une condition.
Syntaxe :
for (<initialize>; <condition>; <iterate>) {<statement list>}
ForEach
-------
Définit une boucle à l'aide de chaque membre d'une collection.
Syntaxe :
ForEach (<item> in <collection>){<statement list>}
From
-----
Réservé pour une utilisation ultérieure.
Function
--------
Crée une liste d'instructions nommées de code réutilisable. Vous pouvez nommer la portée à laquelle appartient une fonction. De plus, vous pouvez spécifier un ou plusieurs paramètres nommés à l'aide du mot clé Param. Dans la liste d'instructions de la fonction, vous pouvez inclure les listes d'instructions DynamicParam, Begin, Process et End.
Syntaxe :
function [<scope:>]<name> {
param ([type]<$pname1> [, [type]<$pname2>])
DynamicParam {<statement list>}
begin {<statement list>}
process {<statement list>}
end {<statement list>}
}
Vous avez également la possibilité de définir un ou plusieurs paramètres en dehors de la liste d'instructions après le nom de fonction.
Syntaxe :
function [<scope:>]<name> [([type]<$pname1>, [[type]<$pname2>])] {
DynamicParam {<statement list>}
begin {<statement list>}
process {<statement list>}
end {<statement list>}
}
If
--
Définit une condition.
Syntaxe :
if (<condition>) {<statement list>}
In
--
Utilisé dans une instruction ForEach pour créer une boucle qui utilise chaque membre d'une collection.
Syntaxe :
ForEach (<item> in <collection>){<statement list>}
InlineScript
------------
Exécute des commandes de workflow dans une session Windows PowerShell partagée. Ce mot clé est valide uniquement dans un workflow Windows PowerShell.
Syntaxe :
workflow <verb>-<noun>
{
InlineScript
{
<Command/Expression>
...
}
}
Le mot clé InlineScript indique une activité InlineScript qui exécute des commandes dans une session standard partagée (et non-workflow). Vous pouvez utiliser le mot clé InlineScript pour exécuter des commandes qui, autrement, ne sont pas valides dans un workflow et pour exécuter des commandes qui partagent des données. Par défaut, les commandes dans un bloc de script InlineScript s'exécutent dans un processus séparé.
Pour plus d'informations, consultez about_InlineScript et Exécution de commandes Windows PowerShell dans un workflow (https://technet.microsoft.com/library/jj574197.aspx).
Param
-----
Définit les paramètres dans une fonction.
Syntaxe :
function [<scope:>]<name> {
param ([type]<$pname1>[, [[type]<$pname2>]])
<statement list>
}
Parallel
--------
Exécute des commandes de workflow simultanément et dans un ordre non défini. Ce mot clé est valide uniquement dans un workflow Windows PowerShell.
Le mot clé Parallel indique un bloc de script Parallel. Les commandes dans un bloc de script Parallel peuvent être exécutées simultanément et dans n'importe quel ordre. Cette fonctionnalité améliore considérablement les performances d'un workflow.
Syntaxe :
workflow <verb>-<noun>
{
Parallel
{
<Activity>
<Activity>
…
}
}
Le paramètre Parallel du mot clé ForEach traite les éléments dans une collection en parallèle. Les activités dans le bloc de script sont exécutées séquentiellement sur chaque élément, mais le bloc de script peut s'exécuter sur plusieurs éléments en même temps et les éléments sont traités dans un ordre non défini.
Syntaxe :
workflow <verb>-<noun>
{
ForEach -Parallel (<item> in <collection>)
{
<Activity>
<Activity>
...
}
}
Pour plus d'informations, consultez about_Parallel, about_ForEach-Parallel.
Process
-------
Spécifie une partie du corps d'une fonction, ainsi que les mots clés DynamicParam, Begin et End. Quand une liste d'instructions Process reçoit l'entrée du pipeline, la liste d'instructions Process s'exécute une fois pour chaque élément du pipeline. Si le pipeline ne fournit pas d'objets, la liste d'instructions Process n'est pas exécutée. Si la commande est la première commande dans le pipeline, la liste d'instructions Process s'exécute une fois.
Syntaxe :
function <name> {
DynamicParam {<statement list>}
begin {<statement list>}
process {<statement list>}
end {<statement list>}
}
Return
------
Provoque la sortie de Windows PowerShell de la portée actuelle, telle qu'un script ou une fonction, et écrit l'expression facultative dans la sortie.
Syntaxe :
return [<expression>]
Sequence
--------
Exécute des commandes de workflow séquentiellement dans un bloc de script Parallel. Ce mot clé est valide uniquement dans un workflow Windows PowerShell.
Syntaxe :
workflow <verb>-<noun>
{
Parallel
{
Sequence
{
<Activity>
}
}
}
Le mot clé Sequence crée un bloc séquentiel dans un bloc de script Parallel. Les commandes dans le bloc de script Sequence s'exécutent séquentiellement et dans l'ordre défini.
Pour plus d'informations, consultez about_Sequence.
Switch
------
Spécifie diverses actions à effectuer sur des éléments à partir du pipeline ou d'un fichier. Vous pouvez utiliser l'un des deux modèles de syntaxe suivants.
Syntaxe 1 :
switch [-regex|-wildcard|-exact][-casesensitive] ( pipeline )
{
<string>|<number>|<variable>|{ <expression> } {<statement list>}
<string>|<number>|<variable>|{ <expression> } {<statement list>}
...
default {<statement list>}
}
Syntaxe 2 :
switch [-regex|-wildcard|-exact][-casesensitive] -file filename
{
<string>|<number>|<variable>|{ <expression> } {<statement list>}
<string>|<number>|<variable>|{ <expression> } {<statement list>}
...
default {<statement list>}
}
Throw
-----
Lève un objet en tant qu'erreur.
Syntaxe :
throw [<object>]
Trap
----
Définit une liste d'instructions à exécuter si une erreur s'est produite. Un type d'erreur requiert des crochets. La deuxième paire de crochets indique que le type d'erreur est facultatif.
Syntaxe :
trap [[<error type>]] {<statement list>}
Try
---
Définit une liste d'instructions dans laquelle rechercher des erreurs pendant l'exécution des instructions. Si une erreur se produit, Windows PowerShell continue de s'exécuter dans une instruction Catch ou Finally. Un type d'erreur requiert des crochets. La deuxième paire de crochets indique que le type d'erreur est facultatif.
Syntaxe :
try {<statement list>}
catch [[<error type]] {<statement list>}
finally {<statement list>}
Until
-----
Utilisé dans une instruction Do comme construction de bouclage dans laquelle la liste d'instructions est exécutée au moins une fois.
Syntaxe :
do {<statement list>} until (<condition>)
While
-----
Utilisé dans une instruction Do comme construction de bouclage dans laquelle la liste d'instructions est exécutée au moins une fois.
Syntaxe :
do {<statement list>} while (<condition>)
Workflow
--------
Crée un workflow Windows PowerShell basé sur des scripts, autrement dit un workflow écrit en langage Windows PowerShell.
Un workflow Windows PowerShell est un type de commande Windows PowerShell pris en charge par Windows PowerShell et Windows Workflow Foundation. Les workflows sont conçus pour les tâches complexes et longues qui affectent plusieurs ordinateurs. Les workflows peuvent être récupérés en cas d'interruption, par exemple après une panne réseau, et vous pouvez les suspendre et les reprendre sans perte des données ni de l'état.
Les workflows peuvent être écrits en XAML, le langage natif de Windows Workflow Foundation, ou en langage Windows PowerShell.
La syntaxe d'un workflow basé sur des scripts est similaire à la syntaxe d'une fonction. Toutefois, l'unité d'exécution dans un workflow est une activité, et non une commande. Les applets de commande (et d'autres commandes) qui sont utilisées dans les workflows basés sur des scripts sont implicitement converties en activités.
Certains éléments de langage qui sont autorisés dans les scripts et les fonctions ne sont pas autorisés dans les workflows. De même, les workflows peuvent inclure des éléments qui ne figurent pas dans les scripts ni les fonctions, tels que les « points de persistance » (points de contrôle), la suspension automatique et le traitement parallèle. En outre, tous les workflows possèdent un ensemble de paramètres courants qui sont ajoutés par Windows PowerShell quand vous utilisez le mot clé Workflow.
Syntaxe :
workflow <Verb-Noun> {
param ([type]<$pname1> [, [type]<$pname2>])
<statement list>
}
workflow <verb-noun>
{
[CmdletBinding(<Attributes>)]
Param
(
[Parameter(<Arguments>)]
$Param1
)
<statement list>
}
Pour plus d'informations sur les workflows, consultez about_Workflows et « Présentation du workflow Windows PowerShell » (https://go.microsoft.com/fwlink/?LinkID=252592) dans la bibliothèque TechNet.
VOIR AUSSI
about_Escape_Characters
about_Special_Characters
about_Wildcards