Freigeben über

about_Functions

Kurzbeschreibung

Beschreibt, wie Funktionen in PowerShell erstellt und verwendet werden.

Lange Beschreibung

Eine Funktion ist eine Liste von PowerShell-Anweisungen mit einem Namen, den Sie zuweisen. Wenn Sie eine Funktion ausführen, geben Sie den Funktionsnamen ein.

PowerShell definiert zwei Arten von Funktionen:

  • Eine Funktion ist ein Codeblock, der anhand des Namens aufgerufen werden kann. Es kann Eingaben annehmen und Ausgabe zurückgeben. Funktionen werden mithilfe des Schlüsselworts function definiert.
  • Ein Filter ist ein Funktionstyp, der zum Verarbeiten von Daten aus der Pipeline entwickelt wurde. Filter werden mithilfe des Schlüsselworts filter definiert.

Sie können die Anweisungen in einer Funktion in einem von vier verschiedenen vordefinierten Anweisungsblöcken gruppieren. Diese Anweisungsblöcke werden mithilfe der Schlüsselwörter begin, , process, endund clean. Wenn Sie diese Schlüsselwörter nicht verwenden, fügt PowerShell die Anweisungen in den entsprechenden Codeblock ein.

Funktionen können auch wie Cmdlets funktionieren. Sie können eine Funktion erstellen, die wie ein Cmdlet funktioniert, ohne C# Programmierung zu verwenden. Weitere Informationen finden Sie unter about_Functions_Advanced.

Wichtig

Innerhalb von Skriptdateien und skriptbasierten Modulen müssen Funktionen definiert werden, bevor sie aufgerufen werden können.

Funktionssyntax

Funktionen werden mithilfe der folgenden Syntax definiert:

function [<scope:>]<name> {
  param([type]$Parameter1 [,[type]$Parameter2])
  dynamicparam {<statement list>}
  begin {<statement list>}
  process {<statement list>}
  end {<statement list>}
  clean {<statement list>}
}

Eine Funktion enthält die folgenden Elemente:

  • Ein function Schlüsselwort
  • Ein Bereich (optional)
  • Ein Name, den Sie auswählen
  • Beliebig viele benannte Parameter (optional), einschließlich dynamischer Parameter
  • Mindestens eine PowerShell-Anweisung, die in geschweifte Klammern eingeschlossen ist {}

Wenn Sie eines der Schlüsselwörter (, , , begin) nicht in einer process Definition verwenden, fügt PowerShell die Anweisungen in den end Block cleanein. functionend

Weitere Informationen zu den dynamicparam Schlüsselwort und dynamischen Parametern in Funktionen finden Sie unter about_Functions_Advanced_Parameters.

Eine Funktion kann so einfach sein wie:

function Get-PowerShellProcess { Get-Process pwsh }

Sobald eine Funktion definiert ist, können Sie sie wie die integrierten Cmdlets verwenden. Um beispielsweise die neu definierte Get-PowerShellProcess-Funktion aufzurufen:

Get-PowerShellProcess

 NPM(K)    PM(M)      WS(M)     CPU(s)      Id  SI ProcessName
 ------    -----      -----     ------      --  -- -----------
    110    78.72     172.39      10.62   10936   1 pwsh

Eine Funktion kann auch so komplex wie ein Cmdlet sein.

Funktionen können Werte zurückgeben, die angezeigt, Variablen zugewiesen oder an andere Funktionen oder Cmdlets übergeben werden können. Sie können das Schlüsselwort verwenden, um die return Ausgabe zurückzugeben. Das schlüsselwort return wirkt sich nicht auf die von Ihrer Funktion zurückgegebene ausgabe aus oder unterdrückt sie nicht. Das schlüsselwort return beendet jedoch die Funktion in dieser Zeile. Weitere Informationen finden Sie unter about_Return.

Filtersyntax

Die Absicht der filter Funktion besteht darin, eine kurze Möglichkeit zum Definieren einer Funktion bereitzustellen, die für jedes Objekt in der Pipeline ausgeführt wird.

Die Syntax eines Filters lautet wie folgt:

filter [<scope:>]<name> {<statement list>}

Um die Syntax für filter Funktionen zu vereinfachen, lassen Sie das Schlüsselwort des Anweisungsblocks (begin, process, , end). clean PowerShell fügt die Anweisungen in den process Block ein. Sie können jeden der anderen Blöcke in einer Filterfunktion verwenden, aber die Absicht bestand darin, eine Kurzform zum Definieren einer Funktion bereitzustellen, die den alleinigen Zweck hat, jedes Objekt in der Pipeline zu verarbeiten.

Der folgende Filter akzeptiert Protokolleinträge aus der Pipeline und zeigt dann entweder den gesamten Eintrag oder nur den Nachrichtenteil des Eintrags an:

filter Get-EventMessage ([switch]$MessageOnly) {
  if ($MessageOnly) { Out-Host -InputObject $_.Message }
  else { $_ }
}

Sie kann wie folgt verwendet werden:

Get-WinEvent -LogName System -MaxEvents 100 | Get-EventMessage -MessageOnly

Eingabeverarbeitungsmethoden

Die in diesem Abschnitt beschriebenen Methoden werden als Eingabeverarbeitungsmethoden bezeichnet. Bei Funktionen werden diese drei Methoden mit dem beginNamen ", process" und end "Blöcken" der Funktion benannt. PowerShell 7.3 fügt eine clean Blockprozessmethode hinzu.

Sie müssen keine dieser Blöcke in Ihren Funktionen verwenden. Wenn Sie keinen benannten Block verwenden, fügt PowerShell den Code in den end Block der Funktion ein. Wenn Sie jedoch einen dieser benannten Blöcke verwenden oder einen dynamicparam-Block definieren, müssen Sie den gesamten Code in einen benannten Block einfügen.

Das folgende Beispiel zeigt die Gliederung einer Funktion, die einen begin Block für einmalige Vorverarbeitung, einen process Block aus der Pipeline und einen end Block für einmalige Nachbearbeitung enthält.

Function Test-ScriptCmdlet {
    [CmdletBinding(SupportsShouldProcess=$true)]
    param ($Parameter1)
    begin{}
    process{}
    end{}
}

begin

Dieser Block wird verwendet, um optionale einmalige Vorverarbeitung für die Funktion bereitzustellen. Die PowerShell-Laufzeit verwendet den Code in diesem Block einmal für jede Instanz der Funktion in der Pipeline.

process

Dieser Block wird verwendet, um die Datensatz-nach-Datensatz-Verarbeitung für die Funktion bereitzustellen. Sie können einen process-Block verwenden, ohne die anderen Blöcke zu definieren. Die Anzahl der process Blockausführungen hängt davon ab, wie Sie die Funktion verwenden und welche Eingabe die Funktion empfängt.

Die automatische Variable $_ oder $PSItem enthält das aktuelle Objekt in der Pipeline für die Verwendung im process-Block. Die $input automatische Variable enthält einen Enumerator, der nur für Funktionen und Scriptblocks verfügbar ist. Weitere Informationen finden Sie unter about_Automatic_Variables.

  • Wenn die Funktion ohne Pipelineeingabe aufgerufen wird, führt PowerShell den process Block nur einmal aus.
  • Innerhalb einer Pipeline wird der process-Block einmal für jedes Eingabeobjekt ausgeführt, das die Funktion erreicht.
  • Wenn die Pipelineeingabe, die die Funktion erreicht, leer ist, wird der process Block nicht ausgeführt.
    • Die begin- und end- und clean-Blöcke werden weiterhin ausgeführt.

Wichtig

Wenn ein Funktionsparameter Pipelineeingaben akzeptiert und kein process Block definiert ist, schlägt die Datensatz-nach-Datensatz-Verarbeitung fehl. In diesem Fall wird Ihre Funktion nur einmal ausgeführt, unabhängig von der Eingabe.

end

Verwenden Sie diesen Block, um optionale einmalige Nachbearbeitung für die Funktion bereitzustellen.

clean

Der clean-Block wurde in PowerShell 7.3 hinzugefügt.

Der clean-Block ist eine bequeme Möglichkeit, um Ressourcen zu bereinigen, die sich über die begin, processund end-Blöcke erstrecken. Es ähnelt semantisch einem finally-Block, der alle anderen benannten Blöcke einer Skriptfunktion oder eines Skript-Cmdlets abdeckt. Die Ressourcenbereinigung wird für die folgenden Szenarien erzwungen:

  1. wenn die Pipelineausführung abgeschlossen ist, ohne den Fehler zu beenden
  2. wenn die Pipelineausführung aufgrund eines Beendigungsfehlers unterbrochen wird
  3. wenn die Pipeline abgeschnitten wird, z. B.: Select-Object -First
  4. wenn die Pipeline durch STRG+c oder StopProcessing()

Der saubere Block verwirft alle Ausgaben, die in den Erfolgsdatenstrom geschrieben wurden.

Vorsicht

Das Hinzufügen des clean Blocks ist eine bahnbrechende Änderung. Da clean als Schlüsselwort analysiert wird, wird verhindert, dass Benutzer direkt einen Befehl aufrufen, der als erste Anweisung in einem Scriptblock bezeichnet clean wird. Es ist jedoch kein Problem. Sie können den Befehl weiterhin über den Aufrufoperator (& clean) aufrufen.

Einfache Funktionen

Funktionen müssen nicht kompliziert sein, um nützlich zu sein. Die einfachsten Funktionen weisen das folgende Format auf:

function <function-name> { statements }

Die folgende Funktion startet beispielsweise PowerShell mit der Option Als Administrator ausführen.

function Start-PSAdmin { Start-Process PowerShell -Verb RunAs }

Um die Funktion zu verwenden, geben Sie Folgendes ein: Start-PSAdmin

Wenn Sie der Funktion Anweisungen hinzufügen möchten, geben Sie jede Anweisung in eine separate Zeile ein, oder verwenden Sie ein Semikolon (;) zum Trennen der Anweisungen.

Die folgende Funktion findet beispielsweise alle .jpg Dateien in den Verzeichnissen des aktuellen Benutzers, die nach dem Startdatum geändert wurden.

function Get-NewPicture {
  $start = Get-Date -Month 1 -Day 1 -Year 2010
  $allPics = Get-ChildItem -Path $Env:USERPROFILE\*.jpg -Recurse
  $allPics | Where-Object {$_.LastWriteTime -gt $Start}
}

Sie können eine Toolbox mit nützlichen kleinen Funktionen erstellen. Fügen Sie diese Funktionen ihrem PowerShell-Profil hinzu, wie in about_Profiles und höher in diesem Artikel beschrieben.

Funktionsnamen

Sie können einer Funktion einen beliebigen Namen zuweisen. Bei Funktionen, die Sie für andere Personen freigeben, sollten Sie jedoch die standardmäßigen PowerShell-Benennungsregeln befolgen.

  • Namen sollten aus einem Verben-Nomenpaar bestehen, bei dem das Verb die von der Funktion ausgeführte Aktion identifiziert, und das Substantiv identifiziert das Element, für das das Cmdlet die Aktion ausführt.
  • Namen sollten die genehmigten Verben für alle PowerShell-Befehle verwenden. Die Verwendung genehmigter Verben schafft Konsistenz für Benutzer.

Weitere Informationen zu den Standard-PowerShell-Verben finden Sie unter genehmigten Verben.

Funktionen mit Parametern

Sie können Parameter mit Funktionen verwenden, einschließlich benannter Parameter, Positionsparameter, Schalterparameter und dynamischer Parameter. Weitere Informationen zu dynamischen Parametern in Funktionen finden Sie unter about_Functions_Advanced_Parameters.

Benannte Parameter

Sie können eine beliebige Anzahl benannter Parameter definieren. Sie können einen Standardwert für benannte Parameter angeben, wie weiter unten in diesem Artikel beschrieben.

Sie können Parameter in den geschweiften Klammern mithilfe des schlüsselworts param definieren, wie in der folgenden Beispielsyntax gezeigt:

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

Sie können Parameter auch außerhalb der geschweiften Klammern ohne das schlüsselwort param definieren, wie in der folgenden Beispielsyntax dargestellt:

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

Die folgende Funktion verwendet beispielsweise die alternative Syntax, um zwei Parameter zu definieren:

function Add-Numbers([int]$One, [int]$Two) {
    $One + $Two
}

Während die erste Methode bevorzugt wird, gibt es keinen Unterschied zwischen diesen beiden Methoden.

Wenn Sie die Funktion ausführen, wird der wert, den Sie für einen Parameter angeben, einer Variablen zugewiesen, die den Parameternamen enthält. Der Wert dieser Variablen kann in der Funktion verwendet werden.

Das folgende Beispiel ist eine Funktion namens Get-SmallFiles. Diese Funktion weist einen $Size-Parameter auf. Die Funktion zeigt alle Dateien an, die kleiner als der Wert des $Size Parameters sind, und schließt Verzeichnisse aus:

function Get-SmallFiles {
  param ($Size)
  Get-ChildItem $HOME | Where-Object {
    $_.Length -lt $Size -and !$_.PSIsContainer
  }
}

In der Funktion können Sie die $Size Variable verwenden, bei der es sich um den für den Parameter definierten Namen handelt.

Geben Sie den folgenden Befehl ein, um diese Funktion zu verwenden:

Get-SmallFiles -Size 50

Sie können auch einen Wert für einen benannten Parameter ohne den Parameternamen eingeben. Der folgende Befehl gibt z. B. dasselbe Ergebnis wie ein Befehl, der den Parameter Size benennt:

Get-SmallFiles 50

Um einen Standardwert für einen Parameter zu definieren, geben Sie ein Gleichheitszeichen und den Wert nach dem Parameternamen ein, wie in der folgenden Variation des Get-SmallFiles Beispiels gezeigt:

function Get-SmallFiles ($Size = 100) {
  Get-ChildItem $HOME | Where-Object {
    $_.Length -lt $Size -and !$_.PSIsContainer
  }
}

Wenn Sie Get-SmallFiles ohne Wert eingeben, weist die Funktion $size100 zu. Wenn Sie einen Wert angeben, verwendet die Funktion diesen Wert.

Optional können Sie eine kurze Hilfezeichenfolge bereitstellen, die den Standardwert Ihres Parameters beschreibt, indem Sie das PSDefaultValue-attribut zur Beschreibung Des Parameters hinzufügen und die Help-Eigenschaft von PSDefaultValueangeben. Um eine Hilfezeichenfolge bereitzustellen, die den Standardwert (100) des parameters Size in der funktion Get-SmallFiles beschreibt, fügen Sie das PSDefaultValue Attribut hinzu, wie im folgenden Beispiel gezeigt.

function Get-SmallFiles {
  param (
      [PSDefaultValue(Help = '100')]
      $Size = 100
  )
  Get-ChildItem $HOME | Where-Object {
    $_.Length -lt $Size -and !$_.PSIsContainer
  }
}

Weitere Informationen zur PSDefaultValue-attributklasse finden Sie unter PSDefaultValue-Attributmber.

Positionsparameter

Ein Positionsparameter ist ein Parameter ohne Parameternamen. PowerShell verwendet die Parameterwertreihenfolge, um jeden Parameterwert einem Parameter in der Funktion zuzuordnen.

Wenn Sie Positionsparameter verwenden, geben Sie nach dem Funktionsnamen einen oder mehrere Werte ein. Positionsparameterwerte werden der $args Arrayvariablen zugewiesen. Der Wert, der auf den Funktionsnamen folgt, wird der ersten Position im $args Array $args[0]zugewiesen.

Die folgende Get-Extension-Funktion fügt die .txt Dateinamenerweiterung zu einem von Ihnen angegebenen Dateinamen hinzu:

function Get-Extension {
  $name = $args[0] + ".txt"
  $name
}

Get-Extension myTextFile

myTextFile.txt

Parameter wechseln

Ein Schalter ist ein Parameter, der keinen Wert erfordert. Stattdessen geben Sie den Funktionsnamen gefolgt vom Namen des Switch-Parameters ein.

Um einen Switch-Parameter zu definieren, geben Sie den Typ [switch] vor dem Parameternamen an, wie im folgenden Beispiel gezeigt:

function Switch-Item {
  param ([switch]$On)
  if ($On) { "Switch on" }
  else { "Switch off" }
}

Wenn Sie den Parameter On Schalter nach dem Funktionsnamen eingeben, wird Switch onangezeigt. Ohne den Schalterparameter wird Switch offangezeigt.

Switch-Item -On

Switch on

Switch-Item

Switch off

Sie können einem Schalter auch einen booleschen Wert zuweisen, wenn Sie die Funktion ausführen, wie im folgenden Beispiel gezeigt:

Switch-Item -On:$true

Switch on

Switch-Item -On:$false

Switch off

Verwenden von Splatting zum Übergeben von Parameterwerten

Sie können splatting verwenden, um die Parameter eines Befehls darzustellen. Dieses Feature wird in Windows PowerShell 3.0 eingeführt.

Verwenden Sie diese Technik in Funktionen, die Befehle in der Sitzung aufrufen. Sie müssen die Befehlsparameter nicht deklarieren oder aufzählen oder die Funktion ändern, wenn befehlsparameter geändert werden.

Die folgende Beispielfunktion ruft das cmdlet Get-Command auf. Der Befehl verwendet @args, um die Parameter von Get-Commanddarzustellen.

function Get-MyCommand { Get-Command @args }

Sie können alle Parameter von Get-Command verwenden, wenn Sie die Get-MyCommand-Funktion aufrufen. Die Parameter und Parameterwerte werden mithilfe von @argsan den Befehl übergeben.

Get-MyCommand -Name Get-ChildItem

CommandType     Name                ModuleName
-----------     ----                ----------
Cmdlet          Get-ChildItem       Microsoft.PowerShell.Management

Das feature @args verwendet den $args automatischen Parameter, der nicht deklarierte Cmdlet-Parameter und -Werte aus verbleibenden Argumenten darstellt.

Weitere Informationen finden Sie unter about_Splatting.

Verlegung von Objekten an Funktionen

Jede Funktion kann Eingaben aus der Pipeline übernehmen. Sie können steuern, wie eine Funktion Eingaben aus der Pipeline mithilfe von begin, process, endund clean Schlüsselwörtern verarbeitet. Die folgende Beispielsyntax zeigt die folgenden Schlüsselwörter:

Die process-Anweisungsliste wird für jedes Objekt in der Pipeline einmal ausgeführt. Während der process-Block ausgeführt wird, wird jedes Pipelineobjekt der $_ automatischen Variablen, jeweils einem Pipelineobjekt, zugewiesen.

Die folgende Funktion verwendet das schlüsselwort process. Die Funktion zeigt Werte aus der Pipeline an:

function Get-Pipeline
{
  process {"The value is: $_"}
}

1, 2, 4 | Get-Pipeline

The value is: 1
The value is: 2
The value is: 4

Wenn Sie eine Funktion benötigen, die Pipelineeingaben oder -eingaben aus einem Parameter übernehmen kann, muss der process-Block beide Fälle behandeln. Zum Beispiel:

function Get-SumOfNumbers {
    param (
        [int[]]$Numbers
    )

    begin { $retValue = 0 }

    process {
        if ($MyInvocation.ExpectingInput) {
           "Pipeline input: $_"
           $retValue += $_
        } else {
           foreach ($n in $Numbers) {
               "Command line input: $n"
               $retValue += $n
           }
        }
    }

    end { "Sum = $retValue" }
}


PS> 1,2,3,4 | Get-SumOfNumbers
Pipeline input: 1
Pipeline input: 2
Pipeline input: 3
Pipeline input: 4
Sum = 10
PS> Get-SumOfNumbers 1,2,3,4
Command line input: 1
Command line input: 2
Command line input: 3
Command line input: 4
Sum = 10

Wenn Sie eine Funktion in einer Pipeline verwenden, werden die an die Funktion weitergeleiteten Objekte der $input automatischen Variablen zugewiesen. Die Funktion führt Anweisungen mit dem Anweisungsblock begin aus, bevor objekte aus der Pipeline stammen. Die Funktion führt Anweisungen mit dem end Anweisungsblock aus, wenn keine weiteren Objekte in der Pipeline vorhanden sind.

Das folgende Beispiel zeigt die automatische Variable, die $input int the begin and end statement blocks verwendet wird.

function Get-PipelineBeginEnd {
    begin   { "Begin: The input is $input" }
    end     { "End:   The input is $input" }
}

Wenn Sie die Funktion mit Pipelineeingaben ausführen, werden die folgenden Ergebnisse angezeigt:

1, 2, 4 | Get-PipelineBeginEnd

Begin: The input is
End:   The input is 1 2 4

Wenn die begin-Anweisung ausgeführt wird, verfügt die Funktion nicht über die Eingabe aus der Pipeline. Die end-Anweisung wird ausgeführt, nachdem die Funktion die Werte aufweist.

Wenn die Funktion über ein process Schlüsselwort verfügt, wird jedes Objekt in $input aus $input entfernt und $_zugewiesen. Im folgenden Beispiel wird eine process-Anweisungsliste aufgeführt:

function Get-PipelineInput
{
    process {"Processing:  $_ " }
    end     {"End:   The input is: $input" }
}

In diesem Beispiel wird jedes Objekt, das an die Funktion weitergeleitet wird, an die process Anweisungsliste gesendet. Die process-Anweisungen werden jeweils für jedes Objekt ausgeführt. Die $input automatische Variable ist leer, wenn die Funktion das schlüsselwort end erreicht.

1, 2, 4 | Get-PipelineInput

Processing:  1
Processing:  2
Processing:  4
End:   The input is:

Weitere Informationen finden Sie unter Using Enumerators

PowerShell 7.3 hat den clean-Block hinzugefügt. Der clean-Block ist eine bequeme Möglichkeit für Benutzer, Ressourcen zu bereinigen, die in den begin, processund end-Blöcken erstellt und verwendet werden. Es ähnelt semantisch einem finally-Block, der alle anderen benannten Blöcke einer Skriptfunktion oder eines Skript-Cmdlets abdeckt. Die Ressourcenbereinigung wird für die folgenden Szenarien erzwungen:

  1. wenn die Pipelineausführung normal abgeschlossen ist, ohne den Fehler zu beenden
  2. wenn die Pipelineausführung aufgrund eines Beendigungsfehlers unterbrochen wird
  3. wenn die Pipeline abgeschnitten wird, z. B.: Select-Object -First
  4. wenn die Pipeline durch STRG+C oder StopProcessing()

Vorsicht

Das Hinzufügen des clean Blocks ist eine bahnbrechende Änderung. Da clean als Schlüsselwort analysiert wird, wird verhindert, dass Benutzer direkt einen Befehl aufrufen, der als erste Anweisung in einem Scriptblock bezeichnet clean wird. Es ist jedoch kein Problem. Der Befehl kann weiterhin über den Anrufoperator (& clean) aufgerufen werden.

Funktionsbereich

Eine Funktion ist im Bereich vorhanden, in dem Sie sie erstellen.

Wenn eine Funktion Teil eines Skripts ist, ist die Funktion für Anweisungen innerhalb dieses Skripts verfügbar. Standardmäßig ist eine Funktion in einem Skript außerhalb dieses Skripts nicht verfügbar.

Sie können den Bereich einer Funktion angeben. Die Funktion wird beispielsweise dem globalen Bereich im folgenden Beispiel hinzugefügt:

function Global:Get-DependentSvs {
  Get-Service | Where-Object {$_.DependentServices}
}

Wenn sich eine Funktion im globalen Bereich befindet, können Sie die Funktion in Skripts, in Funktionen und an der Befehlszeile verwenden.

Funktionen erstellen einen neuen Bereich. Die in einer Funktion erstellten Elemente, z. B. Variablen, sind nur im Funktionsbereich vorhanden.

Weitere Informationen finden Sie unter about_Scopes.

Suchen und Verwalten von Funktionen mithilfe des Laufwerks Function:

Alle Funktionen und Filter in PowerShell werden automatisch auf dem laufwerk Function: gespeichert. Dieses Laufwerk wird vom PowerShell-Function-Anbieter verfügbar gemacht.

Wenn Sie auf das laufwerk Function: verweisen, geben Sie nach Functioneinen Doppelpunkt ein, genau wie beim Verweisen auf das C- oder D Laufwerk eines Computers.

Der folgende Befehl zeigt alle Funktionen in der aktuellen PowerShell-Sitzung an:

Get-ChildItem Function:

Die Befehle in der Funktion werden als Scriptblock in der Definitionseigenschaft der Funktion gespeichert. Wenn Sie beispielsweise die Befehle in der Hilfefunktion anzeigen möchten, die im Lieferumfang von PowerShell enthalten ist, geben Sie Folgendes ein:

(Get-ChildItem Function:help).Definition

Sie können auch die folgende Syntax verwenden.

$Function:help

Weitere Informationen finden Sie unter about_Function_Provider.

Wiederverwenden von Funktionen in neuen Sitzungen

Wenn Sie eine Funktion an der PowerShell-Eingabeaufforderung eingeben, wird die Funktion Teil der aktuellen Sitzung. Die Funktion ist verfügbar, bis die Sitzung endet.

Um Ihre Funktion in allen PowerShell-Sitzungen zu verwenden, fügen Sie die Funktion ihrem PowerShell-Profil hinzu. Weitere Informationen zu Profilen finden Sie unter about_Profiles.

Sie können Ihre Funktion auch in einer PowerShell-Skriptdatei speichern. Geben Sie Ihre Funktion in eine Textdatei ein, und speichern Sie die Datei mit der Dateinamenerweiterung .ps1.

Hilfe für Funktionen erstellen

Das Get-Help Cmdlet erhält Hilfe für Funktionen, Cmdlets, Anbieter und Skripts. Um Hilfe zu einer Funktion zu erhalten, geben Sie Get-Help gefolgt vom Funktionsnamen ein.

Um z. B. Hilfe für die Get-MyDisks-Funktion zu erhalten, geben Sie Folgendes ein:

Get-Help Get-MyDisks

Sie können Hilfe für eine Funktion mit einer der beiden folgenden Methoden schreiben:

  • Comment-Based Hilfe zu Funktionen

    Erstellen Sie Hilfe mithilfe spezieller Schlüsselwörter in den Kommentaren. Um kommentarbasierte Hilfe für eine Funktion zu erstellen, müssen die Kommentare am Anfang, Ende oder im Textkörper der Funktion platziert werden. Weitere Informationen zur kommentarbasierten Hilfe finden Sie unter about_Comment_Based_Help.

  • XML-Based Hilfe zu Funktionen

    Xml-basierte Hilfe ist erforderlich, wenn Sie Hilfeinhalte in mehrere Sprachen lokalisieren müssen. Verwenden Sie das .EXTERNALHELP kommentarbasierte Hilfeschlüsselwort, um die Funktion der XML-basierten Hilfedatei zuzuordnen. Ohne dieses Schlüsselwort Get-Help kann die Funktionshilfedatei nicht gefunden werden und gibt nur die automatisch generierte Hilfe zurück.

    Weitere Informationen zum schlüsselwort .EXTERNALHELP finden Sie unter about_Comment_Based_Help. Weitere Informationen zur XML-basierten Hilfe finden Sie unter Hilfe zum Schreiben von Cmdlets.

Siehe auch

  • Last updated on