THEMA
about_assignment_operators
KURZBESCHREIBUNG
Beschreibt, wie Variablen mithilfe von Operatoren Werte
zugewiesen werden.
DETAILBESCHREIBUNG
Mit Zuweisungsoperatoren werden einer Variablen ein oder mehrere Werte
zugewiesen. Vor der Zuweisung können Sie numerische Operationen für
die Werte ausführen.
Windows PowerShell unterstützt die folgenden Zuweisungsoperatoren.
Operator Beschreibung
------- -----------
= Legt den Wert einer Variablen auf den angegebenen Wert fest.
+= Erhöht den Wert einer Variablen um den angegebenen Wert
oder fügt den angegebenen Wert an den vorhandenen Wert an.
-= Verringert den Wert einer Variablen um den angegebenen Wert.
*= Multipliziert den Wert einer Variablen mit dem
angegebenen Wert oder fügt den angegebenen Wert an den
vorhandenen Wert an.
/= Dividiert den Wert einer Variablen durch den
angegebenen Wert.
%= Dividiert den Wert einer Variablen durch den
angegebenen Wert und weist der Variablen den Rest (Modulo) zu.
++ Vergrößert den Wert einer Variablen, einer zuweisbaren
Eigenschaft oder eines Arrayelements um 1.
-- Verringert den Wert einer Variablen, einer zuweisbaren
Eigenschaft oder eines Arrayelements um 1.
SYNTAX
Zuweisungsoperatoren weisen die folgende Syntax auf:
<Zuweisbarer Ausdruck> <Zuweisungsoperator> <Wert>
Zu zuweisbaren Ausdrücken zählen Variablen und Eigenschaften. Bei
dem Wert kann es sich um einen einzelnen Wert, ein Array von
Werten, einen Befehl, einen Ausdruck oder eine Anweisung handeln.
Der Inkrementoperator und der Dekrementoperator sind unäre
Operatoren. Für beide sind eine Präfix- und eine Postfixversion
verfügbar.
<Zuweisbarer Ausdruck><Operator>
<Operator><Zuweisbarer Ausdruck>
Der zuweisbare Ausdruck muss eine Zahl sein oder er muss in eine
Zahl umgewandelt werden können.
ZUWEISEN VON WERTEN
Variablen sind benannte Speicherbereiche, in denen Werte
gespeichert sind. Werte werden mithilfe des Zuweisungsoperators
(=) in Variablen gespeichert. Der neue Wert kann den vorhandenen
Wert der Variablen ersetzen. Sie können jedoch auch einen neuen
Wert an den vorhandenen Wert anfügen.
Der grundlegende Zuweisungsoperator ist das Gleichheitszeichen
(=) (ASCII 61). Mit der folgenden Anweisung wird beispielsweise der
Variablen "$MyShell" der Wert "Windows PowerShell" zugewiesen:
$MyShell = "Windows PowerShell"
Wenn Sie einer Variablen in Windows PowerShell einen Wert
zuweisen, wird die Variable erstellt, sofern sie noch nicht
vorhanden ist. Die erste der folgenden zwei Zuweisungsanweisungen
erstellt die Variable "$a" und weist dieser den Wert 6 zu. Die zweite
Zuweisungsanweisung weist "$a" den Wert 12 zu. Durch die erste
Anweisung wird eine neue Variable erstellt. Die zweite Anweisung
ändert lediglich deren Wert:
$a = 6
$a = 12
Variablen in Windows PowerShell verfügen über keinen bestimmten
Datentyp, es sei, sie werden umgewandelt. Wenn eine Variable nur
ein Objekt enthält, nimmt die Variable den Datentyp des
betreffenden Objekts an. Wenn eine Variable eine Auflistung von
Objekten enthält, weist die Variable den Datentyp "System.Object"
auf. Daher können Sie der Auflistung beliebige Objekttypen
zuweisen. Im folgenden Beispiel wird veranschaulicht, dass einer
Variablen Prozessobjekte, Dienstobjekte, Zeichenfolgen und ganze
Zahlen hinzugefügt werden können, ohne dass ein Fehler generiert
wird:
$a = get-process
$a += get-service
$a += "string"
$a += 12
Da der Zuweisungsoperator (=) eine niedrigere Rangfolge als der
Pipelineoperator (|) hat, sind keine Klammern erforderlich, um
einer Variablen das Ergebnis einer Befehlspipeline zuzuweisen.
Durch den folgenden Befehl werden z. B. die Dienste auf dem
Computer sortiert, und anschließend werden die sortierten Dienste
der Variablen "$a" zugewiesen:
$a = get-service | sort name
Wie im folgenden Beispiel veranschaulicht, können Sie einer
Variablen auch einen von einer Anweisung erstellten Wert zuweisen:
$a = if ($b -lt 0) { 0 } else { $b }
Der Wert 0 wird der Variablen "$a" zugewiesen, wenn der Wert von "$b"
kleiner als 0 ist. Der Wert von "$b" wird "$a" zugewiesen, wenn der
Wert von "$b" nicht kleiner als null ist.
DER ZUWEISUNGSOPERATOR (=)
Mit dem Zuweisungsoperator (=) werden Variablen Werte zugewiesen.
Wenn die Variable bereits über einen Wert verfügt, wird dieser
durch den Zuweisungsoperator (=) ohne entsprechende Warnung ersetzt.
Die folgende Anweisung weist der Variablen "$a" den ganzzahligen
Wert 6 zu:
$a = 6
Wenn Sie einer Variablen einen Zeichenfolgenwert zuweisen
möchten, schließen Sie den Zeichenfolgenwert wie folgt in
Anführungszeichen ein:
$a = "baseball"
Wenn Sie einer Variable ein Array (mehrere Werte) zuweisen
möchten, trennen Sie die Werte wie folgt mit Kommas:
$a = "apple", "orange", "lemon", "grape"
Um einer Variable eine Hashtabelle zuzuweisen, verwenden Sie die
Standardnotation für Hashtabellen in Windows PowerShell. Geben Sie
ein @-Zeichen und anschließend Schlüssel-Wert-Paare ein, die durch
Semikolons (;) getrennt und in geschweifte Klammern ({})
eingeschlossen sind. Wenn Sie beispielsweise der Variablen "$a" eine
Hashtabelle zuweisen möchten, geben Sie Folgendes ein:
$a = @{eins=1; zwei=2; drei=3}
Wenn Sie einer Variablen Hexadezimalwerte zuweisen möchten,
stellen Sie dem Wert "0x" voran. Windows PowerShell konvertiert den
Hexadezimalwert (0x10) in einen Dezimalwert (in diesem Fall in den
Wert 16) und weist der Variablen "$a" diesen Wert zu. Wenn Sie
beispielsweise der Variablen "$a" den Wert 0x10 zuweisen möchten,
geben Sie Folgendes ein:
$a = 0x10
Wenn Sie einer Variablen einen exponentiellen Wert zuweisen
möchten, geben Sie die Basiszahl, den Buchstaben "e" sowie eine
Zahl an, die ein Mehrfaches von 10 darstellt. Wenn Sie der
Variablen "$a" den Wert 3,1415 zur Potenz von 1.000 zuweisen
möchten, geben Sie Folgendes ein:
$a = 3.1415e3
Windows PowerShell kann auch Kilobytes (KB), Megabytes (MB) und
Gigabytes (GB) in Bytes konvertieren. Wenn Sie beispielsweise der
Variablen "$a" einen Wert von 10 Kilobyte zuweisen möchten, geben
Sie Folgendes ein:
$a = 10kb
DER ADDITIONSZUWEISUNGSOPERATOR (+=)
Der Additionszuweisungsoperator (+ =) erhöht entweder den Wert
einer Variablen oder fügt den angegebenen Wert an den vorhandenen
Wert an. Die ausgeführte Aktion hängt davon ab, ob die Variable
einen numerischen Typ oder einen Zeichenfolgentyp aufweist und ob
sie einen einzigen Wert (einen Skalar) oder mehrere Werte (eine
Auflistung) enthält.
Durch den Additionszuweisungsoperator "+=" werden zwei Vorgänge
kombiniert. Zunächst werden eine Addition und anschließend eine
Zuweisung ausgeführt. Daher sind die folgenden Anweisungen äquivalent:
$a += 2
$a = ($a + 2)
Wenn die Variable einen einzigen numerischen Wert enthält, wird
der vorhandene Wert mit dem Operator "+=" um den rechts vom
Operator angegebenen Betrag erhöht. Anschließend weist der
Operator der Variablen den Ergebniswert zu.
Im folgenden Beispiel wird veranschaulicht, wie mit dem Operator
"+=" der Wert einer Variablen erhöht wird:
C:\PS> $a = 4
C:\PS> $a += 2
C:\PS> $a
6
Wenn es sich bei dem Wert der Variablen um eine Zeichenfolge
handelt, wird der Wert rechts vom Operator wie folgt an die
Zeichenfolge angefügt:
C:\PS> $a = "Windows"
C:\PS> $a +- " PowerShell"
C:\PS> $a
Windows PowerShell
Wenn der Wert der Variablen ein Array ist, fügt der Operator "+="
die Werte rechts vom Operator an das Array angefügt. Wenn das
Array nicht durch Umwandlung explizit typisiert ist, können Sie
wie folgt einen beliebigen Werttyp an das Array anfügen:
C:\PS> $a = 1,2,3
C:\PS> $a += 2
C:\PS> $a
1
2
3
2
C:\PS> $a += "String"
C:\PS> $a
1
2
3
2
String
Wenn der Wert einer Variable eine Hashtabelle ist, fügt der
Operator "+=" den Wert rechts vom Operator an die Hashtabelle an.
Da jedoch der einzige Typ, der einer Hashtabelle hinzugefügt
werden kann, eine andere Hashtabelle ist, tritt bei allen anderen
Zuweisungen ein Fehler auf.
Mit dem folgenden Befehl wird z. B. der Variablen "$a" eine
Hashtabelle zugewiesen.
Anschließend wird mithilfe des Operators "+=" eine andere
Hashtabelle an die vorhandene Hashtabelle angefügt, wodurch der
vorhandenen Hashtabelle effektiv ein neues Schlüssel-Wert-Paar
hinzugefügt wird. Wie in der Ausgabe ersichtlich, wird dieser
Befehl erfolgreich ausgeführt:
C:\PS> $a = @{a = 1; b = 2; c = 3}
C:\PS> $a += @{mode = "write"}
C:\PS> $a
Name Value
---- -----
a 1
b 2
mode write
c 3
Mit dem folgenden Befehl wird versucht, an die Hashtabelle in der
Variablen "$a" eine ganze Zahl (1) anzufügen. Dieser Befehl führt
zu einem Fehler:
C:\PS> $a = @{a = 1; b = 2; c = 3}
C:\PS> $a += 1
Eine Hashtabelle kann nur zu einer Hashtabelle addiert werden.
Bei Zeile:1 Zeichen:6
+ $a += <<<< 1
DER SUBTRAKTIONSZUWEISUNGSOPERATOR (-=)
Mit dem Subtraktionszuweisungsoperator (-=) wird der Wert einer
Variablen um den Wert rechts vom Operator verringert.
Dieser Operator kann nicht mit Zeichenfolgenvariablen verwendet
werden. Außerdem können mit dem Operator keine Elemente aus einer
Auflistung entfernt werden.
Durch den Subtraktionszuweisungsoperator "-=" werden zwei Vorgänge
kombiniert. Zunächst werden eine Subtraktion und anschließend eine
Zuweisung ausgeführt. Daher sind die folgenden Anweisungen äquivalent:
$a -= 2
$a = ($a - 2)
Im folgenden Beispiel wird veranschaulicht, wie mit dem Operator
"-=" der Wert einer Variablen verringert wird:
C:\PS> $a = 8
C:\PS> $a -= 2
C:\PS> $a
6
Mit dem Zuweisungsoperator "-=" können Sie auch den Wert des
Elements eines numerischen Arrays verringern. Geben Sie dazu den
Index des Arrayelements an, das Sie ändern möchten. Im folgenden
Beispiel wird der Wert des dritten Elements eines Arrays (Element
2) um 1 verringert:
C:\PS> $a = 1,2,3
C:\PS> $a[2] -= 1.
C:\PS> $a
1
2
2
Mit dem Operator "-=" können nicht die Werte einer Variablen
gelöscht werden. Wenn Sie alle einer Variablen zugewiesenen Werte
löschen möchten, weisen Sie der Variablen mit dem Cmdlet
"Clear-Item" oder dem Cmdlet "Clear-Variable" den Wert $null bzw.
"" zu.
$a = $null
Wenn Sie einen bestimmten Wert aus einem Array löschen möchten,
weisen Sie dem betreffenden Element mithilfe der Arraynotation
den Wert $null zu. Mit der folgenden Anweisung wird z. B. der
zweite Wert (Indexposition 1) aus einem Array gelöscht:
C:\PS> $a = 1,2,3
C:\PS> $a
1
2
3
C:\PS> $a[1] = $null
C:\PS> $a
1
3
Löschen Sie eine Variable mit dem Cmdlet "Remove-Variable". Diese
Methode ist hilfreich, wenn die Variable explizit in einen
bestimmten Datentyp umgewandelt wurde und eine nicht typisierte
Variable erhalten werden soll. Mit dem folgenden Befehl wird die
Variable "$a" gelöscht:
remove-variable a
DER MULTIPLIKATIONSZUWEISUNGSOPERATOR (*=) Der Multiplikationszuweis
ungsoperator (*=) multipliziert einen numerischen Wert oder fügt
die angegebene Anzahl von Kopien des Zeichenfolgenwerts an eine
Variable an.
Wenn eine Variable einen einzigen numerischen Wert enthält, wird
dieser mit dem rechts vom Operator angegebenen Betrag
multipliziert. Im folgenden Beispiel wird veranschaulicht, wie
der Wert einer Variablen mit dem Operator "*=" multipliziert wird:
C:\PS> $a = 3
C:\PS> $a *= 4
C:\PS> $a
12
In diesem Fall werden durch den Operator "*=" zwei Vorgänge
kombiniert. Zunächst werden eine Multiplikation und anschließend eine
Zuweisung ausgeführt. Daher sind die folgenden Anweisungen äquivalent:
$a *= 2
$a = ($a * 2)
Wenn eine Variable einen Zeichenfolgenwert enthält, wird von
Windows PowerShell wie folgt die angegebene Anzahl von
Zeichenfolgen an den Wert angefügt:
C:\PS> $a = "file"
C:\PS> $a *= 4
C:\PS> $a
filefilefilefile
Wenn Sie ein Element eines Arrays multiplizieren möchten, geben
Sie das zu multiplizierende Element anhand des Index an. Mit dem
folgenden Befehl wird beispielsweise das erste Element im Array
(Indexposition 0) mit 2 multipliziert:
$a[0] *= 2
DER DIVISIONSZUWEISUNGSOPERATOR (/=)
Der Divisionszuweisungsoperator (/=) dividiert einen numerischen
Wert durch den auf der rechten Seite des Operators angegebenen
Wert. Dieser Operator kann nicht mit Zeichenfolgenvariablen
verwendet werden.
Durch den Divisionszuweisungsoperator "/=" werden zwei Vorgänge
kombiniert. Zunächst werden eine Division und anschließend eine
Zuweisung ausgeführt. Daher sind die folgenden beiden Anweisungen
äquivalent:
$a /= 2
$a = ($a / 2)
Im folgenden Befehl wird beispielsweise mit dem Operator "/=" der
Wert einer Variablen dividiert:
C:\PS> $a = 8
C:\PS> $a /=2
C:\PS> $a
4
Wenn Sie ein Element eines Arrays dividieren möchten, geben Sie
das gewünschte Element über den Index an. Mit dem folgenden
Befehl wird beispielsweise das zweite Element im Array
(Indexposition 1) durch 2 dividiert:
$a[1] /= 2
DER MODULOZUWEISUNGSOPERATOR (%=)
Mit dem Modulozuweisungsoperator (%=) wird der Wert einer
Variablen durch den Wert rechts vom Operator dividiert.
Anschließend weist der Operator "%=" der Variablen den Rest
(Modulo) zu. Dieser Operator kann nur angegeben werden, wenn eine
Variable einen einzigen numerischen Wert enthält. Dieser Operator
kann nicht verwendet werden, wenn eine Variable eine
Zeichenfolgenvariable oder ein Array enthält.
Durch den Operator "%=" werden zwei Vorgänge kombiniert. Zunächst
wird eine Division ausgeführt, und der Rest wird bestimmt, der
anschließend der Variablen zugewiesen wird. Daher sind die
folgenden Anweisungen äquivalent:
$a %= 2
$a = ($a % 2)
Im folgenden Beispiel wird veranschaulicht, wie mit dem Operator
"%=" der Modulo eines Quotienten gespeichert wird:
C:\PS> $a = 7
C:\PS> $a %= 4
C:\PS> $a
3
DER INKREMENTOPERATOR UND DER DEKREMENTOPERATOR
Der Inkrementoperator (++) vergrößert den Wert einer Variablen um
1. Wenn Sie den Inkrementoperator in einer einfachen Anweisung
verwenden, wird kein Wert zurückgegeben.
Wenn Sie das Ergebnis anzeigen möchten, zeigen Sie den Wert der
Variablen wie folgt an:
C:\PS> $a = 7
C:\PS> ++$a
C:\PS> $a
8
Um die Rückgabe eines Werts zu erzwingen, schließen Sie die
Variable und den Operator wie folgt in Klammern ein:
C:\PS> $a = 7
C:\PS> (++$a)
8
Der Inkrementoperator kann vor einer Variablen (Präfix) oder nach
einer Variablen (Postfix) platziert werden. Mit der Präfixversion
des Operators wird eine Variable vor der Verwendung ihres Werts
in der Anweisung wie folgt inkrementiert:
C:\PS> $a = 7
C:\PS> $c = ++$a
C:\PS> $a
8
C:\PS> $c
8
Mit der Postfixversion des Operators wird eine Variable inkrementiert,
nachdem ihr Wert in der Anweisung verwendet wurde. Im folgenden
Beispiel weisen die Variablen "$c" und "$a" unterschiedliche Werte
auf, da "$c" der Wert zugewiesen wird, bevor "$a" geändert wird:
C:\PS> $a = 7
C:\PS> $c = $a++
C:\PS> $a
8
C:\PS> $c
7
Durch den Dekrementoperator (--) wird den Wert einer Variablen um
1 verringert. Wie beim Inkrementoperator wird kein Wert
zurückgegeben, wenn der Operator in einer einfachen Anweisung
verwendet wird. Stellen Sie mithilfe von Klammern sicher, dass
ein Wert zurückgegeben wird:
C:\PS> $a = 7
C:\PS> --$a
C:\PS> $a
6
C:\PS> (--$a)
5
Mit der Präfixversion des Operators wird eine Variable vor der
Verwendung ihres Werts in der Anweisung wie folgt dekrementiert:
C:\PS> $a = 7
C:\PS> $c = --$a
C:\PS> $a
6
C:\PS> $c
6
Mit der Postfixversion des Operators wird eine Variable dekrementiert,
nachdem ihr Wert in der Anweisung verwendet wurde. Im folgenden
Beispiel weisen die Variablen "$d" und "$a" unterschiedliche Werte
auf, da "$d" der Wert zugewiesen wird, bevor "$a" geändert wird:
C:\PS> $a = 7
C:\PS> $d = $a--
C:\PS> $a
6
C:\PS> $d
7
MICROSOFT .NET FRAMEWORK-TYPEN
Wenn eine Variable über nur einen Wert verfügt, wird der Datentyp
der Variablen standardmäßig durch den der Variablen zugewiesenen
Wert bestimmt. Mit dem folgenden Befehl wird z. B. eine Variable
erstellt, die über einen Ganzzahltyp ("System.Int32") verfügt:
$a = 6
Bestimmen Sie mit der GetType-Methode und deren FullName-Eigenscha
ft den .NET Framework-Typ einer Variablen. Die Klammern nach dem
Namen der GetType-Methode müssen angegeben werden, selbst wenn
der Methodenaufruf über keine Argumente verfügt:
C:\PS> $a = 6
C:\PS> $a.gettype().fullname
System.Int32
Weisen Sie der Variablen einen Zeichenfolgenwert zu, um eine
Variable zu erstellen, die eine Zeichenfolge enthält. Um
anzugeben, dass es sich bei dem Wert um eine Zeichenfolge
handelt, schließen Sie ihn wie folgt in Anführungszeichen ein:
C:\PS> $a = "6"
C:\PS> $a.gettype().fullname
System.String
Wenn der erste der Variablen zugewiesene Wert eine Zeichenfolge
darstellt, werden von Windows PowerShell alle Operationen als
Zeichenfolgenoperationen behandelt, und neue Werte werden in
Zeichenfolgen umgewandelt. Dies wird im folgenden Beispiel
veranschaulicht:
C:\PS> $a = "file"
C:\PS> $a += 3
C:\PS> $a
file3
Wenn der erste Wert eine ganze Zahl darstellt, werden von Windows
PowerShell alle Operationen als Ganzzahloperationen behandelt,
und neue Werte werden in ganze Zahlen umgewandelt. Dies wird im
folgenden Beispiel veranschaulicht:
C:\PS> $a = 6
C:\PS> $a += "3"
C:\PS> $a
9
Sie können eine neue Skalarvariable in einen beliebigen .NET
Framework-Datentyp umwandeln, indem Sie den Typnamen in Klammern
einschließen, auf die der Variablenname oder der erste
Zuweisungswert folgt. Beim Umwandeln einer Variablen können Sie
die Typen der Daten bestimmen, die in der Variablen gespeichert
werden können. Darüber hinaus können Sie das Verhalten der
Variablen beim Bearbeiten bestimmen.
Beispielsweise wird die Variable durch den folgenden Befehl in
einen Zeichenfolgentyp umgewandelt:
C:\PS> [string]$a = 27
C:\PS> $a += 3
C:\PS> $a
273
Im folgenden Beispiel wird der erste Wert anstelle der Variablen
umgewandelt:
$a = [string]27
Beim Umwandeln einer Variablen in einen spezifischen Typ wird
normalerweise die Variable und nicht der Wert umgewandelt. Sie
können jedoch den Datentyp einer vorhandenen Variablen nicht erneut
umwandeln, wenn ihr Wert nicht in den neuen Datentyp konvertiert
werden kann. Wenn der Datentyp geändert werden soll, muss ihr Wert
wie folgt ersetzt werden:
C:\PS> $a = "string"
C:\PS> [int]$a
Der Wert "string" kann nicht in den Typ "System.Int32" konvertiert
werden. Fehler: "Die Eingabezeichenfolge hat das falsche Format."
Bei Zeile:1 Zeichen:8
+ [int]$a <<<<
C:\PS> [int]$a =3
Außerdem wird durch Voranstellen eines Datentyps vor einen
Variablennamen der Typ der betreffenden Variablen gesperrt, es
sei denn, der Typ wird explizit durch Angabe eines anderen
Datentyps überschrieben. Wenn Sie einen Wert zuweisen, der mit
dem vorhandenen Typ inkompatibel ist und Sie diesen Typ nicht
explizit überschreiben, wird von Windows PowerShell ein Fehler
ausgegeben, wie im folgenden Beispiel veranschaulicht:
C:\PS> $a = 3
C:\PS> $a = "string"
C:\PS> [int]$a = 3
C:\PS> $a = "string"
Der Wert "string" kann nicht in den Typ "System.Int32" konvertiert
werden. Fehler: "Die Eingabezeichenfolge hat das falsche Format."
Bei Zeile:1 Zeichen:3
+ $a <<<< = "string"
C:\PS> [string]$a = "string"
In Windows PowerShell werden die Datentypen von Variablen mit
mehreren Elementen in einem Array anders als die Datentypen von
Variablen behandelt, die nur ein einziges Element enthalten. Wenn
ein Datentyp keiner spezifischen Arrayvariablen zugewiesen ist,
handelt es sich immer um den Datentyp "System.Object []". Dieser
Datentyp ist für Arrays spezifisch.
Gelegentlich können Sie den Standardtyp durch Angabe eines
anderen Datentyps überschreiben. Beispielsweise wird durch den
folgenden Befehl die Variable in den Arraytyp "string[]" umgewandelt:
[string []] $a = "eins", "zwei", "drei"
Windows PowerShell-Variablen können jeden beliebigen .NET
Framework-Datentyp aufweisen. Außerdem können Sie jeden
vollqualifizierten .NET Framework-Datentyp zuweisen, der im
aktuellen Prozess verfügbar ist. Beispielsweise wird durch den
folgenden Befehl der Typ "System.DateTime" angegeben:
[system.datetime]$a = "31.5.2005"
Der Variablen wird ein Wert zugewiesen, der dem Typ
"System.Datetime" entspricht. Dadurch wird der folgende Wert für
die Variable "$a" erhalten:
Dienstag, 31. Mai 2005, 00:00:00
ZUWEISEN MEHRERER VARIABLEN
In Windows PowerShell können Sie mit einem einzigen Befehl
mehreren Variablen Werte zuweisen. Das erste Element der
Zuweisungsvariablen wird der ersten Variablen zugewiesen, das
zweite Element wird der zweiten Variablen zugewiesen, das dritte
Element der dritten Variablen usw. Mit dem folgenden Befehl wird
z. B. der Variablen "$a" der Wert 1, der Variablen "$b" der Wert
2 und der Variablen "$c" der Wert 3 zugewiesen:
C:\PS> $a, $b, $c = 1, 2, 3
Wenn der Zuweisungswert mehr Elemente enthält, als Variablen
vorhanden sind, werden alle verbleibenden Werte der letzten
Variablen zugewiesen. Der folgende Befehl enthält beispielsweise
drei Variablen und fünf Werte.
$a, $b, $c = 1, 2, 3, 4, 5
Daher wird in Windows PowerShell der Variablen "$a" der Wert 1 und der
Variablen "$b" der Wert 2 zugewiesen. Der Variablen "$c" werden die
Werte 3, 4 und 5 zugewiesen. Wenn Sie die Werte in der Variablen "$c"
drei anderen Variablen zuweisen möchten, verwenden Sie das folgende
Format:
$d, $e, $f = $c
Mit diesem Befehl wird der Variablen "$d" der Wert 3, der
Variablen "$e" der Wert 4 und der Variablen "$f" der Wert 5
zugewiesen.
Sie können mehreren Variablen auch einen Wert zuweisen, indem Sie die
Variablen verketten. Beispielsweise wird durch den folgenden Befehl
allen vier Variablen der Wert "drei" zugewiesen.
$a = $b = $c = $d = "drei"
VARIABLENBEZOGENE CMDLETS
Neben dem Festlegen von Variablenwerten durch Zuweisungsoperatione
n können Sie auch das Cmdlet "Set-Variable" verwenden.
Beispielsweise wird im folgenden Befehl mit "Set-Variable" der
Variablen "$a" das Array 1, 2, 3 zugewiesen.
Set-Variable -name a -value 1, 2, 3
SIEHE AUCH
about_Arrays
about_Hash_Tables
about_Variables
Clear-Variable
Remove-Variable
Set-Variable