about_Assignment_Operators
Letzte Aktualisierung: Mai 2014
Betrifft: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Einführung hier einfügen.
THEMA
about_assignment_operators
KURZE BESCHREIBUNG
Beschreibt, wie Operatoren verwendet werden, um Variablen Werte zuweisen.
LANGE BESCHREIBUNG
Zuweisungsoperatoren weisen einer Variablen einen oder mehrere Werte zu. Sie können vor der Zuweisung numerische Operationen mit den Werten durchführen.
Windows PowerShell® unterstützt die folgenden Zuweisungsoperatoren.
Operator Description
------- -----------
= Sets the value of a variable to the specified value.
+= Increases the value of a variable by the specified value, or
appends the specified value to the existing value.
-= Decreases the value of a variable by the specified value.
*= Multiplies the value of a variable by the specified value, or
appends the specified value to the existing value.
/= Divides the value of a variable by the specified value.
%= Divides the value of a variable by the specified value and
then assigns the remainder (modulus) to the variable.
++ Increases the value of a variable, assignable property, or
array element by 1.
-- Decreases the value of a variable, assignable property, or
array element by 1.
SYNTAX
Die Syntax der Zuweisungsoperatoren lautet wie folgt:
<assignable-expression> <assignment-operator> <value>
Zuweisbare Ausdrücke enthalten Variablen und Eigenschaften. Der Wert kann ein einzelner Wert, ein Array von Werten oder ein Befehl, ein Ausdruck oder eine Anweisung sein.
Die Operatoren zum Inkrementieren und Dekrementieren sind unäre Operatoren. Jeder verfügt über Präfix- und Postfixversionen.
<assignable-expression><operator>
<operator><assignable-expression>
Der zuweisbare Ausdruck muss eine Zahl oder in eine Zahl konvertierbar sein.
ZUWEISEN VON WERTEN
Variablen sind benannte Speicherbereiche, die Werte speichern. Mithilfe des Zuweisungsoperators (=) speichern Sie die Werte in Variablen. Der neue Wert kann den vorhandenen Wert der Variablen ersetzen, oder Sie können dem vorhandenen Wert einen neuen Wert anfügen.
Der grundlegende Zuweisungsoperator ist das Gleichheitszeichen (=) (ASCII-61). Die folgende Anweisung weist z. B. den Wert Windows PowerShell der Variablen „$MyShell“ zu:
$MyShell = "Windows PowerShell"
Wenn Sie einer Variablen in Windows PowerShell einen Wert zuzuweisen, wird die Variable erstellt, wenn sie nicht bereits vorhanden ist. Die erste der beiden folgenden Zuweisungsanweisungen erstellt z. B. die Variable „$a“ und weist ihr den Wert 6 zu. Die zweite Zuweisungsanweisung weist „$a“ den Wert 12 zu. Die erste Anweisung erstellt eine neue Variable. Die zweite Anweisung ändert nur deren Wert:
$a = 6
$a = 12
Variablen in Windows PowerShell haben erst dann einen bestimmten Datentyp, wenn Sie sie umwandeln. Wenn eine Variable nur ein Objekt enthält, übernimmt die Variable den Datentyp des Objekts. Wenn eine Variable eine Auflistung von Objekten enthält, hat die Variable den Datentyp „System.Object“. Aus diesem Grund können Sie der Auflistung jede Art von Objekt zuweisen. Das folgende Beispiel zeigt, dass Sie Prozessobjekte, Dienstobjekte, Zeichenfolgen und Ganzzahlen einer Variable hinzufügen können, ohne einen Fehler hervorzurufen:
$a = get-process
$a += get-service
$a += "string"
$a += 12
Da der Zuweisungsoperator (=) einen niedrigeren Rang hat als der Pipelineoperator (|), sind keine Klammern erforderlich, um das Ergebnis einer Befehlspipeline einer Variablen zuzuweisen. Beispielsweise sortiert der folgende Befehl die Dienste auf dem Computer und weist dann die sortierten Dienste der Variablen „$a“ zu:
$a = get-service | sort name
Sie können auch den von einer Anweisung erstellten Wert wie im folgenden Beispiel einer Variablen zuweisen:
$a = if ($b -lt 0) { 0 } else { $b }
In diesem Beispiel wird 0 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 0 ist.
DER ZUWEISUNGSOPERATOR (=)
Der Zuweisungsoperator (=) weist Variablen Werte zu. Wenn die Variable bereits einen Wert besitzt, ersetzt der Zuweisungsoperator (=) den Wert ohne Warnung.
Die folgende Anweisung weist den Ganzzahlwert 6 der Variablen „$a“ zu:
$a = 6
Um einer Variablen einen Zeichenfolgenwert zuzuweisen, müssen Sie den Zeichenfolgenwert wie folgt in Anführungszeichen setzen:
$a = "baseball"
Um einer Variablen ein Array (mehrere Werte) zuzuweisen, trennen Sie die Werte wie folgt mit Kommas:
$a = "apple", "orange", "lemon", "grape"
Um einer Variablen eine Hashtabelle zuzuweisen, verwenden Sie die standardmäßige Hashtabellenotation in Windows PowerShell. Geben Sie ein At-Zeichen (@) gefolgt von Schlüssel-/Wertpaaren ein, die durch Semikolons (;) voneinander getrennt und in geschweifte Klammern ({}) eingeschlossen sind. Um z. B. der Variablen „$a“ eine Hashtabelle zuzuweisen, geben Sie Folgendes ein:
$a = @{one=1; two=2; three=3}
Um einer Variablen Hexadezimalwerte zuzuweisen, stellen Sie dem Wert „0x“ voran. Windows PowerShell wandelt den Hexadezimalwert (0x10) in einen Dezimalwert um (in diesem Fall 16) und weist diesen Wert der Variablen „$a“ zu. Um z. B. der Variablen „$a“ einen Wert von 0x10 zuzuweisen, geben Sie Folgendes ein:
$a = 0x10
Um einer Variablen einen Exponentialwert zuzuweisen, geben Sie die Mantisse, den Buchstaben „e“ und eine Zahl ein, die eine Zehnerpotenz darstellt. Um z. B. der Variablen „$a“ den Wert 3,1415 mit 1.000 multipliziert zuzuweisen, geben Sie Folgendes ein:
$a = 3.1415e3
Windows PowerShell kann auch Kilobytes (KB), Megabytes (MB) oder Gigabytes (GB) in Bytes konvertieren. Um z. B. der Variablen „$a“ einen Wert von 10 Kilobytes zuzuweisen, geben Sie Folgendes ein:
$a = 10kb
DIE ZUWEISUNG MIT ADDITIONSOPERATOR (+=)
Die Zuweisung mit Additionsoperator (+=) inkrementiert den Wert einer Variablen oder fügt den angegebenen Wert dem vorhandenen Wert an. Die Aktion ist davon abhängig, ob die Variable einen numerischen oder Zeichenfolgentyp aufweist, und ob die Variable einen einzelnen Wert (einen Skalar) oder mehrere Werte (eine Auflistung) enthält.
Der +=-Operator kombiniert zwei Operationen. Er fügt hinzu und weist dann zu. Aus diesem Grund sind die folgenden Anweisungen äquivalent:
$a += 2
$a = ($a + 2)
Wenn die Variable einen einzelnen numerischen Wert enthält, inkrementiert der +=-Operator den vorhandenen Wert mit dem Betrag auf der rechten Seite des Operators. Anschließend weist der Operator den resultierenden Wert der Variablen zu. Das folgende Beispiel zeigt, wie Sie mithilfe des +=-Operators den Wert einer Variablen heraufsetzen:
C:\PS> $a = 4
C:\PS> $a += 2
C:\PS> $a
6
Wenn der Wert der Variablen eine Zeichenfolge ist, wird der Wert auf der rechten Seite des Operators wie folgt der 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 auf der rechten Seite des Operators dem Array an. Sofern das Array nicht explizit durch Umwandlung typisiert ist, können Sie sämtliche Typen von Werten wie folgt dem 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 Variablen eine Hashtabelle ist, fügt der +=-Operator den Wert auf der rechten Seite des Operators der Hashtabelle an. Da jedoch der einzige Typ, den Sie einer Hashtabelle anfügen können, eine andere Hashtabelle ist, schlagen alle anderen Zuweisungen fehl.
Der folgende Befehl weist z. B. der Variablen „$a“ eine Hashtabelle zu. Anschließend fügt er mit dem +=-Operator an die vorhandene Hashtabelle eine weitere Hashtabelle an, wobei er tatsächlich der vorhandenen Hashtabelle ein neues Schlüssel-/Wertpaar hinzufügt. Dieser Befehl wird erfolgreich ausgeführt, wie in der Ausgabe angezeigt:
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
Der folgende Befehl versucht, der Hashtabelle in der Variablen „$a“ eine Ganzzahl (1) anzufügen. Dieser Befehl schlägt fehl:
C:\PS> $a = @{a = 1; b = 2; c = 3}
C:\PS> $a += 1
You can add another hash table only to a hash table.
At line:1 char:6
+ $a += <<<< 1
ZUWEISUNG MIT SUBTRAKTIONSOPERATOR (-=)
Die Zuweisung mit Subtraktionsoperator (-=) dekrementiert den Wert einer Variablen mit dem Wert, der auf der rechten Seite des Operators angegeben ist. Dieser Operator kann weder mit Zeichenfolgenvariablen noch dazu verwendet werden, um ein Element aus einer Auflistung zu entfernen.
Der -=-Operator kombiniert zwei Operationen. Er subtrahiert und weist dann zu. Aus diesem Grund sind die folgenden Anweisungen äquivalent:
$a -= 2
$a = ($a - 2)
Das folgende Beispiel zeigt, wie Sie mithilfe des -=-Operators den Wert einer Variablen herabsetzen:
C:\PS> $a = 8
C:\PS> $a -= 2
C:\PS> $a
6
Sie können mit dem -=-Zuweisungsoperator auch den Wert eines Elements eines numerischen Arrays herabsetzen. Geben Sie hierzu 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
Sie können den -=-Operator nicht verwenden, um die Werte einer Variablen zu löschen. Um alle Werte zu löschen, die einer Variablen zugewiesen sind, verwenden Sie das Cmdlet „Clear-Item“ oder „Clear-Variable“, um der Variablen den Wert „$null“ oder „“ zuzuweisen.
$a = $null
Um einen bestimmten Wert aus einem Array zu löschen, verwenden Sie Arraynotation, um dem entsprechenden Element den Wert „$null“ zuzuweisen. Die folgende Anweisung löscht beispielsweise den zweiten Wert (die Indexposition 1) aus einem Array:
C:\PS> $a = 1,2,3
C:\PS> $a
1
2
3
C:\PS> $a[1] = $null
C:\PS> $a
1
3
Um eine Variable zu löschen, verwenden Sie das Cmdlet „Remove-Variable“. Diese Methode ist nützlich, wenn die Variable explizit in einen bestimmten Datentyp umgewandelt wird, und Sie eine nicht typisierte Variable wünschen. Der folgende Befehl löscht die Variable „$a“:
remove-variable a
DIE ZUWEISUNG MIT MULTIPLIKATIONSOPERATOR (*=)
Die Zuweisung mit Multiplikationsoperator (* =) multipliziert einen numerischen Wert oder fügt die angegebene Anzahl von Kopien an den Zeichenfolgenwert einer Variablen an.
Wenn eine Variable einen einzelnen numerischen Wert enthält, wird dieser Wert mit dem Wert auf der rechten Seite des Operators multipliziert. Das folgende Beispiel zeigt, wie Sie mit dem *=-Operator den Wert einer Variablen multiplizieren:
C:\PS> $a = 3
C:\PS> $a *= 4
C:\PS> $a
12
In diesem Fall kombiniert der *=-Operator zwei Operationen. Er multipliziert und weist dann zu. Aus diesem Grund sind die folgenden Anweisungen äquivalent:
$a *= 2
$a = ($a * 2)
Wenn eine Variable einen Zeichenfolgenwert enthält, fügt Windows PowerShell die angegebene Anzahl von Zeichenfolgen wie folgt an den Wert an:
C:\PS> $a = "file"
C:\PS> $a *= 4
C:\PS> $a
filefilefilefile
Um ein Element eines Arrays zu multiplizieren, verwenden Sie einen Index, um das Element zu identifizieren, das Sie multiplizieren möchten. Der folgende Befehl multipliziert beispielsweise das erste Element im Array (die Indexposition 0) mit 2:
$a[0] *= 2
DIE ZUWEISUNG MIT DIVISIONSOPERATOR (/=)
Die Zuweisung mit Divisionsoperator (/ =) teilt einen numerischen Wert durch den Wert, der auf der rechten Seite des Operators angegeben ist. Der Operator kann nicht mit Zeichenfolgenvariablen verwendet werden.
Der /=-Operator kombiniert zwei Operationen. Er dividiert und weist dann zu. Aus diesem Grund sind die folgenden beiden Anweisungen äquivalent:
$a /= 2
$a = ($a / 2)
Der folgende Befehl verwendet beispielsweise den /=-Operator, um den Wert einer Variablen zu teilen:
C:\PS> $a = 8
C:\PS> $a /=2
C:\PS> $a
4
Um ein Element eines Arrays zu dividieren, verwenden Sie einen Index, um das Element zu identifizieren, das Sie ändern möchten. Der folgende Befehl dividiert beispielsweise das zweite Element im Array (die Indexposition 1) durch 2:
$a[1] /= 2
DIE ZUWEISUNG MIT MODULOOPERATOR (%=)
Die Zuweisung mit Modulooperator (% =) dividiert den Wert einer Variablen durch den Wert auf der rechten Seite des Operators. Dann weist der %=-Operator den („Modulo“ genannten) Rest der Variablen zu. Sie können diesen Operator nur verwenden, wenn eine Variable einen einzelnen numerischen Wert enthält. Sie können diesen Operator nicht verwenden, wenn eine Variable eine Zeichenfolgenvariable oder ein Array enthält.
Der %=-Operator kombiniert zwei Operationen. Er dividiert, bestimmt den Rest und weist ihn der Variablen zu. Aus diesem Grund sind die folgenden Anweisungen äquivalent:
$a %= 2
$a = ($a % 2)
Das folgende Beispiel zeigt, wie Sie mit dem %=-Operator den Modulo eines Quotienten speichern:
C:\PS> $a = 7
C:\PS> $a %= 4
C:\PS> $a
3
DIE OPERATOREN ZUM INKREMENTIEREN UND DEKREMENTIEREN
Der Inkrementoperator (++) setzt den Wert einer Variablen um 1 herauf. Wenn Sie den Inkrementoperator in einer einfachen Anweisung verwenden, wird kein Wert zurückgegeben. Um das Ergebnis zu sehen, 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 (Präfix) oder hinter (Postfix) einer Variablen platziert werden. Die Präfixversion des Operators inkrementiert eine Variable, bevor ihr Wert in der Anweisung verwendet wird, wie folgt:
C:\PS> $a = 7
C:\PS> $c = ++$a
C:\PS> $a
8
C:\PS> $c
8
Die Postfixversion des Operators inkrementiert eine Variable, nachdem ihr Wert in der Anweisung verwendet wird. Im folgenden Beispiel haben die Variablen „$c“ und „$a“ unterschiedliche Werte, da der Wert „$c“ zugewiesen wird, bevor „$a“ geändert wird:
C:\PS> $a = 7
C:\PS> $c = $a++
C:\PS> $a
8
C:\PS> $c
7
Der Dekrementoperator (--) setzt den Wert einer Variablen um 1 herab. Wie beim Inkrementoperator wird kein Wert zurückgegeben, wenn Sie den Operator in einer einfachen Anweisung verwenden. Verwenden Sie Klammern wie folgt, um einen Wert zurückgeben:
C:\PS> $a = 7
C:\PS> --$a
C:\PS> $a
6
C:\PS> (--$a)
5
Die Präfixversion des Operators dekrementiert eine Variable, bevor ihr Wert in der Anweisung verwendet wird, wie folgt:
C:\PS> $a = 7
C:\PS> $c = --$a
C:\PS> $a
6
C:\PS> $c
6
Die Postfixversion des Operators dekrementiert eine Variable, nachdem ihr Wert in der Anweisung verwendet wird. Im folgenden Beispiel haben die Variablen „$d“ und „$a“ unterschiedliche Werte, da der Wert „$d“ 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 nur einen Wert hat, bestimmt standardmäßig der Wert, der der Variablen zugewiesen ist, deren Datentyp. Der folgende Befehl erstellt z. B. eine Variable mit Ganzzahltyp (System.Int32):
$a = 6
Um den .NET Framework-Typ einer Variablen zu finden, verwenden Sie wie folgt die Methode „GetType“ und deren Eigenschaft „FullName“. Schließen Sie unbedingt die Klammern nach dem Methodennamen „GetType“ ein, obwohl der Aufruf der Methode keine Argumente annimmt:
C:\PS> $a = 6
C:\PS> $a.gettype().fullname
System.Int32
Um eine Variable zu erstellen, die eine Zeichenfolge enthält, weisen Sie der Variablen einen Zeichenfolgenwert zu. Um anzugeben, dass der Wert eine Zeichenfolge ist, schließen Sie ihn wie folgt in Anführungszeichen ein:
C:\PS> $a = "6"
C:\PS> $a.gettype().fullname
System.String
Wenn der erste Wert, der der Variablen zugewiesen wird, eine Zeichenfolge ist, behandelt Windows PowerShell alle Operationen als Zeichenfolgenoperationen und wandelt neue Werte in Zeichenfolgen um. Dies tritt in folgendem Beispiel auf:
C:\PS> $a = "file"
C:\PS> $a += 3
C:\PS> $a
file3
Der erste Wert ist eine ganze Zahl, Windows PowerShell behandelt alle Operationen als Ganzzahloperationen und wandelt neue Werte in ganze Zahlen um. Dies tritt in folgendem Beispiel auf:
C:\PS> $a = 6
C:\PS> $a += "3"
C:\PS> $a
9
Um eine neue skalare Variable in einen beliebigen .NET Framework-Typ umzuwandeln, setzen Sie den Typnamen in Klammern, der entweder dem Namen der Variablen oder dem ersten Zuweisungswert vorangestellt ist. Wenn Sie eine Variable umwandeln, können Sie die Datentypen bestimmen, die in der Variablen gespeichert werden können. Außerdem können Sie bestimmen, wie sich die Variable verhält, wenn Sie sie bearbeiten.
Beispielsweise wandelt der folgende Befehl die Variable in einen Zeichenfolgentyp um:
C:\PS> [string]$a = 27
C:\PS> $a += 3
C:\PS> $a
273
Im folgenden Beispiel wird statt der Variablen der erste Wert umgewandelt:
$a = [string]27
Wenn Sie eine Variable in einen bestimmten Typ umwandeln, wird gemäß allgemeiner Konvention die Variable, nicht der Wert umgewandelt. Allerdings können Sie nicht den Datentyp einer vorhandenen Variablen rückumwandeln, wenn ihr Wert nicht in den neuen Datentyp konvertiert werden kann. Um den Datentyp zu ändern, müssen Sie seinen Wert wie folgt ersetzen:
C:\PS> $a = "string"
C:\PS> [int]$a
Cannot convert value "string" to type "System.Int32". Error: "Input
string was not in a correct format."
At line:1 char:8
+ [int]$a <<<<
C:\PS> [int]$a =3
Wenn Sie einem Variablennamen einen Datentyp voranstellen, ist außerdem der Typ dieser Variablen gesperrt, solange Sie den Typ nicht explizit überschreiben, indem Sie einen anderen Datentyp angeben. Wenn Sie versuchen, einen Wert zuzuweisen, der nicht mit dem vorhandenen Typ kompatibel ist, und den Typ nicht explizit überschreiben, zeigt Windows PowerShell einen Fehler an, wie im folgenden Beispiel gezeigt:
C:\PS> $a = 3
C:\PS> $a = "string"
C:\PS> [int]$a = 3
C:\PS> $a = "string"
Cannot convert value "string" to type "System.Int32". Error: "Input
string was not in a correct format."
At line:1 char:3
+ $a <<<< = "string"
C:\PS> [string]$a = "string"
In Windows PowerShell werden die Datentypen von Variablen, die mehrere Elemente in einem Array enthalten, anders behandelt als Datentypen von Variablen, die ein einzelnes Element enthalten. Solange ein Datentyp nicht speziell einer Arrayvariablen zugewiesen ist, ist der Datentyp immer „System.Object []“. Dieser Datentyp ist spezifisch für Arrays.
Manchmal können Sie den Standardtyp überschreiben, indem Sie einen anderen Typ angeben. Beispielsweise wandelt der folgende Befehl die Variable in einen Zeichenfolgenarraytyp „[]“ um:
[string []] $a = "one", "two", "three"
Windows PowerShell-Variablen können jeden .NET Framework-Datentyp haben. Darüber hinaus können Sie jeden vollqualifizierten .NET Framework-Datentyp zuweisen, der im aktuellen Prozess verfügbar ist. Der folgende Befehl gibt z. B. einen System.DateTime-Datentyp an:
[system.datetime]$a = "5/31/2005"
Der Variablen wird ein Wert zugewiesen, der dem System.DateTime-Datentyp entspricht. Der Wert der Variablen „$a“ würde folgendermaßen lauten:
Tuesday, May 31, 2005 12:00:00 AM
ZUWEISEN MEHRERER VARIABLEN
In Windows PowerShell können Sie mit einem einzelnen Befehl mehreren Variablen Werte zuweisen. Das erste Element des Zuweisungswerts wird der ersten Variablen zugewiesen, das zweite Element der zweiten Variablen, das dritte Element der dritten Variablen usw. Der folgende Befehl weist beispielsweise den Wert 1 der Variablen „$a“, den Wert 2 der Variablen „$b“ und den Wert 3 der Variablen „$c“ zu:
C:\PS> $a, $b, $c = 1, 2, 3
Wenn der Zuweisungswert mehr Elemente als Variablen enthält, werden alle verbleibenden Werte der letzten Variablen zugewiesen. Der folgende Befehl enthält z. B. drei Variablen und fünf Werte:
$a, $b, $c = 1, 2, 3, 4, 5
Aus diesem Grund weist Windows PowerShell den Wert 1 der Variablen „$a“ und den Wert 2 der Variablen „$b“ zu. Die Werte 3, 4 und 5 werden der Variablen „$c“ zugewiesen. Um die Werte in der Variablen „$c“ drei anderen Variablen zuzuweisen, verwenden Sie folgendes Format:
$d, $e, $f = $c
Dieser Befehl weist den Wert 3 der Variablen „$d“, den Wert 4 der Variablen „$e“ und den Wert 5 der Variablen „$f“ zu.
Sie können auch durch Verkettung der Variablen mehreren Variablen einen einzelnen Wert zuweisen. Der folgende Befehl weist z. B. allen vier Variablen den Wert „three“ zu:
$a = $b = $c = $d = "three"
VARIABLENBEZOGENE CMDLETS
Um einen Variablenwert festzulegen, können Sie außer einer Zuweisungsoperation auch das Cmdlet „Set-Variable“ verwenden. Beispielsweise weist der folgende Befehl mit „Set-Variable“ der Variablen „$a“ das Array 1, 2, 3 zu.
Set-Variable -name a -value 1, 2, 3
SIEHE AUCH
about_Arrays
about_Hash_Tables
about_Variables
Clear-Variable
Remove-Variable
Set-Variable