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