about_Script_Blocks
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 Auflistung von Anweisungen kann in Klammern () eingeschlossen,{}
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 Klammern, wie in der folgenden Syntax gezeigt:
{<statement list>}
Ein Skriptblock gibt die Ausgabe aller Befehle im Skriptblock zurück, entweder als einzelnes Objekt oder als Array.
Sie können auch einen Rückgabewert mithilfe des return
Schlüsselwort (keyword) angeben. Die return
Schlüsselwort (keyword) wirkt sich nicht auf andere Ausgaben aus Ihrem Skriptblock aus oder unterdrückt sie nicht. 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 gezeigt:
{
Param([type]$Parameter1 [,[type]$Parameter2])
<statement list>
}
Hinweis
In einem Skriptblock können Sie im Gegensatz zu einer Funktion keine Parameter außerhalb der Klammern angeben.
Wie Funktionen können Skriptblöcke die DynamicParam
Schlüsselwörter , Begin
, Process
und End
enthalten. Weitere Informationen finden Sie unter about_Functions und about_Functions_Advanced.
Verwenden von Skriptblöcken
Ein Skriptblock ist ein instance eines Microsoft-.NET Framework-TypsSystem.Management.Automation.ScriptBlock
. Befehle können Skriptblockparameterwerte aufweisen. Das Cmdlet verfügt beispielsweise über einen ScriptBlock
Parameter, der Invoke-Command
einen Skriptblockwert annimmt, 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
) und "Second" 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-Command
ü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-Command
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 Ihrer Skriptblöcke 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 Aufrufoperator finden Sie unter about_Operators.
Verwenden von Verzögerungsbindungsskriptblöcken mit Parametern
Ein typisierter Parameter, der die Pipelineeingabe akzeptiert, ermöglicht die Verwendung von Verzögerungsbindungsskriptblöcken für den Parameter. Sie können Verzögerungsbindungsskriptblöcke als Kurzform verwenden, um Parameter für ein pipelinefähiges Cmdlet zu definieren, bevor Sie es ausführen.
Im Skriptblock delay-bind können Sie mithilfe der Pipelinevariablen $_
auf das piped in -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 In-Pipe-Objekts, um andere Parameter aufzufüllen.
Hinweise zu Verzögerungsbindungsskriptblöcken als Parameter:
Sie müssen alle Parameternamen explizit angeben, die Sie mit Verzögerungsbindungsskriptblöcken verwenden.
Der Parameter darf nicht nicht typisiert sein, und der Typ des Parameters kann nicht oder
[object]
sein[scriptblock]
.Sie erhalten eine Fehlermeldung, wenn Sie einen Verzögerungsbindungsskriptblock verwenden, ohne Pipelineeingaben bereitzustellen.
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