about_Script_Blocks

  • Artikel

Korte beschrijving

Definieert wat een scriptblok is en legt uit hoe u scriptblokken gebruikt in de Programmeertaal PowerShell.

Lange beschrijving

In de Programmeertaal PowerShell is een scriptblok een verzameling instructies of expressies die als één eenheid kunnen worden gebruikt. De verzameling instructies kan tussen accolades ({}), gedefinieerd als een functie of worden opgeslagen in een scriptbestand. Een scriptblok kan waarden retourneren en parameters en argumenten accepteren.

Syntactisch is een scriptblok een instructielijst in accolades, zoals wordt weergegeven in de volgende syntaxis:

{<statement list>}

Een scriptblok retourneert de uitvoer van alle opdrachten in het scriptblok, hetzij als één object of als een matrix.

U kunt ook een retourwaarde opgeven met behulp van het return trefwoord. Het return trefwoord heeft geen invloed op of onderdrukt andere uitvoer die wordt geretourneerd vanuit uw scriptblok. Het return trefwoord sluit echter het scriptblok op die regel af. Zie about_Return voor meer informatie.

Net als functies kan een scriptblok parameters bevatten. Gebruik het trefwoord Param om benoemde parameters toe te wijzen, zoals wordt weergegeven in de volgende syntaxis:

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

Notitie

In een scriptblok kunt u, in tegenstelling tot een functie, geen parameters opgeven buiten de accolades.

Net als functies kunnen scriptblokken de DynamicParamtrefwoorden , Beginen ProcessEnd trefwoorden bevatten. Zie about_Functions en about_Functions_Advanced voor meer informatie.

Scriptblokken gebruiken

Een scriptblok is een exemplaar van een Microsoft .NET Framework-type System.Management.Automation.ScriptBlock. Opdrachten kunnen parameterwaarden voor scriptblokken bevatten. De Invoke-Command cmdlet heeft bijvoorbeeld een parameter die een ScriptBlock scriptblokwaarde gebruikt, zoals wordt weergegeven in dit voorbeeld:

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 kan ook scriptblokken uitvoeren die parameterblokken bevatten. Parameters worden toegewezen met behulp van de parameter ArgumentList .

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

p1: First
p2: Second

Het scriptblok in het voorgaande voorbeeld gebruikt het param trefwoord om een parameters $p1 te maken en $p2. De tekenreeks 'Eerste' is gebonden aan de eerste parameter ($p1) en 'Second' is gebonden aan ($p2).

Zie about_Splatting voor meer informatie over het gedrag van ArgumentList.

U kunt variabelen gebruiken om scriptblokken op te slaan en uit te voeren. In het onderstaande voorbeeld wordt een scriptblok in een variabele opgeslagen en doorgegeven aan Invoke-Command.

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

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

De aanroepoperator is een andere manier om scriptblokken uit te voeren die zijn opgeslagen in een variabele. De aanroepoperator voert het scriptblok in Invoke-Commandeen onderliggend bereik uit. Met de aanroepoperator kunt u eenvoudiger parameters gebruiken met uw scriptblokken.

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

p1: Second
p2: First

U kunt de uitvoer van uw scriptblokken opslaan in een variabele met behulp van toewijzing.

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

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

Zie about_Operators voor meer informatie over de oproepoperator.

Scriptblokken voor vertragingsbinding gebruiken met parameters

Een getypte parameter die pijplijninvoer accepteert, maakt het gebruik van vertragingsbindingsscriptblokken voor de parameter mogelijk. U kunt scriptblokken voor vertragingsbinding gebruiken als een afkorting om parameters voor een pijplijn-cmdlet te definiëren voordat u deze uitvoert.

In het scriptblok voor vertragingsbinding kunt u verwijzen naar het object met behulp van de pijplijnvariabele $_.

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

In complexere cmdlets kunnen scriptblokken met delay-bind het hergebruik van één piped in object andere parameters invullen.

Opmerkingen over vertragingsbindingsscriptblokken als parameters:

  • U moet expliciet parameternamen opgeven die u gebruikt met scriptblokken voor vertragingsbinding.

  • De parameter mag niet ongedaan worden getypt en het type van de parameter kan niet of [scriptblock][object].

  • Er wordt een foutbericht weergegeven als u een scriptblok voor vertragingsbinding gebruikt zonder pijplijninvoer op te geven.

    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

Zie ook