about_Script_Blocks

  • Article

Description courte

Définit ce qu’est un bloc de script et explique comment utiliser des blocs de script dans le langage de programmation PowerShell.

Description longue

Dans le langage de programmation PowerShell, un bloc de script est une collection d’instructions ou d’expressions qui peuvent être utilisées en tant qu’unité unique. La collection d’instructions peut être placée entre accolades ({}), définie en tant que fonction ou enregistrée dans un fichier de script. Un bloc de script peut retourner des valeurs et accepter des paramètres et des arguments.

Syntacticalement, un bloc de script est une liste d’instructions dans les accolades, comme illustré dans la syntaxe suivante :

{<statement list>}

Un bloc de script retourne la sortie de toutes les commandes du bloc de script, en tant qu’objet unique ou en tant que tableau.

Vous pouvez également spécifier une valeur de retour à l’aide du return mot clé. Le return mot clé n’affecte pas ou ne supprime pas d’autres sorties retournées par votre bloc de script. Toutefois, le return mot clé quitte le bloc de script à cette ligne. Pour plus d’informations, consultez about_Return.

Comme les fonctions, un bloc de script peut inclure des paramètres. Utilisez le mot clé Param pour affecter des paramètres nommés, comme indiqué dans la syntaxe suivante :

{
    Param([type]$Parameter1 [,[type]$Parameter2])
    <statement list>
}

Remarque

Dans un bloc de script, contrairement à une fonction, vous ne pouvez pas spécifier de paramètres en dehors des accolades.

Comme les fonctions, les blocs de script peuvent inclure les mot clé, et end les dynamicparambeginprocessblocs de script. Pour plus d’informations, consultez about_Functions et about_Functions_Advanced.

Utilisation de blocs de script

Un bloc de script est une instance d’un type System.Management.Automation.ScriptBlockMicrosoft .NET Framework. Les commandes peuvent avoir des valeurs de paramètre de bloc de script. Par exemple, l’applet Invoke-Command de commande a un ScriptBlock paramètre qui prend une valeur de bloc de script, comme illustré dans cet exemple :

Invoke-Command -ScriptBlock { Get-Process }

Handles  NPM(K)    PM(K)     WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----     ----- -----   ------     -- -----------
999          28    39100     45020   262    15.88   1844 communicator
721          28    32696     36536   222    20.84   4028 explorer
...

Invoke-Command peut également exécuter des blocs de script qui ont des blocs de paramètres. Les paramètres sont attribués par position à l’aide du paramètre ArgumentList .

Invoke-Command -ScriptBlock { param($p1, $p2)
"p1: $p1"
"p2: $p2"
} -ArgumentList "First", "Second"

p1: First
p2: Second

Le bloc de script dans l’exemple précédent utilise la param mot clé pour créer des paramètres $p1 et $p2. La chaîne « First » est liée au premier paramètre ($p1) et « Second » est lié à ($p2).

Pour plus d’informations sur le comportement d’ArgumentList, consultez about_Splatting.

Vous pouvez utiliser des variables pour stocker et exécuter des blocs de script. L’exemple ci-dessous stocke un bloc de script dans une variable et le transmet à Invoke-Command.

$a = { Get-Service BITS }
Invoke-Command -ScriptBlock $a

Status   Name               DisplayName
------   ----               -----------
Running  BITS               Background Intelligent Transfer Ser...

L’opérateur d’appel est un autre moyen d’exécuter des blocs de script stockés dans une variable. Comme Invoke-Command, l’opérateur d’appel exécute le bloc de script dans une étendue enfant. L’opérateur d’appel peut faciliter l’utilisation des paramètres avec vos blocs de script.

$a ={ param($p1, $p2)
"p1: $p1"
"p2: $p2"
}
&$a -p2 "First" -p1 "Second"

p1: Second
p2: First

Vous pouvez stocker la sortie de vos blocs de script dans une variable à l’aide d’une affectation.

PS>  $a = { 1 + 1}
PS>  $b = &$a
PS>  $b
2

PS>  $a = { 1 + 1}
PS>  $b = Invoke-Command $a
PS>  $b
2

Pour plus d’informations sur l’opérateur d’appel, consultez about_Operators.

Utilisation de blocs de script de liaison différée avec des paramètres

Un paramètre typé qui accepte l’entrée de pipeline active l’utilisation de blocs de script de liaison différée sur le paramètre. Vous pouvez utiliser des blocs de script de liaison différée comme raccourci pour définir des paramètres pour une applet de commande pipeline avant de l’exécuter.

Dans le bloc de script de liaison différée, vous pouvez référencer le canal dans l’objet à l’aide de la variable $_de pipeline.

# Both examples rename config.log to old_config.log
# Without delay-binding
dir config.log | ForEach-Object -Process {
  Rename-Item -Path $_ -NewName "old_$($_.Name)"
}
# With delay-binding
dir config.log | Rename-Item -NewName { "old_$($_.Name)" }

Dans les applets de commande plus complexes, les blocs de script de liaison différé permettent la réutilisation d’un canal dans l’objet pour remplir d’autres paramètres.

Remarques sur les blocs de script de liaison différée en tant que paramètres :

  • Vous devez spécifier explicitement les noms de paramètres que vous utilisez avec des blocs de script de liaison différée.

  • Le paramètre ne doit pas être non typé et le type du paramètre ne peut pas être [scriptblock] ou [object].

  • Vous recevez une erreur si vous utilisez un bloc de script de liaison différée sans fournir d’entrée de pipeline.

    Rename-Item -NewName {$_.Name + ".old"}

    Rename-Item : Cannot evaluate parameter 'NewName' because its argument is
specified as a script block and there is no input. A script block cannot
be evaluated without input.
At line:1 char:23
+  Rename-Item -NewName {$_.Name + ".old"}
+                       ~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : MetadataError: (:) [Rename-Item],
      ParameterBindingException
    + FullyQualifiedErrorId : ScriptBlockArgumentNoInput,
      Microsoft.PowerShell.Commands.RenameItemCommand

Voir aussi