PowerShell verwendet Variablen, um Informationen zu speichern, die später gebraucht werden. Mit Variablen lassen sich auch einfach Werte an mehreren Stellen ändern, indem man die Definition der Variable ändert. Sie können Informationen wie Namen, Pfade und die Ausgaben von Befehlen in einer Variablen speichern.
Während Sie an Erfahrung mit PowerShell gewinnen, wird das Konzept der Variablenbereiche vermutlich ab einem bestimmten Punkt eine Rolle beim Schreiben von Skripts, Funktionen und Modulen spielen. In diesem Beitrag gehe ich auf die Grundlagen des PowerShell-Variablenbereichs ein und biete Beispiele für die Verwendung von Bereichen in PowerShell-Skripts und -Modulen.
Zusätzlich zu den Bereichen sollten Sie sich auch unsere Sammlung von PowerShell-Tools für weitere Ressourcen wie Editoren, Module und Schulungen anschauen. Damit können Sie Ihre PowerShell-Fähigkeiten auf das nächste Level bringen.
Der PowerShell-Bereich schützt Variablen und andere Artefakte, indem er einschränkt, wo sie gelesen und geändert werden können. Bereichsebenen schützen Elemente, die nicht geändert werden sollten. PowerShell verfügt über die folgenden Bereiche:
Bereiche arbeiten in einer Hierarchie, d. h. global ist der übergeordnete Bereich. Variablen, die im globalen Bereich definiert sind, stehen dem untergeordneten Bereich automatisch zum Abruf zur Verfügung. Im untergeordneten Bereich definierte Variablen sind jedoch nicht für den übergeordneten Bereich verfügbar.
Die Bereichsfunktionen in PowerShell folgen einigen grundlegenden Regeln:
Schauen wir uns einige Beispiele für verschiedene Bereiche in Aktion an. Ich habe ein Skript, das eine Variable definiert und auf dem Bildschirm ausgibt:
Dieses Skript definiert die Variable $greeting im Bereich des Skripts (oder lokal). Diese Variable und ihr Wert stehen der PowerShell-Konsole, also dem übergeordneten Bereich, jedoch nicht zur Verfügung. Schauen Sie sich hier die Ausgabe der PowerShell-Befehle an:
Ich zeige den aktuellen Wert der Variablen $greeting in der Konsole (oder im globalen Bereich) an, und wie erwartet ist sie leer. Ich führe die Skriptdatei aus, in der $greeting definiert ist und auf dem Bildschirm ausgegeben wird. Nachdem das Skript beendet wurde, zeige ich den Wert von $greeting erneut in der PowerShell-Konsole an, und er ist immer noch leer. Dieses Verhalten ist zu erwarten, da sich die Variable $greeting im untergeordneten Skriptbereich und nicht im übergeordneten globalen Bereich befindet.
Betrachten wir nun den umgekehrten Fall. Anstatt den Wert von $greeting im Skript zu definieren, definieren wir ihn im globalen Bereich. Das Skript zeigt dann den Wert der Variablen $greeting innerhalb des Skripts an, da es ihn aus dem globalen Bereich geerbt hat.
Innerhalb des Skripts habe ich die Variable $greeting nicht festgelegt oder verändert. Ich habe nur ihren Wert angezeigt. Der greeting-String wurde aus der Konsole als übergeordnetem Bereich an die Skriptdatei als untergeordneten Bereich vererbt.
In den vorherigen Beispielen sehen wir, wie eine im untergeordneten Skriptbereich definierte Variable dem globalen Bereich nicht als Referenz zur Verfügung stand. Wir können jedoch Bereichsmodifikatoren verwenden, um den Bereich der definierten Variable zu ändern. Einige Bereichsmodifikatoren sind:
| Bereichsmodifikator | Nutzung |
| global: | Die Variable existiert im globalen Bereich |
| local: | Die Variable existiert im lokalen Bereich |
| private: | Die Variable ist nur im aktuellen Bereich sichtbar |
| script: | Die Variable existiert im Skriptbereich, d. h. im Bereich der nächstgelegenen Skriptdatei, oder im Bereich „Global“, wenn keiner verfügbar ist |
Ich kann beispielsweise das Präfix $global: für eine Variable in einem Skript verwenden, um einen Variablenwert zu ändern, den ich bereits im globalen übergeordneten Bereich definiert habe. Schauen Sie sich das Skript und die Konsolenausgabe unten an:
Ich habe die Variable $greeting im globalen Konsolenbereich als “Hello, Jeff!” definiert. Anschließend habe ich die Skriptdatei ausgeführt, die den Wert mithilfe des Bereichsmodifikators $global: “Hello, World!” neu zugewiesen hat. Nach der Ausführung des Skripts wurde der Wert von $greeting im globalen Konsolenbereich auf den Wert des Skripts geändert.
Ein PowerShell-Modul ist ein Paket von Befehlen, z. B. cmdlets oder Funktionen, die ähnliche Funktionen oder Zwecke haben. Ein Beispiel dafür ist das Modul ActiveDirectory für Windows PowerShell, das Befehle zum Verwalten von Active-Directory-Objekten enthält.
Sie können ein Modul selbst erstellen und müssen möglicherweise in verschiedenen Funktionen auf dieselbe Variable verweisen. Durch das Festlegen von Variablen im Skriptbereich in einem Modul sind die Variablen nun für die Funktionen des Moduls gemeinsam nutzbar.
Hier ist eine Beispieldatei des PowerShell-Moduls (MyModule.psm1), die zwei Funktionen enthält: Get-Greeting und Set-Greeting:
function Get-Greeting {
if ($name) {
$greeting = "Hello, $name!"
}
else {
$greeting = "Hello, World!"
}
$greeting
}
function Set-GreetingName {
param(
[Parameter(Mandatory)]
[string]
$GreetingName
)
$name = $GreetingName
}
function Get-Greeting {
if ($name) {
$greeting = "Hello, $name!"
}
else {
$greeting = "Hello, World!"
}
$greeting
}
function Set-GreetingName {
param(
[Parameter(Mandatory)]
[string]
$GreetingName
)
$name = $GreetingName
}
Beachten Sie, dass beide Funktionen auf die Variable $name verweisen. Da ich die Variable jedoch in separaten Funktionen definiert habe, gilt ihr Bereich nur für diese Funktion. Das Festlegen der Variablen $name in der Funktion Set-GreetingName hat keinen Einfluss auf die Variable $name in Get-Greeting. Sie können das selbst ausprobieren, indem Sie diesen Code in einer .psm1-Datei speichern, ihn mit dem Befehl Import-Module importieren und den Dateinamen des Moduls referenzieren.
Obwohl ich die Variable $name mit der Funktion Set-GreetingName festgelegt habe, hat das keine Auswirkungen auf die Variable $name in der Funktion Get-Greeting . Jede Variable $name ist durch ihren Bereich auf ihre eigene Funktion beschränkt. Wenn ich den Wert in einer Funktion ändere, wirkt sich das nicht auf die andere Funktion aus.
Wenn die Variable für alle Funktionen im Modul verfügbar sein soll, füge ich folgendermaßen den Modifikator $script: zur Variable $name hinzu:
function Get-Greeting {
if ($script:name) {
$greeting = "Hello, $script:name!"
}
else {
$greeting = "Hello, World!"
}
$greeting
}
function Set-GreetingName {
param(
[Parameter(Mandatory)]
[string]
$GreetingName
)
$script:name = $GreetingName
}
function Get-Greeting {
if ($script:name) {
$greeting = "Hello, $script:name!"
}
else {
$greeting = "Hello, World!"
}
$greeting
}
function Set-GreetingName {
param(
[Parameter(Mandatory)]
[string]
$GreetingName
)
$script:name = $GreetingName
}
Wenn ich das Modul mit dem Parameter -Force erneut importiere, kann ich nun den Wert von $name in einer Funktion festlegen und ihn in einer anderen referenzieren.
Beachten Sie, dass der Aufruf von Get-Greeting die Standardnachricht anzeigt, da die Variable $script:name keinen Wert hatte. Nach dem Aufruf der Funktion Set-GreetingName zeigt die Funktion Get-Greeting nun einen anderen Wert an, gemäß dem Namen, den ich übergeben habe. Dieses Verhalten ist zu erwarten, da beide Funktionen nun auf dieselbe Variable verweisen.
Das Beispielmodul ist zwar einfach, aber daran lässt sich der praktische Nutzen von Bereichen erkennen. Ich verwende diese Funktionen, um API-Anmeldedaten einzustellen, die mehrere Funktionen in von mir geschriebenen Modulen verwenden. Ein Beispiel dafür finden Sie in meinem GitHub-Repository twilio-powershell-module.
Wie ich in den obigen Beispielen gezeigt habe, haben Skripts und Funktionen ihren eigenen Bereich außerhalb des globalen Bereichs. Änderungen an Variablen sind nur in diesem Bereich gültig, es sei denn, Sie verwenden einen Bereichsmodifikator, um den Bereich der Variablen zu ändern.
Sie können jedoch den Bereich eines Skripts oder einer Funktion integrieren, indem Sie die Dot-Source-Notation verwenden. Wenn das Skript im aktuellen Bereich ausgeführt wird, sind alle Skriptvariablen im aktuellen Bereich verfügbar. Sie können die Dot-Source-Notation verwenden, indem Sie einen Punkt (.) und ein Leerzeichen vor den Skriptnamen setzen. Schauen Sie sich die Skriptdatei und den Code unten an:
Zunächst ist der Wert von $greeting im globalen Konsolenbereich leer bzw null, und die Datei scopetest.ps1 legt den Wert von $greeting fest. Durch die Verwendung der Dot-Source-Notation bringt das Skript den Variablenwert in den übergeordneten Bereich. Sie können auch den Aufruf-Operator/das Et-Zeichen (&) verwenden, um ein Skript oder eine Funktion auszuführen, ohne dass der Bereich zum aktuellen Bereich hinzugefügt wird.
Ein gutes Verständnis von Bereichen in PowerShell ist beim Schreiben von Skripts, Modulen und Funktionen unerlässlich. Beispielsweise können Sie in eine Situation kommen, in der eine Variable einen unerwarteten Wert hat, weil sie ihn von einem anderen Bereich geerbt hat. Die Verwendung anderer Techniken, beispielsweise die Arbeit mit Bereichen auf Modulebene und Dot-Source-Notation, kann Ihnen helfen, wertvolle PowerShell-Tools für Ihren Werkzeugkasten zu erstellen.
Weitere Informationen zum Schreiben von PowerShell-Skripts finden Sie in Jeff Petters Windows PowerShell Scripting-Tutorial für Anfänger.