Comparteix via

about_Script_Blocks

Descripción breve

Define qué es un scriptblock y explica cómo usar los bloques de script en el lenguaje de programación de PowerShell.

Descripción larga

En el lenguaje de programación de PowerShell, un scriptblock es una colección de instrucciones o expresiones que se pueden usar como una sola unidad. La colección de instrucciones se puede incluir entre llaves ({}), definidas como una función o guardadas en un archivo de script. Un scriptblock puede devolver valores y aceptar parámetros y argumentos. Los bloques de scripts crean un nuevo ámbito para las variables.

Sintácticamente, un scriptblock es una lista de instrucciones entre llaves, como se muestra en la sintaxis siguiente:

{<statement list>}

Un scriptblock devuelve la salida de todos los comandos del scriptblock, ya sea como un solo objeto o como una matriz.

También puede especificar un valor devuelto mediante la return palabra clave . La return palabra clave no afecta ni suprime otra salida devuelta desde el scriptblock. Sin embargo, la return palabra clave sale del scriptblock en esa línea. Para obtener más información, consulte about_Return.

Al igual que las funciones, un scriptblock puede incluir parámetros. Use la palabra clave param para asignar parámetros con nombre, como se muestra en la sintaxis siguiente:

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

Al igual que las funciones, los bloques de script pueden incluir la dynamicparam instrucción y las begininstrucciones , processy end . Para obtener más información, consulte about_Functions y about_Functions_Advanced.

Importante

No todos los bloques entre llaves son bloques de script. Por ejemplo, los comandos de un for bucle o una if instrucción se incluyen en un bloque de instrucciones. Los bloques de instrucciones no crean un nuevo ámbito para variables, admiten parámetros de las otras palabras clave de instrucción.

Uso de scriptsblocks

Un scriptblock es una instancia de un tipo System.Management.Automation.ScriptBlockde Microsoft .NET Framework. Los comandos pueden tener valores de parámetro de scriptblock. Por ejemplo, el Invoke-Command cmdlet tiene un ScriptBlock parámetro que toma un valor de scriptblock, como se muestra en este ejemplo:

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 también puede ejecutar bloques de script que tienen bloques de parámetros. Los parámetros se asignan mediante la posición mediante el parámetro ArgumentList .

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

p1: First
p2: Second

El scriptblock del ejemplo anterior usa la param palabra clave para crear parámetros $p1 y $p2. La cadena "First" está enlazada al primer parámetro ($p1) y "Second" está enlazado a ($p2).

Para obtener más información sobre el comportamiento de ArgumentList, vea about_Splatting.

Puede usar variables para almacenar y ejecutar bloques de scripts. En el ejemplo siguiente se almacena un scriptblock en una variable y se pasa a Invoke-Command.

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

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

El operador de llamada es otra manera de ejecutar los bloques de script almacenados en una variable. Al igual que Invoke-Command, el operador de llamada ejecuta el scriptblock en un ámbito secundario. El operador de llamada puede facilitar el uso de parámetros con los bloques de script.

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

p1: Second
p2: First

Puede almacenar la salida de los bloques de script en una variable mediante la asignación.

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

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

Para obtener más información sobre el operador de llamada, consulte about_Operators.

Uso de scriptblocks de enlace retrasado con parámetros

Un parámetro con tipo que acepta la entrada de canalización permite el uso de los bloques de script de enlace retrasado en el parámetro . Puede usar scriptblocks de enlace retrasado como abreviatura para definir parámetros para un cmdlet canalización antes de ejecutarlo.

Dentro del scriptblock de enlace retrasado, puede hacer referencia al canalización en el objeto mediante la variable $_de canalización .

# 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)" }

En cmdlets más complejos, los bloqueos de script de enlace retrasado permiten la reutilización de un canalización en el objeto para rellenar otros parámetros.

Notas sobre los bloques de scripts de enlace retrasado como parámetros:

  • Debe especificar explícitamente los nombres de parámetro que use con los bloques de script de enlace retrasado.

  • El parámetro no debe estar sin tipo y el tipo del parámetro no puede ser [scriptblock] ni [Object].

  • Recibirá un error si usa un scriptblock de enlace retrasado sin proporcionar entrada de canalización.

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

    Rename-Item : Cannot evaluate parameter 'NewName' because its argument is
specified as a scriptblock and there is no input. A scriptblock 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 también

  • Last updated on