about_Script_Blocks

Korte beschrijving

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

Lange beschrijving

In de Programmeertaal PowerShell is een scriptblock 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. Scriptblocks maken een nieuw bereik voor variabelen.

Syntactisch is een scriptblock 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>
}

Net als functies kunnen scriptblokkeringen de dynamicparam instructie en de begin, processen end instructies bevatten. Zie about_Functions en about_Functions_Advanced voor meer informatie.

Scriptblocks gebruiken

Een scriptblok is een exemplaar van een Microsoft .NET Framework-type System.Management.Automation.ScriptBlock. Opdrachten kunnen parameterwaarden voor scriptblock 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 scriptblocks 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

In het scriptblok in het voorgaande voorbeeld wordt het param trefwoord gebruikt 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 scriptblokkeringen 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 scriptblokkeringen uit te voeren die zijn opgeslagen in een variabele. De Invoke-Commandaanroepoperator voert bijvoorbeeld het scriptblok uit in een onderliggend bereik. Met de aanroepoperator kunt u eenvoudiger parameters gebruiken met uw scriptblokkeringen.

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

p1: Second
p2: First

U kunt de uitvoer van uw scriptblokkeringen 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.

Scriptblokkeringen voor vertragingsbinding gebruiken met parameters

Een getypte parameter die pijplijninvoer accepteert, maakt het gebruik van scriptblokkeringen voor vertragingsbinding op de parameter mogelijk. U kunt scriptblokkeringen voor vertragingsbinding gebruiken als een afkorting om parameters voor een cmdlet met pijplijn 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 scriptblokkeringen voor vertragingsbindingen het hergebruik van één piped in object andere parameters invullen.

Opmerkingen over scriptblokkeringen voor vertragingsbinding als parameters:

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

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

• U ontvangt een foutmelding 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 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
  

Zie ook

• about_Functions
• about_Functions_Advanced
• about_Operators