about_Script_Blocks

  • Artigo

Breve descrição

Define o que é um bloco de script e explica como usar blocos de script na linguagem de programação do PowerShell.

Descrição longa

Na linguagem de programação do PowerShell, um bloco de script é uma coleção de instruções ou expressões que podem ser usadas como uma única unidade. A coleção de instruções pode ser incluída entre chaves ({}), definida como uma função, ou salva em um arquivo de script. Um bloco de script pode retornar valores e aceitar parâmetros e argumentos.

Sintaticamente, um bloco de script é uma lista de instruções em chaves, como mostrado na sintaxe a seguir:

{<statement list>}

Um bloco de script retorna a saída de todos os comandos no bloco de script, como um único objeto ou como uma matriz.

Você também pode especificar um valor de retorno usando a palavra-chave return . A return palavra-chave não afeta nem suprime outras saídas retornadas do seu bloco de script. No entanto, a return palavra-chave sai do bloco de script nessa linha. Para obter mais informações, consulte about_Return.

Como funções, um bloco de script pode incluir parâmetros. Use a palavra-chave Param para atribuir parâmetros nomeados, conforme mostrado na sintaxe a seguir:

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

Nota

Em um bloco de script, ao contrário de uma função, você não pode especificar parâmetros fora das chaves.

Como as funções, os blocos de script podem incluir as DynamicParampalavras-chave , Begin, Process, e End . Para obter mais informações, consulte about_Functions e about_Functions_Advanced.

Usando blocos de script

Um bloco de script é uma instância de um tipo System.Management.Automation.ScriptBlockdo Microsoft .NET Framework . Os comandos podem ter valores de parâmetros de bloco de script. Por exemplo, o Invoke-Command cmdlet tem um ScriptBlock parâmetro que usa um valor de bloco de script, conforme mostrado neste exemplo:

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 Também pode executar blocos de script que tenham blocos de parâmetro. Os parâmetros são atribuídos por posição usando o parâmetro ArgumentList .

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

p1: First
p2: Second

O bloco de script no exemplo anterior usa a param palavra-chave para criar parâmetros $p1 e $p2. A string "First" está vinculada ao primeiro parâmetro ($p1) e "Second" está vinculada a ($p2).

Para obter mais informações sobre o comportamento de ArgumentList, consulte about_Splatting.

Você pode usar variáveis para armazenar e executar blocos de script. O exemplo abaixo armazena um bloco de script em uma variável e o passa para Invoke-Command.

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

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

O operador de chamada é outra maneira de executar blocos de script armazenados em uma variável. Como Invoke-Command, o operador de chamada executa o bloco de script em um escopo filho. O operador de chamada pode facilitar o uso de parâmetros com seus blocos de script.

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

p1: Second
p2: First

Você pode armazenar a saída de seus blocos de script em uma variável usando a atribuição.

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

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

Para obter mais informações sobre o operador de chamada, consulte about_Operators.

Usando blocos de script de vinculação de atraso com parâmetros

Um parâmetro tipado que aceita entrada de pipeline permite o uso de blocos de script de ligação de atraso no parâmetro. Você pode usar blocos de script de vinculação de atraso como uma abreviação para definir parâmetros para um cmdlet pipelined antes de executá-lo.

Dentro do bloco de script delay-bind, você pode fazer referência ao objeto canalizado usando a variável $_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)" }

Em cmdlets mais complexos, os blocos de script de vinculação de atraso permitem a reutilização de um objeto canalizado para preencher outros parâmetros.

Notas sobre blocos de script de vinculação de atraso como parâmetros:

  • Você deve especificar explicitamente quaisquer nomes de parâmetros usados com blocos de script de vinculação de atraso.

  • O parâmetro não deve ser destipado e o tipo do parâmetro não pode ser [scriptblock] ou [object].

  • Você recebe um erro se usar um bloco de script de vinculação de atraso sem fornecer entrada 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

Consulte também