Freigeben über

about_Scopes

Kurzbeschreibung

Erläutert das Konzept des Bereichs in PowerShell und zeigt, wie der Bereich von Elementen festgelegt und geändert wird.

Lange Beschreibung

PowerShell schützt den Zugriff auf Variablen, Aliase, Funktionen und PowerShell-Laufwerke (PSDrives), indem sie einschränken, wo sie gelesen und geändert werden können. PowerShell verwendet Bereichsregeln, um sicherzustellen, dass Sie nicht unbeabsichtigte Änderungen an Elementen in anderen Bereichen vornehmen.

Bereichsregeln

Wenn Sie PowerShell starten, erstellt der Host (pwsh.exe) einen PowerShell-Runspace. Hostprozesse können mehrere Runspaces haben. Jeder Runspace hat seine eigenen Container für Sitzungsstatus und Bereiche. Auf Sitzungsstatus und Bereiche kann nicht über Runspace-Instanzen hinweg zugegriffen werden.

Im Folgenden sind die grundlegenden Regeln des Gültigkeitsbereichs aufgeführt:

  • Bereiche können verschachtelt werden. Ein äußerer Bereich wird als übergeordneter Bereich bezeichnet. Alle verschachtelten Bereiche sind untergeordnete Bereiche dieses übergeordneten Bereichs.
  • Ein Objekt ist in dem Bereich, in dem es erstellt wurde, und in allen untergeordneten Bereichen sichtbar, es sei denn, Sie machen es ausdrücklich privat.
  • Mithilfe von Bereichsmodifizierern können Sie Variablen, Aliase, Funktionen und PowerShell-Laufwerke für einen Bereich außerhalb des aktuellen Bereichs deklarieren.
  • Ein Element, das Sie in einem Bereich erstellt haben, kann nur in dem Bereich geändert werden, in dem es erstellt wurde, es sei denn, Sie geben explizit einen anderen Bereich an.
  • Wenn code, der in einem Runspace ausgeführt wird, auf ein Element verweist, durchsucht PowerShell die Bereichshierarchie, beginnend mit dem aktuellen Bereich und durchläuft jeden übergeordneten Bereich.
    • Wenn das Element nicht gefunden wird, wird ein neues Element im aktuellen Bereich erstellt.
    • Wenn eine Übereinstimmung gefunden wird, wird der Wert des Elements aus dem Bereich abgerufen, in dem gefunden wurde.
    • Wenn Sie den Wert ändern, wird das Element in den aktuellen Bereich kopiert, sodass sich die Änderung nur auf den aktuellen Bereich auswirkt.
  • Wenn Sie explizit ein Element erstellen, das seinen Namen mit einem Element in einem anderen Bereich teilt, wird das ursprüngliche Element möglicherweise vom neuen Element ausgeblendet, aber es wird nicht überschrieben oder geändert.

Übergeordnete und untergeordnete Bereiche

Sie können einen neuen untergeordneten Bereich erstellen, indem Sie ein Skript oder eine Funktion aufrufen. Der aufrufende Bereich ist der übergeordnete Bereich. Das aufgerufene Skript oder die Funktion ist der untergeordnete Bereich. Die von Ihnen aufgerufenen Funktionen oder Skripts rufen möglicherweise andere Funktionen auf, wodurch eine Hierarchie untergeordneter Bereiche erstellt wird, deren Stammbereich der globale Bereich ist.

Anmerkung

Funktionen aus einem Modul werden nicht in einem untergeordneten Bereich des aufrufenden Bereichs ausgeführt. Module verfügen über einen eigenen Sitzungsstatus, der mit dem Bereich verknüpft ist, in den das Modul importiert wurde. Der gesamte Modulcode wird in einer modulspezifischen Hierarchie von Bereichen ausgeführt, die über einen eigenen Stammbereich verfügen. Weitere Informationen finden Sie im Abschnitt Module dieses Artikels.

Wenn ein untergeordneter Bereich erstellt wird, enthält er alle Aliase und Variablen, die die Option AllScope haben, sowie einige automatische Variablen. Diese Option wird weiter unten in diesem Artikel erläutert.

Sofern Sie die Elemente nicht ausdrücklich als privat kennzeichnen, sind die Elemente im übergeordneten Bereich für den untergeordneten Bereich verfügbar. Elemente, die Sie in einem untergeordneten Bereich erstellen oder ändern, wirken sich nicht auf den übergeordneten Bereich aus, es sei denn, Sie geben den Bereich explizit an, wenn Sie die Elemente erstellen.

Um die Elemente in einem bestimmten Bereich zu finden, verwenden Sie den Scope-Parameter von Get-Variable oder Get-Alias.

Um beispielsweise alle Variablen im lokalen Bereich abzurufen, geben Sie Folgendes ein:

Get-Variable -Scope Local

Um alle Variablen im globalen Bereich abzurufen, geben Sie Folgendes ein:

Get-Variable -Scope Global

Wenn ein Verweis auf eine Variable, einen Alias oder eine Funktion erfolgt, durchsucht PowerShell den aktuellen Bereich. Wenn das Objekt nicht gefunden wird, wird der übergeordnete Bereich durchsucht. Diese Suche wird bis hin zum globalen Bereich wiederholt. Wenn eine Variable in einem übergeordneten Bereich privat ist, wird die Suche über die Bereichskette fortgesetzt. Beispiel 4 zeigt die Auswirkung einer privaten Variablen in einer Bereichssuche an.

PowerShell-Bereichsnamen

PowerShell definiert Namen für einige Bereiche, um den Zugriff auf diesen Bereich zu erleichtern. PowerShell definiert die folgenden benannten Bereiche:

  • Global: Der Bereich, der in Kraft ist, wenn PowerShell startet oder wenn Sie eine neue Sitzung oder einen neuen Runspace erstellen. Variablen und Funktionen, die beim Starten von PowerShell vorhanden sind, z. B. automatische Variablen und Einstellungsvariablen, werden im globalen Bereich erstellt. Die Variablen, Aliase und Funktionen in Ihren PowerShell-Profilen werden auch im globalen Bereich erstellt. Der globale Bereich ist der übergeordnete Root-Bereich in einem Runspace.
  • Lokal: Der aktuelle Bereich. Der lokale Bereich kann der globale Bereich oder ein beliebiger anderer Bereich sein.
  • Skript: Der Bereich, der beim Ausführen einer Skriptdatei erstellt wird. Die Befehle im Skript werden im Bereich des Skripts ausgeführt. Für die Befehle in einem Skript ist der Skriptbereich der lokale Bereich.

Für Cmdlets, die Bereiche unterstützen, können Bereiche durch eine Zahl verwiesen werden, die die relative Position eines Bereichs zu einem anderen beschreibt. Bereich 0 bezeichnet den aktuellen (lokalen) Bereich, Bereich 1 ist der übergeordnete Bereich des aktuellen Bereichs, Bereich 2 ist der übergeordnete Bereich des übergeordnete Bereichs des aktuellen Bereichs. Dieses Muster setzt sich fort, bis Sie den Root-Bereich erreichen.

Bereichsmodifizierer

Eine Variable, ein Alias oder ein Funktionsname kann einen der folgenden optionalen Bereichsmodifizierer enthalten:

  • Global: – Gibt an, dass der Name im bereich Global vorhanden ist.

  • Local: – Gibt an, dass der Name im lokalen Bereich existiert. Der aktuelle Bereich ist immer der Lokale Bereich. Wenn Sie den Local: Bereichsmodifizierer verwenden, durchsucht PowerShell keine übergeordneten Bereiche. Wenn das Element im aktuellen Bereich vorhanden ist, wird es verwendet. Wenn das Element im aktuellen Bereich nicht vorhanden ist, erstellt PowerShell ein neues Element im aktuellen Bereich.

  • Private: – Gibt an, dass der Name Private ist und nur für den aktuellen Bereich sichtbar ist.

    Anmerkung

    Private: ist kein Bereich. Es handelt sich um eine Option, die die Barrierefreiheit eines Elements außerhalb des Bereichs ändert, in dem es definiert ist.

  • Script: – Gibt an, dass der Name im bereich Script vorhanden ist. Skriptbereich ist der Bereich der nächsten übergeordneten Skriptdatei oder Global, wenn keine nächste übergeordnete Skriptdatei vorhanden ist.

  • Using: – Wird für den Zugriff auf Variablen verwendet, die in einem anderen Bereich definiert sind, während sie in Remotesitzungen, Hintergrundaufträgen oder Threadaufträgen ausgeführt werden.

  • Workflow: – Gibt an, dass der Name innerhalb eines Workflows vorhanden ist. Hinweis: Workflows werden in PowerShell v6 und höher nicht unterstützt.

  • <variable-namespace> – Ein Modifizierer, der von einem PowerShell-PSDrive--Anbieter erstellt wurde. Zum Beispiel:

    Namespace Beschreibung
    Alias: Im aktuellen Bereich definierte Aliase
    Env: Umgebungsvariablen, die im aktuellen Bereich definiert sind
    Function: Im aktuellen Bereich definierte Funktionen
    Variable: Variablen, die im aktuellen Bereich definiert sind

Der Standardbereich für Skripts ist der Skriptbereich. Der Standardbereich für Funktionen und Aliase ist der lokale Bereich, auch wenn er in einem Skript definiert ist.

Bereichsmodifikatoren verwenden

Verwenden Sie einen Bereichsmodifizierer, um den Bereich einer neuen Variablen, eines Alias oder einer neuen Funktion anzugeben.

Die Syntax für einen Bereichsmodifizierer in einer Variablen lautet:

$[<scope-modifier>:]<name> = <value>

Die Syntax für einen Bereichsmodifizierer in einer Funktion lautet:

function [<scope-modifier>:]<name> {<function-body>}

Der folgende Befehl, der keinen Bereichsmodifizierer verwendet, erstellt eine Variable im aktuellen oder lokalen Bereich:

$a = "one"

Um dieselbe Variable im globalen Bereich zu erstellen, verwenden Sie den Bereichsmodifikator Global::

$Global:a = "one"
Get-Variable a | Format-List *

Beachten Sie die Werte der Eigenschaften Visibility und Options.

Name        : a
Description :
Value       : one
Visibility  : Public
Module      :
ModuleName  :
Options     : None
Attributes  : {}

Vergleichen Sie dies mit einer privaten Variablen:

$Private:pVar = 'Private variable'
Get-Variable pVar | Format-List *

Die Verwendung des Bereichsmodifikators Private: legt die Eigenschaft Options auf Private fest.

Name        : pVar
Description :
Value       : Private variable
Visibility  : Public
Module      :
ModuleName  :
Options     : Private
Attributes  : {}

Um dieselbe Variable im Skript Bereich zu erstellen, verwenden Sie den Script: Bereichsmodifizierer:

$Script:a = "one"

Sie können auch einen Bereichsmodifizierer mit Funktionen verwenden. Die folgende Funktionsdefinition erstellt eine Funktion im globalen Bereich:

function Global:Hello {
  Write-Host "Hello, World"
}

Sie können auch Bereichsmodifizierer verwenden, um auf eine Variable in einem anderen Bereich zu verweisen. Der folgende Befehl bezieht sich auf die variable $test, zuerst im lokalen Bereich und dann im globalen Bereich:

$test
$Global:test

Der Bereichsmodifikator Using:

ist ein spezieller Bereichsmodifikator, der eine lokale Variable in einem Remote-Befehl identifiziert. Ohne Modifizierer erwartet PowerShell, dass Variablen in Remotebefehlen in der Remotesitzung definiert werden.

Der Using: Bereichsmodifizierer wurde in PowerShell 3.0 eingeführt.

Für alle Skripts oder Befehle, die außerhalb der Sitzung ausgeführt werden, benötigen Sie den Using: Bereichsmodifizierer, um Variablenwerte aus dem aufrufenden Sitzungsbereich einzubetten, damit außerhalb des Sitzungscodes darauf zugegriffen werden kann. Der Using: Bereichsmodifizierer wird in den folgenden Kontexten unterstützt:

  • Remote ausgeführte Befehle, gestartet mit Invoke-Command unter Verwendung der Parameter ComputerName, HostName, SSHConnection oder Session, (Remotesitzung)
  • Hintergrundaufträge werden mit Start-Job gestartet (nicht aktive Sitzung)
  • Threadaufträge, gestartet über Start-ThreadJob oder ForEach-Object -Parallel (separate Threadsitzung)

Abhängig vom Kontext sind eingebettete Variablenwerte entweder unabhängige Kopien der Daten im Bereich des Aufrufers oder Verweise darauf. In Remote- und Out-of-Process-Sitzungen handelt es sich immer um unabhängige Kopien.

Weitere Informationen finden Sie unter about_Remote_Variables.

Ein $Using: Verweis wird nur auf den Wert einer Variablen erweitert. Wenn Sie den Wert einer Variablen im Bereich des Aufrufers ändern möchten, müssen Sie über einen Verweis auf die Variable selbst verfügen. Sie können einen Verweis auf eine Variable erstellen, indem Sie die PSVariable Instanz der Variablen abrufen. Das folgende Beispiel zeigt, wie Sie einen Verweis erstellen und Änderungen an einer Thread-Aufgabe vornehmen.

$Count = 1
$refOfCount = Get-Variable Count

Start-ThreadJob {
    ($Using:refOfCount).Value = 2
} | Receive-Job -Wait -AutoRemoveJob

$Count

2

Anmerkung

Dies ist kein thread-sicherer Vorgang. Sie können Datenbeschädigungen verursachen, wenn Sie versuchen, den Wert von mehreren Threads gleichzeitig zu ändern. Sie sollten threadsichere Datentypen oder Synchronisierungsgrundtypen verwenden, um freigegebene Daten zu schützen. Weitere Informationen finden Sie unter Thread-sichere Collections.

Serialisierung von Variablenwerten

Remote-Befehle und Hintergrundaufträge werden außerhalb des Prozesses ausgeführt. Out-of-Process-Sitzungen verwenden XML-basierte Serialisierung und Deserialisierung, um die Werte von Variablen über die Prozessgrenzen hinweg verfügbar zu machen. Der Serialisierungsprozess konvertiert Objekte in eine PSObject-, die die ursprünglichen Objekteigenschaften enthält, jedoch nicht die zugehörigen Methoden.

Bei einer begrenzten Anzahl von Typen konvertiert die Deserialisierung Objekte zurück in den ursprünglichen Typ. Das rehydratisierte Objekt ist eine Kopie der ursprünglichen Objektinstanz. Es verfügt über die Typeigenschaften und -methoden. Bei einfachen Typen wie System.Versionist die Kopie genau. Bei komplexen Typen ist die Kopie unvollkommen. Beispielsweise enthalten rehydratisierte Zertifikatobjekte nicht den privaten Schlüssel.

Instanzen aller anderen Typen sind PSObject Instanzen. Die pstypenames-Eigenschaft enthält den ursprünglichen Typnamen, dem Deserializedvorangestellt ist, z. B. Deserialized.System.Data.DataTable-

Die AllScope-Option

Variablen und Aliase haben eine Option Eigenschaft, die einen Wert von AllScopeannehmen kann. Elemente, die die Eigenschaft AllScope haben, werden Teil aller untergeordneten Bereiche, die Sie erstellen, obwohl sie nicht retroaktiv an übergeordnete Bereiche vererbt werden.

Ein Element, das die Eigenschaft Visibility besitzt, ist im untergeordneten Bereich sichtbar und gehört zu diesem Bereich. Änderungen am Element in einem beliebigen Bereich wirken sich auf alle Bereiche aus, in denen die Variable definiert ist.

Bereich verwalten

Mehrere Cmdlets verfügen über einen Scope Parameter, mit dem Sie Elemente in einem bestimmten Bereich abrufen oder festlegen (erstellen und ändern). Verwenden Sie den folgenden Befehl, um alle Cmdlets in Ihrer Sitzung zu finden, die über einen Scope Parameter verfügen:

Get-Help * -Parameter Scope

Um die Variablen zu finden, die in einem bestimmten Bereich sichtbar sind, verwenden Sie den Scope Parameter von Get-Variable. Die sichtbaren Variablen umfassen globale Variablen, Variablen im übergeordneten Bereich und Variablen im aktuellen Bereich.

Der folgende Befehl ruft beispielsweise die Variablen ab, die im lokalen Bereich sichtbar sind:

Get-Variable -Scope Local

Um eine Variable in einem bestimmten Bereich zu erstellen, verwenden Sie einen Bereichsmodifizierer oder den Scope Parameter von Set-Variable. Mit dem folgenden Befehl wird eine Variable im globalen Bereich erstellt:

New-Variable -Scope Global -Name a -Value "One"

Sie können auch den Scope-Parameter der New-Alias, Set-Aliasoder Get-Alias Cmdlets verwenden, um den Bereich anzugeben. Mit dem folgenden Befehl wird ein Alias im globalen Bereich erstellt:

New-Alias -Scope Global -Name np -Value Notepad.exe

Verwenden Sie zum Abrufen der Funktionen in einem bestimmten Bereich das Cmdlet Get-Item, wenn Sie sich im Bereich befinden. Das Cmdlet Get-Item verfügt nicht über einen Scope--Parameter.

Anmerkung

Für die Cmdlets, die den Parameter Scope verwenden, können Sie auch auf Bereiche nach Nummer verweisen. Die Zahl beschreibt die relative Position eines Bereichs zu einem anderen. Bereich 0 stellt den aktuellen oder lokalen Bereich dar. Bereich 1 gibt den unmittelbar übergeordneten Bereich an. Bereich 2 zeigt den übergeordneten Bereich des übergeordneten Bereichs an usw. Nummerierte Bereiche sind nützlich, wenn Sie viele rekursive Bereiche erstellt haben.

Verwendung der Punkt-Quellennotation mit dem Bereich

Skripte und Funktionen folgen den Regeln des Bereichs. Sie erstellen sie in einem bestimmten Bereich, und sie wirken sich nur auf diesen Bereich aus, es sei denn, Sie verwenden einen Cmdlet-Parameter oder einen Bereichsmodifizierer, um diesen Bereich zu ändern.

Sie können jedoch den Inhalt eines Skripts oder einer Funktion dem aktuellen Bereich hinzufügen, indem Sie die Punkt-Quellennotation verwenden. Wenn Sie ein Skript oder eine Funktion mit der Punkt-Quellennotation ausführen, wird es im aktuellen Bereich ausgeführt. Alle Funktionen, Aliase und Variablen im Skript oder der Funktion werden dem aktuellen Bereich hinzugefügt.

Wenn Sie z. B. das Sample.ps1 Skript aus dem verzeichnis C:\Scripts im Skriptbereich (standard für Skripts) ausführen möchten, geben Sie einfach den vollständigen Pfad zur Skriptdatei in der Befehlszeile ein.

C:\scripts\sample.ps1

Eine Skriptdatei muss über eine .ps1 Dateierweiterung verfügen, damit sie ausführbar ist. Dateien mit Leerzeichen in ihrem Pfad müssen in Anführungszeichen eingeschlossen werden. Wenn Sie versuchen, den in Anführungszeichen gesetzten Pfad auszuführen, zeigt PowerShell den Inhalt der Zeichenfolge an, anstatt das Skript auszuführen. Mit dem Aufrufoperator (&) können Sie den Inhalt der Zeichenfolge ausführen, die den Dateinamen enthält.

Wenn Sie den Aufrufoperator verwenden, um eine Funktion oder ein Skript auszuführen, wird dieses im Skriptbereich ausgeführt. Die Verwendung des Aufrufoperators unterscheidet sich nicht von der Ausführung des Skripts über den Namen.

& C:\scripts\sample.ps1

Weitere Informationen zum Anrufanbieter finden Sie in about_Operators.

Um das skript Sample.ps1 im lokalen Bereich auszuführen, geben Sie einen Punkt und ein Leerzeichen (. ) vor dem Pfad zum Skript ein:

. C:\scripts\sample.ps1

Jetzt werden alle Funktionen, Aliase oder Variablen, die im Skript definiert sind, dem aktuellen Bereich hinzugefügt.

Einschränken ohne Bereich

PowerShell verfügt über einige Optionen und Funktionen, die dem Bereich ähnlich sind und mit Bereichen interagieren können. Diese Funktionen können mit dem Bereich oder dem Verhalten des Bereichs verwechselt werden.

Sitzungen, Module und verschachtelte Prompts sind in sich geschlossene Umgebungen und keine untergeordneten Bereiche des globalen Bereichs in der Sitzung.

Sitzungen

Eine Sitzung ist eine Umgebung, in der PowerShell ausgeführt wird. Wenn Sie eine Sitzung auf einem Remotecomputer erstellen, stellt PowerShell eine dauerhafte Verbindung mit dem Remotecomputer her. Mit der persistenten Verbindung können Sie die Sitzung für mehrere verwandte Befehle verwenden.

Da eine Sitzung eine in sich geschlossene Umgebung ist, verfügt sie über einen eigenen Bereich, aber eine Sitzung ist kein untergeordneter Bereich der Sitzung, in der sie erstellt wurde. Die Sitzung beginnt mit ihrem eigenen globalen Bereich. Dieser Bereich ist unabhängig vom globalen Bereich der Sitzung. Sie können in der Sitzung untergeordnete Bereiche erstellen. Sie können zum Beispiel ein Skript ausführen, um einen untergeordneten Bereich in einer Sitzung zu erstellen.

Module

Sie können ein PowerShell-Modul verwenden, um PowerShell-Tools zu teilen und bereitzustellen. Ein Modul ist eine Einheit, die Cmdlets, Skripts, Funktionen, Variablen, Aliase und andere nützliche Elemente enthalten kann. Sofern nicht explizit exportiert (mit Export-ModuleMember oder dem Modulmanifest) sind die Elemente in einem Modul außerhalb des Moduls nicht zugänglich. Daher können Sie das Modul zu Ihrer Sitzung hinzufügen und die öffentlichen Elemente verwenden, ohne sich Sorgen zu machen, dass die anderen Elemente in Ihrer Sitzung die Cmdlets, Skripts, Funktionen und andere Elemente überschreiben könnten.

Standardmäßig werden Module in den Bereich der Root-Ebene (global) des Runspace geladen. Beim Importieren eines Moduls wird der Bereich nicht geändert. Innerhalb der Sitzung haben Module ihren eigenen Gültigkeitsbereich. Betrachten Sie das folgende Modul C:\temp\mod1.psm1:

$a = "Hello"

function foo {
    "`$a = $a"
    "`$Global:a = $Global:a"
}

Jetzt erstellen wir eine globale Variable $a, geben ihm einen Wert und rufen die Funktion fooauf.

$a = "Goodbye"
foo

Das Modul deklariert die Variable $a im Bereich des Moduls und die Funktion foo gibt den Wert der Variable in beiden Bereichen aus.

$a = Hello
$Global:a = Goodbye

Module erstellen parallele Bereichscontainer, die mit dem Bereich verknüpft sind, in den sie importiert wurden. Elemente, die vom Modul exportiert werden, sind ab der Bereichsebene verfügbar, in der sie importiert werden. Elemente, die nicht aus dem Modul exportiert werden, sind nur innerhalb des Bereichscontainers des Moduls verfügbar. Funktionen im Modul können auf Elemente im Bereich zugreifen, in dem sie importiert wurden, sowie Elemente im Bereichscontainer des Moduls.

Wenn Sie Modul2 von innerhalb vonModul1 laden, wird Modul2 in den Bereich Container von Modul1 geladen. Alle Exporte aus Module2 werden im aktuellen Modulbereich Module1platziert. Wenn Sie Import-Module -Scope Localverwenden, werden die Exporte nicht auf der obersten Ebene, sondern in das aktuelle Bereichsobjekt eingefügt. Wenn Sie in einem Modul sind und ein anderes Modul mithilfe von Import-Module -Scope Global (oder Import-Module -Global) laden, werden dieses Modul und seine Exporte in den globalen Bereich anstelle des lokalen Bereichs des Moduls geladen. Die Funktion WindowsCompatibility führt dies aus, um Proxymodule in den globalen Sitzungszustand zu importieren.

Verschachtelte Prompts

Verschachtelte Prompts verfügen nicht über einen eigenen Bereich. Wenn Sie einen verschachtelten Prompt eingeben, ist der verschachtelte Prompt eine Untermenge der Umgebung. Sie bleiben jedoch innerhalb des lokalen Bereichs.

Skripte haben einen eigenen Bereich. Wenn Sie ein Skript debuggen und einen Haltepunkt im Skript erreichen, betreten Sie den Bereich des Skripts.

Private Option

Aliase und Variablen weisen eine Option Eigenschaft auf, die einen Wert von Privateannehmen kann. Elemente mit der Option Private können im Bereich, in dem sie erstellt werden, angezeigt und geändert werden, sie können jedoch nicht außerhalb dieses Bereichs angezeigt oder geändert werden.

Wenn Sie beispielsweise eine Variable erstellen, die eine private Option im globalen Bereich aufweist und dann ein Skript ausführt, zeigen Get-Variable Befehle im Skript nicht die private Variable an. Wenn Sie den Global: Bereichsmodifizierer in dieser Instanz verwenden, wird die private Variable nicht angezeigt.

Sie können den parameter Option des New-Variable, Set-Variable, New-Aliasund Set-Alias Cmdlets verwenden, um den Wert der Option -Eigenschaft auf "Privat" festzulegen.

Sichtbarkeit

Die Sichtbarkeit Eigenschaft einer Variablen oder eines Alias bestimmt, ob das Element außerhalb des Containers angezeigt werden kann, in dem es erstellt wurde. Ein Container kann ein Modul, ein Skript oder ein Snap-In sein. Sichtbarkeit ist für Container gedacht, so wie der Private-Wert der Eigenschaft Option für Bereiche gedacht ist.

Die Eigenschaft Visibility nimmt die Werte Public und Private an. Elemente mit privater Sichtbarkeit können nur im Container angezeigt und geändert werden, in dem sie erstellt wurden. Wenn der Container hinzugefügt oder importiert wird, können die Elemente mit privater Sichtbarkeit nicht angezeigt oder geändert werden.

Da die Sichtbarkeit für Container ausgelegt ist, funktioniert sie in einem Bereich anders.

  • Wenn Sie ein Element mit privater Sichtbarkeit im globalen Bereich erstellen, können Sie das Element in keinem Bereich anzeigen oder ändern.
  • Wenn Sie versuchen, den Wert einer Variablen mit privater Sichtbarkeit anzuzeigen oder zu ändern, gibt PowerShell eine Fehlermeldung zurück.

Sie können die cmdlets New-Variable und Set-Variable verwenden, um eine Variable mit privater Sichtbarkeit zu erstellen.

Examples

Beispiel 1: Ändern eines Variablenwerts nur in einem Skript

Der folgende Befehl ändert den Wert der $ConfirmPreference Variablen in einem Skript. Die Änderung wirkt sich nicht auf den globalen Bereich aus.

Verwenden Sie zunächst den folgenden Befehl, um den Wert der variablen $ConfirmPreference im lokalen Bereich anzuzeigen:

PS>  $ConfirmPreference
High

Erstellen Sie ein Scope.ps1 Skript, das die folgenden Befehle enthält:

$ConfirmPreference = "Low"
"The value of `$ConfirmPreference is $ConfirmPreference."

Führen Sie das Skript aus. Das Skript ändert den Wert der $ConfirmPreference Variablen und meldet dann den Wert im Skriptbereich. Die Ausgabe sollte der folgenden Ausgabe ähneln:

The value of $ConfirmPreference is Low.

Testen Sie als Nächstes den aktuellen Wert der variablen $ConfirmPreference im aktuellen Bereich.

PS>  $ConfirmPreference
High

Dieses Beispiel zeigt, dass Änderungen am Wert einer Variablen im Skriptbereich keinen Einfluss auf den Wert der Variablen im übergeordneten Bereich haben.

Beispiel 2: Anzeigen eines Variablenwerts in verschiedenen Bereichen

Sie können Bereichsmodifizierer verwenden, um den Wert einer Variablen im lokalen Bereich und in einem übergeordneten Bereich anzuzeigen.

Definieren Sie zunächst eine $test Variable im globalen Bereich.

$test = "Global"

Erstellen Sie als Nächstes ein Sample.ps1 Skript, das die $test Variable definiert. Verwenden Sie im Skript einen Bereichsmodifizierer, um auf die globale oder lokale Version der $test Variable zu verweisen.

In Sample.ps1:

$test = "Local"
"The local value of `$test is $test."
"The global value of `$test is $Global:test."

Wenn Sie Sample.ps1ausführen, sollte die Ausgabe etwa wie das folgende Ergebnis aussehen:

The local value of $test is Local.
The global value of $test is Global.

Wenn das Skript abgeschlossen ist, wird nur der globale Wert von $test in der Sitzung definiert.

PS> $test
Global

Beispiel 3: Ändern des Werts einer Variablen in einem übergeordneten Bereich

Wenn Sie ein Element nicht mithilfe der Option "Privat" oder einer anderen Methode schützen, können Sie den Wert einer Variablen in einem übergeordneten Bereich anzeigen und ändern.

Definieren Sie zunächst eine $test Variable im globalen Bereich.

$test = "Global"

Erstellen Sie als Nächstes ein Sample.ps1 Skript, das die $test Variable definiert. Verwenden Sie im Skript einen Bereichsmodifizierer, um auf die globale oder lokale Version der $test Variable zu verweisen.

In Sample.ps1:

$Global:test = "Local"
"The global value of `$test is $Global:test."

Nach Abschluss des Skripts wird der globale Wert von $test geändert.

PS> $test
Local

Beispiel 4: Erstellen einer privaten Variablen

Eine Variable kann privat gemacht werden, indem man den Private:-Bereichsmodifizierer verwendet oder die Variable mit der -Option erstellt und die Eigenschaft auf Privatefestlegt. Private Variablen können nur im Bereich angezeigt oder geändert werden, in dem sie erstellt wurden.

In diesem Beispiel erstellt das skript ScopeExample.ps1 fünf Funktionen. Die erste Funktion ruft die nächste Funktion auf, die einen untergeordneten Bereich erstellt. Eine der Funktionen verfügt über eine private Variable, die nur im Bereich angezeigt werden kann, in dem sie erstellt wurde.

PS> Get-Content ScopeExample.ps1
# Start of ScopeExample.ps1
function funcA {
    "Setting `$funcAVar1 to 'Value set in funcA'"
    $funcAVar1 = "Value set in funcA"
    funcB
}

function funcB {
    "In funcB before set -> '$funcAVar1'"
    $Private:funcAVar1 = "Locally overwrite the value - child scopes can't see me!"
    "In funcB after set  -> '$funcAVar1'"
    funcC
}

function funcC {
    "In funcC before set -> '$funcAVar1' - should be the value set in funcA"
    $funcAVar1 = "Value set in funcC - Child scopes can see this change."
    "In funcC after set  -> '$funcAVar1'"
    funcD
}

function funcD {
    "In funcD before set -> '$funcAVar1' - should be the value from funcC."
    $funcAVar1 = "Value set in funcD"
    "In funcD after set  -> '$funcAVar1'"
    '-------------------'
    ShowScopes
}

function ShowScopes {
    $funcAVar1 = "Value set in ShowScopes"
    "Scope [0] (local)  `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 0 -ValueOnly)'"
    "Scope [1] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 1 -ValueOnly)'"
    "Scope [2] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 2 -ValueOnly)'"
    "Scope [3] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 3 -ValueOnly)'"
    "Scope [4] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 4 -ValueOnly)'"
}
funcA
# End of ScopeExample.ps1
PS> .\ScopeExample.ps1

Die Ausgabe zeigt den Wert der Variablen in jedem Bereich an. Sie können sehen, dass die private Variable nur in funcB, dem Bereich, in dem sie erstellt wurde, sichtbar ist.

Setting $funcAVar1 to 'Value set in funcA'
In funcB before set -> 'Value set in funcA'
In funcB after set  -> 'Locally overwrite the value - child scopes can't see me!'
In funcC before set -> 'Value set in funcA' - should be the value set in funcA
In funcC after set  -> 'Value set in funcC - Child scopes can see this change.'
In funcD before set -> 'Value set in funcC - Child scopes can see this change.' - should be the value from funcC.
In funcD after set  -> 'Value set in funcD'
-------------------
Scope [0] (local)  $funcAVar1 = 'Value set in ShowScopes'
Scope [1] (parent) $funcAVar1 = 'Value set in funcD'
Scope [2] (parent) $funcAVar1 = 'Value set in funcC - Child scopes can see this change.'
Scope [3] (parent) $funcAVar1 = 'Locally overwrite the value - child scopes can't see me!'
Scope [4] (parent) $funcAVar1 = 'Value set in funcA'

Wie in der Ausgabe von ShowScopesgezeigt, können Sie mithilfe von Get-Variable auf Variablen aus anderen Bereichen zugreifen und eine Bereichsnummer angeben.

Beispiel 5: Verwenden einer lokalen Variablen in einem Remotebefehl

Verwenden Sie für Variablen in einem Remotebefehl, der in der lokalen Sitzung erstellt wurde, den Using: Bereichsmodifizierer. PowerShell geht davon aus, dass die Variablen in Remotebefehlen in der Remotesitzung erstellt wurden.

Die Syntax lautet:

$Using:<VariableName>

Beispielsweise erstellen die folgenden Befehle eine $Cred Variable in der lokalen Sitzung und verwenden dann die $Cred Variable in einem Remotebefehl:

$Cred = Get-Credential
Invoke-Command $s {Remove-Item .\Test*.ps1 -Credential $Using:Cred}

Der Using: Bereichsmodifizierer wurde in PowerShell 3.0 eingeführt.

Siehe auch

  • Last updated on