about_Assignment_Operators
Kurze Beschreibung
Beschreibt, wie Operatoren verwendet werden, um Variablen Werte zuzuweisen.
Lange Beschreibung
Zuweisungsoperatoren weisen einer Variablen einen oder mehrere Werte zu. Sie können numerische Vorgänge für die Werte vor der Zuweisung ausführen.
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 dann der Variablen den Rest (Modulus) zu. | |
| ++ | Erhöht den Wert einer Variablen, einer zuweisbaren Eigenschaft oder |
| array-Element um 1. | |
| -- | Verringert den Wert einer Variablen, einer zuweisbaren Eigenschaft oder |
| array-Element um 1. |
Syntax
Die Syntax der Zuweisungsoperatoren lautet wie folgt:
<assignable-expression> <assignment-operator> <value>
Zuweisbare Ausdrücke umfassen Variablen und Eigenschaften. Der Wert kann ein einzelner Wert, ein Array von Werten oder ein Befehl, ein Ausdruck oder eine Anweisung sein.
Die Inkrement- und Dekrementoperatoren sind unäre Operatoren. Jede verfügt über Präfix- und Postfixversionen.
<assignable-expression><operator>
<operator><assignable-expression>
Der zuweisbare Ausdruck muss eine Zahl sein, oder er muss in eine Zahl konvertiert werden.
Zuweisen von Werten
Variablen sind benannte Speicherplätze, die Werte speichern. Sie speichern die Werte in Variablen, indem Sie den Zuweisungsoperator verwenden =. Der neue Wert kann den vorhandenen Wert der Variablen ersetzen, oder Sie können einen neuen Wert an den vorhandenen Wert anfügen.
Der grundlegende Zuweisungsoperator ist das Gleichheitszeichen =(ASCII 61). Die folgende Anweisung weist der Variablen beispielsweise den $MyShell Wert PowerShell zu:
$MyShell = "PowerShell"
Wenn Sie einer Variablen in PowerShell einen Wert zuweisen, wird die Variable erstellt, sofern sie noch nicht vorhanden ist. Beispielsweise erstellt die erste der folgenden beiden Zuordnungsanweisungen die $a Variable und weist den Wert 6 zu $a. Die zweite Zuweisungsanweisung weist den Wert 12 zu $a. Die erste Anweisung erstellt eine neue Variable. Die zweite Anweisung ändert nur ihren Wert:
$a = 6
$a = 12
Variablen in PowerShell verfügen nur dann über einen bestimmten Datentyp, wenn Sie sie umwandeln. Wenn eine Variable nur ein Objekt enthält, nimmt die Variable den Datentyp dieses Objekts an. Wenn eine Variable eine Auflistung von -Objekten enthält, hat die Variable den System.Object-Datentyp. Daher können Sie der Auflistung einen beliebigen Objekttyp zuweisen. Das folgende Beispiel zeigt, dass Sie einer Variablen Prozessobjekte, Dienstobjekte, Zeichenfolgen und ganze Zahlen hinzufügen können, ohne einen Fehler zu generieren:
$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 das Ergebnis einer Befehlspipeline einer Variablen zuzuweisen. Der folgende Befehl sortiert beispielsweise die Dienste auf dem Computer und weist dann die sortierten Dienste der $a Variablen zu:
$a = Get-Service | Sort-Object -Property name
Sie können den von einer -Anweisung erstellten Wert auch einer Variablen zuweisen, wie im folgenden Beispiel gezeigt:
$a = if ($b -lt 0) { 0 } else { $b }
In diesem Beispiel wird der $a Variablen null zugewiesen, wenn der Wert von $b kleiner als 0 (null) ist. Er weist den Wert von $b zu zu $a , wenn der Wert von $b nicht kleiner als 0 (null) ist.
Der Zuweisungsoperator
Der Zuweisungsoperator = weist Variablen Werte zu. Wenn die Variable bereits über einen Wert verfügt, ersetzt der Zuweisungsoperator = den Wert ohne Warnung.
Die folgende Anweisung weist der Variablen den $a ganzzahligen Wert 6 zu:
$a = 6
Um einer Variablen einen Zeichenfolgenwert zuzuweisen, schließen Sie den Zeichenfolgenwert wie folgt in Anführungszeichen ein:
$a = "baseball"
Um einer Variablen ein Array (mehrere Werte) zuzuweisen, trennen Sie die Werte wie folgt durch Kommas:
$a = "apple", "orange", "lemon", "grape"
Um einer Variablen eine Hashtabelle zuzuweisen, verwenden Sie die Standard-Hashtabellennotation in PowerShell. Geben Sie am Vorzeichen @ gefolgt von Schlüssel-Wert-Paaren ein, die durch Semikolons ; getrennt und in geschweifte Klammern { }eingeschlossen sind. Um der Variablen beispielsweise eine Hashtabelle zuzuweisen $a , geben Sie Folgendes ein:
$a = @{one=1; two=2; three=3}
Um hexadezimale Werte zu einer Variablen zuzuweisen, stellen Sie dem Wert 0xvoran.
PowerShell konvertiert den Hexadezimalwert (0x10) in einen Dezimalwert (in diesem Fall 16) und weist diesen Wert der $a Variablen zu. Um der Variablen beispielsweise den Wert 0x10 zuzuweisen $a , geben Sie Folgendes ein:
$a = 0x10
Um einer Variablen einen exponentiellen Wert zuzuweisen, geben Sie die Stammnummer, den Buchstaben eund eine Zahl ein, die ein Vielfaches von 10 darstellt. Um der Variablen beispielsweise einen Wert von 3,1415 der Leistung von 1.000 zuzuweisen $a , geben Sie Folgendes ein:
$a = 3.1415e3
PowerShell kann auch Kilobytes KB, Megabyte MBund Gigabyte in GB Bytes konvertieren. Um der Variablen beispielsweise einen Wert von 10 Kb zuzuweisen $a , geben Sie Folgendes ein:
$a = 10kb
Der Zuweisungsoperator nach Addition
Der Zuweisungsoperator += nach Addition erhöht entweder den Wert einer Variablen oder fügt den angegebenen Wert an den vorhandenen Wert an. Die Aktion hängt davon ab, ob die Variable einen numerischen oder Zeichenfolgentyp aufweist und ob die Variable einen einzelnen Wert (skalar) oder mehrere Werte (eine Auflistung) enthält.
Der += Operator kombiniert zwei Vorgänge. Zuerst wird hinzugefügt und dann zugewiesen.
Daher sind die folgenden Anweisungen gleichwertig:
$a += 2
$a = ($a + 2)
Wenn die Variable einen einzelnen numerischen Wert enthält, erhöht der += Operator den vorhandenen Wert um den Betrag auf der rechten Seite des Operators. Anschließend weist der Operator der Variablen den resultierenden Wert zu. Das folgende Beispiel zeigt, wie sie den += -Operator verwenden, um den Wert einer Variablen zu erhöhen:
$a = 4
$a += 2
$a
6
Wenn der Wert der Variablen eine Zeichenfolge ist, wird der Wert auf der rechten Seite des Operators wie folgt an die Zeichenfolge angefügt:
$a = "Windows"
$a += " PowerShell"
$a
Windows PowerShell
Wenn der Wert der Variablen ein Array ist, fügt der += Operator die Werte auf der rechten Seite des Operators an das Array an. Sofern das Array nicht explizit durch Umwandlung eingegeben wird, können Sie einen beliebigen Werttyp wie folgt an das Array anfügen:
$a = 1,2,3
$a += 2
$a
1
2
3
2
und
$a += "String"
$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 an die Hashtabelle an. Da der einzige Typ, den Sie einer Hashtabelle hinzufügen können, eine andere Hashtabelle ist, schlagen alle anderen Zuweisungen fehl.
Der folgende Befehl weist der Variablen beispielsweise eine Hashtabelle zu $a .
Anschließend wird der += Operator verwendet, um eine weitere Hashtabelle an die vorhandene Hashtabelle anzufügen, wodurch der vorhandenen Hashtabelle ein neues Schlüssel-Wert-Paar hinzugefügt wird.
Dieser Befehl ist erfolgreich, wie in der Ausgabe gezeigt:
$a = @{a = 1; b = 2; c = 3}
$a += @{mode = "write"}
$a
Name Value
---- -----
a 1
b 2
mode write
c 3
Der folgende Befehl versucht, eine ganze Zahl "1" an die Hashtabelle in der $a Variablen anzufügen. Dieser Befehl schlägt fehl:
$a = @{a = 1; b = 2; c = 3}
$a += 1
You can add another hash table only to a hash table.
At line:1 char:6
+ $a += <<<< 1
Der Zuweisungsoperator nach Subtraktion
Der Zuweisungsoperator -= nach Subtraktion verringert den Wert einer Variablen um den Wert, der auf der rechten Seite des Operators angegeben ist. Dieser Operator kann nicht mit Zeichenfolgenvariablen verwendet werden, und er kann nicht verwendet werden, um ein Element aus einer Auflistung zu entfernen.
Der -= Operator kombiniert zwei Vorgänge. Zuerst wird subtrahiert und dann zugewiesen. Daher sind die folgenden Anweisungen gleichwertig:
$a -= 2
$a = ($a - 2)
Im folgenden Beispiel wird gezeigt, wie Sie den -= -Operator verwenden, um den Wert einer Variablen zu verringern:
$a = 8
$a -= 2
$a
6
Sie können auch den Zuweisungsoperator -= verwenden, um den Wert eines Elements eines numerischen Arrays zu 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:
$a = 1,2,3
$a[2] -= 1
$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 die Cmdlets Clear-Item oder Clear-Variable , um der Variablen einen Wert von $null oder "" zuzuweisen.
$a = $null
Um einen bestimmten Wert aus einem Array zu löschen, verwenden Sie die Arraynotation, um dem bestimmten Element einen Wert von $null zuzuweisen. Die folgende Anweisung löscht beispielsweise den zweiten Wert (Indexposition 1) aus einem Array:
$a = 1,2,3
$a
1
2
3
$a[1] = $null
$a
1
3
Verwenden Sie zum Löschen einer Variablen 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 verwenden möchten. Der folgende Befehl löscht die $a Variable:
Remove-Variable -Name a
Die Zuweisung nach Multiplikationsoperator
Der Zuweisungsoperator nach Multiplikationsoperator *= multipliziert einen numerischen Wert oder fügt die angegebene Anzahl von Kopien des Zeichenfolgenwerts 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. Im folgenden Beispiel wird beispielsweise gezeigt, wie der *= -Operator verwendet wird, um den Wert einer Variablen zu multiplizieren:
$a = 3
$a *= 4
$a
12
In diesem Fall kombiniert der *= Operator zwei Vorgänge. Zuerst multipliziert sie, und dann wird zugewiesen. Daher sind die folgenden Anweisungen gleichwertig:
$a *= 2
$a = ($a * 2)
Wenn eine Variable einen Zeichenfolgenwert enthält, fügt PowerShell die angegebene Anzahl von Zeichenfolgen wie folgt an den Wert an:
$a = "file"
$a *= 4
$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 (Indexposition 0) mit 2:
$a[0] *= 2
Die Zuordnung nach Bereichsoperator
Der Zuweisungsoperator /= nach Division dividiert 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 Vorgänge. Zuerst wird dividiert und dann zugewiesen. Daher sind die folgenden beiden Anweisungen gleichwertig:
$a /= 2
$a = ($a / 2)
Der folgende Befehl verwendet beispielsweise den /= Operator, um den Wert einer Variablen zu dividieren:
$a = 8
$a /=2
$a
4
Um ein Element eines Arrays zu unterteilen, verwenden Sie einen Index, um das Element zu identifizieren, das Sie ändern möchten. Der folgende Befehl dividiert beispielsweise das zweite Element im Array (Indexposition 1) durch 2:
$a[1] /= 2
Der Zuweisungsoperator nach modulus
Der Operator %= assignment by modulus dividiert den Wert einer Variablen durch den Wert auf der rechten Seite des Operators. Anschließend weist der %= Operator der Variablen den Rest (als Modulus bezeichnet) 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 Vorgänge. Zunächst dividiert und bestimmt er den Rest und weist dann den Rest der Variablen zu. Daher sind die folgenden Anweisungen gleichwertig:
$a %= 2
$a = ($a % 2)
Das folgende Beispiel zeigt, wie sie den %= -Operator verwenden, um den Modulus eines Quotienten zu speichern:
$a = 7
$a %= 4
$a
3
Die Inkrement- und Dekrementoperatoren
Der Inkrementoperator ++ erhöht den Wert einer Variablen um 1. Wenn Sie den Inkrementoperator in einer einfachen Anweisung verwenden, wird kein Wert zurückgegeben. Um das Ergebnis anzuzeigen, zeigen Sie den Wert der Variablen wie folgt an:
$a = 7
++$a
$a
8
Um die Rückgabe eines Werts zu erzwingen, schließen Sie die Variable und den Operator wie folgt in Klammern ein:
$a = 7
(++$a)
8
Der Inkrementoperator kann vor (Präfix) oder nach (Postfix) einer Variablen platziert werden. Die Präfixversion des Operators erhöht eine Variable, bevor ihr Wert in der -Anweisung verwendet wird, wie folgt:
$a = 7
$c = ++$a
$a
8
$c
8
Die Postfixversion des Operators erhöht eine Variable, nachdem ihr Wert in der -Anweisung verwendet wurde. Im folgenden Beispiel weisen die $c Variablen und $a unterschiedliche Werte auf $c , da der Wert vor $a Änderungen zugewiesen wird:
$a = 7
$c = $a++
$a
8
$c
7
Der Dekrementoperator -- verringert den Wert einer Variablen um 1. Wie beim Inkrementoperator wird kein Wert zurückgegeben, wenn Sie den Operator in einer einfachen Anweisung verwenden. Verwenden Sie Klammern, um einen Wert wie folgt zurückzugeben:
$a = 7
--$a
$a
6
(--$a)
5
Die Präfixversion des Operators dekrementiert eine Variable, bevor ihr Wert in der -Anweisung verwendet wird, wie folgt:
$a = 7
$c = --$a
$a
6
$c
6
Die Postfixversion des Operators dekrementiert eine Variable, nachdem ihr Wert in der -Anweisung verwendet wurde. Im folgenden Beispiel weisen die $d Variablen und $a unterschiedliche Werte auf $d , da der Wert vor $a Änderungen zugewiesen wird:
$a = 7
$d = $a--
$a
6
$d
7
Microsoft .NET-Typen
Wenn eine Variable nur über einen Wert verfügt, bestimmt der der Variablen zugewiesene Wert standardmäßig den Datentyp der Variablen. Mit dem folgenden Befehl wird beispielsweise eine Variable erstellt, die den Typ "Integer" (System.Int32) aufweist:
$a = 6
Um den .NET-Typ einer Variablen zu ermitteln, verwenden Sie wie folgt die GetType-Methode und die zugehörige FullName-Eigenschaft . Achten Sie darauf, die Klammern nach dem Namen der GetType-Methode einzuschließen, auch wenn der Methodenaufruf keine Argumente enthält:
$a = 6
$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:
$a = "6"
$a.GetType().FullName
System.String
Wenn der erste Wert, der der Variablen zugewiesen ist, eine Zeichenfolge ist, behandelt PowerShell alle Vorgänge als Zeichenfolgenvorgänge und wandelt neue Werte in Zeichenfolgen um. Dies geschieht im folgenden Beispiel:
$a = "file"
$a += 3
$a
file3
Wenn der erste Wert eine ganze Zahl ist, behandelt PowerShell alle Vorgänge als ganzzahlige Vorgänge und wandelt neue Werte in ganze Zahlen um. Dies geschieht im folgenden Beispiel:
$a = 6
$a += "3"
$a
9
Sie können eine neue Skalarvariable in einen beliebigen .NET-Typ umwandeln, indem Sie den Typnamen in Klammern platzieren, die entweder dem Variablennamen oder dem ersten Zuweisungswert vorangehen. 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.
Der folgende Befehl wandelt die Variable beispielsweise in einen Zeichenfolgentyp um:
[string]$a = 27
$a += 3
$a
273
Im folgenden Beispiel wird der erste Wert umgewandelt, anstatt die Variable zu umwandeln:
$a = [string]27
Wenn Sie eine Variable in einen bestimmten Typ umwandeln, besteht die allgemeine Konvention darin, die Variable und nicht den Wert zu umwandeln. Sie können den Datentyp einer vorhandenen Variablen jedoch nicht neu umwandeln, wenn deren Wert nicht in den neuen Datentyp konvertiert werden kann. Um den Datentyp zu ändern, müssen Sie dessen Wert wie folgt ersetzen:
$a = "string"
[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 <<<<
[int]$a = 3
Wenn Sie außerdem einem Variablennamen einen Datentyp vorangestellt haben, wird der Typ dieser Variablen gesperrt, es sei denn, Sie überschreiben den Typ explizit, indem Sie einen anderen Datentyp angeben. Wenn Sie versuchen, einen Wert zuzuweisen, der mit dem vorhandenen Typ nicht kompatibel ist, und Sie den Typ nicht explizit überschreiben, zeigt PowerShell einen Fehler an, wie im folgenden Beispiel gezeigt:
$a = 3
$a = "string"
[int]$a = 3
$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"
[string]$a = "string"
In PowerShell werden die Datentypen von Variablen, die mehrere Elemente in einem Array enthalten, anders behandelt als die Datentypen von Variablen, die ein einzelnes Element enthalten. Es sei denn, ein Datentyp ist speziell einer Arrayvariablen zugewiesen, der Datentyp ist immer System.Object []. Dieser Datentyp ist spezifisch für Arrays.
Manchmal können Sie den Standardtyp überschreiben, indem Sie einen anderen Typ angeben. Der folgende Befehl wandelt die Variable beispielsweise in einen Arraytyp um string [] :
[string []] $a = "one", "two", "three"
PowerShell-Variablen können einen beliebigen .NET-Datentyp aufweisen. Darüber hinaus können Sie jeden vollqualifizierten .NET-Datentyp zuweisen, der im aktuellen Prozess verfügbar ist. Der folgende Befehl gibt beispielsweise 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 $a Variablen wäre wie folgt:
Tuesday, May 31, 2005 12:00:00 AM
Zuweisen mehrerer Variablen
In PowerShell können Sie mehreren Variablen Mithilfe eines einzelnen Befehls Werte zuweisen. Das erste Element des Zuordnungswerts wird der ersten Variablen zugewiesen, das zweite Element der zweiten Variablen, das dritte Element der dritten Variablen usw. Dies wird als Mehrfachzuweisung bezeichnet.
Der folgende Befehl weist z. B. der Variablen den $a Wert 1, den Wert 2 der $b Variablen und den Wert 3 der $c Variablen zu:
$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 beispielsweise drei Variablen und fünf Werte:
$a, $b, $c = 1, 2, 3, 4, 5
Daher weist PowerShell der Variablen den Wert 1 $a und den Wert 2 der $b Variablen zu. Sie weist der Variablen die Werte 3, 4 und 5 zu $c .
Verwenden Sie das folgende Format, um die Werte in der $c Variablen drei anderen Variablen zuzuweisen:
$d, $e, $f = $c
Dieser Befehl weist der Variablen den $d Wert 3, den Wert 4 der $e Variablen und den Wert 5 der $f Variablen zu.
Wenn der Zuweisungswert weniger Elemente als Variablen enthält, wird den übrigen Variablen der Wert $nullzugewiesen. Der folgende Befehl enthält beispielsweise drei Variablen und zwei Werte:
$a, $b, $c = 1, 2
Daher weist PowerShell der Variablen den Wert 1 $a und den Wert 2 der $b Variablen zu. Die $c Variable ist $null.
Sie können auch mehrere Variablen einen einzelnen Wert zuweisen, indem Sie die Variablen verketten. Der folgende Befehl weist beispielsweise allen vier Variablen den Wert "three" zu:
$a = $b = $c = $d = "three"
Variablenbezogene Cmdlets
Zusätzlich zur Verwendung eines Zuweisungsvorgangs zum Festlegen eines Variablenwerts können Sie auch das Cmdlet Set-Variable verwenden. Der folgende Befehl verwendet Set-Variable beispielsweise, um der $a Variablen ein Array von 1, 2, 3 zuzuweisen.
Set-Variable -Name a -Value 1, 2, 3