about_Script_Blocks

  • Artikel

Kurze Beschreibung

Definiert, was ein Skriptblock ist, und erläutert, wie Skriptblöcke in der PowerShell-Programmiersprache verwendet werden.

Lange Beschreibung

In der PowerShell-Programmiersprache ist ein Skriptblock eine Sammlung von Anweisungen oder Ausdrücken, die als einzelne Einheit verwendet werden können. Die Sammlung von Anweisungen kann in geschweifte Klammern ({}), als Funktion definiert oder in einer Skriptdatei gespeichert werden. Ein Skriptblock kann Werte zurückgeben und Parameter und Argumente akzeptieren.

Syntaktisch ist ein Skriptblock eine Anweisungsliste in geschweiften Klammern, wie in der folgenden Syntax dargestellt:

{<statement list>}

Ein Skriptblock gibt die Ausgabe aller Befehle im Skriptblock als einzelnes Objekt oder als Array zurück.

Sie können auch einen Rückgabewert mithilfe der return Schlüsselwort (keyword) angeben. Die return Schlüsselwort (keyword) wirkt sich nicht auf andere ausgaben aus, die von Ihrem Skriptblock zurückgegeben werden, oder unterdrückt sie. Der return Schlüsselwort (keyword) beendet jedoch den Skriptblock in dieser Zeile. Weitere Informationen finden Sie unter about_Return.

Wie Funktionen kann ein Skriptblock Parameter enthalten. Verwenden Sie die Param-Schlüsselwort (keyword), um benannte Parameter zuzuweisen, wie in der folgenden Syntax dargestellt:

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

Hinweis

In einem Skriptblock können Sie im Gegensatz zu einer Funktion keine Parameter außerhalb der geschweiften Klammern angeben.

Wie Funktionen können Skriptblöcke die DynamicParam, Begin, Process, und End Schlüsselwort (keyword) enthalten. Weitere Informationen finden Sie unter about_Functions und about_Functions_Advanced.

Verwenden von Skriptblöcken

Ein Skriptblock ist eine Instanz eines Microsoft .NET Framework-Typs System.Management.Automation.ScriptBlock. Befehle können Skriptblockparameterwerte enthalten. Das Cmdlet verfügt beispielsweise über einen ScriptBlock Parameter, der Invoke-Command einen Skriptblockwert verwendet, wie in diesem Beispiel gezeigt:

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 kann auch Skriptblöcke mit Parameterblöcken ausführen. Parameter werden mithilfe des ArgumentList-Parameters nach Position zugewiesen.

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

p1: First
p2: Second

Der Skriptblock im vorherigen Beispiel verwendet die param Schlüsselwort (keyword) zum Erstellen von Parametern $p1 und $p2. Die Zeichenfolge "First" ist an den ersten Parameter ($p1) gebunden, und "Second" ist an ($p2) gebunden.

Weitere Informationen zum Verhalten von ArgumentList finden Sie unter about_Splatting.

Sie können Variablen verwenden, um Skriptblöcke zu speichern und auszuführen. Im folgenden Beispiel wird ein Skriptblock in einer Variablen gespeichert und an Invoke-Commanddiese übergeben.

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

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

Der Aufrufoperator ist eine weitere Möglichkeit zum Ausführen von Skriptblöcken, die in einer Variablen gespeichert sind. Wie Invoke-Commandfolgt führt der Aufrufoperator den Skriptblock in einem untergeordneten Bereich aus. Der Aufrufoperator kann ihnen die Verwendung von Parametern mit Ihren Skriptblöcken erleichtern.

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

p1: Second
p2: First

Sie können die Ausgabe aus Ihren Skriptblöcken mithilfe der Zuweisung in einer Variablen speichern.

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

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

Weitere Informationen zum Anrufanbieter finden Sie unter about_Operators.

Verwenden von Verzögerungsbindungsskriptblöcken mit Parametern

Ein typierter Parameter, der Pipelineeingaben akzeptiert, ermöglicht die Verwendung von Verzögerungsbindungsskriptblöcken für den Parameter. Sie können Skriptblöcke mit Verzögerungsbindung als Kurzform verwenden, um Parameter für ein weitergeleitetes Cmdlet zu definieren, bevor Sie es ausführen.

Innerhalb des Verzögerungsbindungsskriptblocks können Sie mithilfe der Pipelinevariablen $_auf das weitergeleitete Objekt verweisen.

# 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 komplexeren Cmdlets ermöglichen Verzögerungsbindungsskriptblöcke die Wiederverwendung eines weitergeleiteten Objekts, um andere Parameter aufzufüllen.

Hinweise zu Verzögerungsbindungsskriptblöcken als Parameter:

  • Sie müssen explizit alle Parameternamen angeben, die Sie mit Verzögerungsbindungsskriptblöcken verwenden.

  • Der Parameter darf nicht eingegeben werden, und der Typ des Parameters kann nicht sein [scriptblock] oder [object].

  • Wenn Sie einen Verzögerungsbindungsskriptblock verwenden, ohne Pipelineeingaben bereitzustellen, wird eine Fehlermeldung angezeigt.

    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

Weitere Informationen