about_Assignment_Operators

2025-01-23

Kurzbeschreibung

Beschreibt, wie Operatoren zum Zuweisen von Werten zu Variablen verwendet werden.

Lange Beschreibung

Zuordnungsoperatoren weisen einer Variablen einen oder mehrere Werte zu. Das Gleichheitszeichen (=) ist der PowerShell-Zuweisungsoperator. PowerShell verfügt außerdem über die folgenden zusammengesetzten Zuweisungsoperatoren: +=, -=, *=, %=, ++, --, ??=. Zusammengesetzte Zuweisungsoperatoren führen Operationen an den Werten vor der Zuweisung durch.

Syntax

Die Syntax der Zuordnungsoperatoren 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 Dekrement-Operatoren sind unäre Operatoren. Sie haben jeweils Präfix- und Postfix-Versionen.

<assignable-expression><operator>
<operator><assignable-expression>

Der Wert des zuweisbaren Ausdrucks muss eine Zahl sein oder in eine Zahl konvertierbar sein.

Verwendung des Zuweisungsoperators

Variablen werden als Speicherplätze bezeichnet, die Werte speichern. Sie speichern die Werte in Variablen mithilfe des Zuordnungsoperators =. Der neue Wert kann den vorhandenen Wert der Variablen ersetzen, oder Sie können einen neuen Wert an den vorhandenen Wert anfügen. Die folgende Anweisung weist beispielsweise der Variablen $MyShell den Wert PowerShell zu.

$MyShell = "PowerShell"

Wenn Sie einer Variablen in PowerShell einen Wert zuweisen, wird die Variable erstellt, wenn sie noch nicht vorhanden war. Die erste der folgenden beiden Zuordnungsanweisungen erstellt beispielsweise die $a Variable und weist dem $aden Wert 6 zu. Die zweite Zuweisungsanweisung weist $a einen Wert von 12 zu. Die erste Anweisung erstellt eine neue Variable. Die zweite Aussage ändert nur ihren Wert:

$a = 6
$a = 12

Variablen in PowerShell verfügen nicht über einen bestimmten Datentyp, es sei denn, Sie casten sie. Wenn eine Variable nur ein Objekt enthält, verwendet die Variable den Datentyp dieses Objekts. Wenn eine Variable eine Auflistung von Objekten enthält, weist die Variable den datentyp System.Object auf. 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 Zuordnungsoperator = eine niedrigere Priorität hat als der Pipelineoperator |, sind Klammern nicht 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-Object -Property Name

Sie können den Wert, der durch eine Anweisung erstellt wird, auch einer Variablen zuweisen, wie im folgenden Beispiel gezeigt:

$a = if ($b -lt 0) { 0 } else { $b }

In diesem Beispiel wird der variablen $a Null zugewiesen, wenn der Wert von $b kleiner als 0 ist. Sie ordnet den Wert von $b$a zu, wenn der Wert von $b nicht kleiner als Null ist.

Wenn Sie einer Variablen ein Array (mehrere Werte) zuweisen möchten, trennen Sie die Werte wie folgt durch Kommas:

$a = "apple", "orange", "lemon", "grape"

Um einer Variablen eine Hashtabelle zuzuweisen, verwenden Sie die Standardmäßige Hashtabellennotation in PowerShell. Geben Sie ein at-Zeichen @ gefolgt von Schlüssel/Wert-Paaren ein, die durch Semikolons ; getrennt und in geschweifte Klammern { } eingeschlossen sind. Geben Sie beispielsweise Folgendes ein, um der $a Variablen eine Hashtabelle zuzuweisen:

$a = @{one=1; two=2; three=3}

Um einer Variablen hexadezimale Werte zuzuweisen, stellen Sie dem Wert ein 0x voran. PowerShell konvertiert den Hexadezimalwert (0x10) in einen Dezimalwert (in diesem Fall 16) und weist diesen Wert der variablen $a zu. Wenn Sie der variablen $a beispielsweise einen Wert von 0x10 zuweisen möchten, geben Sie Folgendes ein:

$a = 0x10

Wenn Sie einer Variablen einen exponentiellen Wert zuweisen möchten, geben Sie die Stammnummer, den Buchstaben eund eine Zahl ein, die ein Vielfaches von 10 darstellt. Um zum Beispiel der Variablen $a den Wert 3,1415 hoch 1.000 zuzuweisen, geben Sie ein:

$a = 3.1415e3

PowerShell kann auch Kilobytes KB, Megabytes MBund Gigabyte GB in Byte konvertieren. Wenn Sie der variablen $a beispielsweise einen Wert von 10 KB zuweisen möchten, geben Sie Folgendes ein:

$a = 10kb

Verwendung von zusammengesetzten Zuweisungsoperatoren

Zusammengesetzte Zuweisungsoperatoren führen numerische Operationen an den Werten vor der Zuweisung durch.

Wichtig

Zusammengesetzte Zuweisungsoperatoren verwenden kein dynamisches Scoping. Die Variable befindet sich immer im aktuellen Bereich.

Im folgenden Beispiel wird die Variable $x im globalen Bereich definiert. Die geschweiften Klammern erzeugen einen neuen Bereich. Die Variable $x innerhalb der geschweiften Klammern ist eine neue Instanz und keine Kopie der globalen Variablen.

$x = 1 # Global scope
& { $x += 1; $x }

Wenn Sie den normalen Zuweisungsoperator verwenden, erhalten Sie eine Kopie der Variablen aus dem übergeordneten Bereich. Beachten Sie aber, dass $x im übergeordneten Bereich nicht geändert wird.

$x = 1 # Global scope
& { $x = $x + 1; $x }
"Global `$x = $x"

2
Global $x = 1

Die Zuweisung durch den Additionsoperator

Die Zuweisung durch den Additionsoperator += erhöht entweder den Wert einer Variablen oder fügt den angegebenen Wert zum vorhandenen Wert hinzu. Die Aktion hängt davon ab, ob die Variable über einen numerischen oder Zeichenfolgentyp verfügt und ob die Variable einen einzelnen Wert (ein Skalar) oder mehrere Werte (eine Auflistung) enthält.

Der +=-Operator kombiniert zwei Operationen. Zuerst wird addiert, dann wird zugewiesen. Daher sind die folgenden Aussagen gleichwertig:

$a += 2
$a = ($a + 2)

Wenn die Variable einen einzelnen numerischen Wert enthält, erhöht der += Operator den vorhandenen Wert um den Wert 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

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 einer Variablen ein Array ist, hängt der +=-Operator die Werte auf der rechten Seite des Operators an das Array an. Sofern das Array nicht explizit durch Casting typisiert ist, können Sie jeden Werttyp an das Array anhängen, wie im Folgenden beschrieben:

$a = 1,2,3
$a += 2
$a

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 jedoch der einzige Typ, den Sie einer Hashtabelle hinzufügen können, eine andere Hashtabelle ist, schlagen alle anderen Zuordnungen fehl.

Beispielsweise weist der folgende Befehl der variablen $a eine Hashtabelle zu. Anschließend wird der operator += verwendet, um eine weitere Hashtabelle an die vorhandene Hashtabelle anzufügen, wodurch der vorhandenen Hashtabelle effektiv ein neues Schlüsselwertpaar hinzugefügt wird. Dieser Befehl ist erfolgreich, wie die Ausgabe zeigt:

$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 variablen $a anzufügen. Dieser Befehl schlägt fehl:

$a = @{a = 1; b = 2; c = 3}
$a += 1

InvalidOperation:
Line |
   2 |  $a += 1
     |  ~~~~~~~
     | A hash table can only be added to another hash table.

Die Zuweisung durch den Subtraktionsoperator

Der Zuweisung durch den Subtraktionsoperator -= dekrementiert 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 kann nicht verwendet werden, um ein Element aus einer Auflistung zu entfernen.

Der -=-Operator kombiniert zwei Operationen. Zuerst wird subtrahiert, dann wird zugewiesen. Daher sind die folgenden Aussagen gleichwertig:

$a -= 2
$a = ($a - 2)

Das folgende Beispiel zeigt, wie Sie den Wert einer Variablen mithilfe des -=-Operators verringern:

$a = 8
$a -= 2
$a

Sie können auch den -= Zuordnungsoperator 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 Clear-Item- oder Clear-Variable Cmdlets, 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 jeweiligen Element einen Wert von $null zuzuweisen. Die folgende Anweisung löscht zum Beispiel 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. Mit dem folgenden Befehl wird die $a Variable gelöscht:

Remove-Variable -Name a

Die Zuweisung durch den Multiplikationsoperator

Die Zuordnung durch 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

In diesem Fall kombiniert der *= Operator zwei Vorgänge. Er multipliziert zuerst und weist dann zu. Daher sind die folgenden Aussagen 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 zum Beispiel das erste Element im Array (Indexposition 0) mit 2:

$a[0] *= 2

Die Zuweisung durch den Divisionsoperator

Die Zuweisung durch den Divisionsoperator /= 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 Operationen. Zuerst wird geteilt, dann wird zugewiesen. Daher sind die folgenden beiden Aussagen 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

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 zum Beispiel das zweite Element im Array (Indexposition 1) durch 2:

$a[1] /= 2

Die Zuweisung durch Modulus-Operator

Die Zuordnung nach Modulusoperator %= 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 Operationen. Zuerst dividiert er und bestimmt den Rest, und dann weist er den Rest der Variablen zu. Daher sind die folgenden Aussagen 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

Die Operatoren Inkrement und Dekrement

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

Um zu erzwingen, dass ein Wert zurückgegeben wird, schließen Sie die Variable und den Operator wie folgt in Klammern ein:

$a = 7
(++$a)

Der Inkrement-Operator kann vor (Präfix) oder nach (Postfix) einer Variablen platziert werden. Die Präfixversion des Operators inkrementiert eine Variable, bevor der Wert in der Anweisung verwendet wird, wie folgt:

$a = 7
$c = ++$a
$a

$c

Die Postfix-Version des Operators inkrementiert eine Variable, nachdem ihr Wert in der Anweisung verwendet wurde. Im folgenden Beispiel haben die Variablen $c und $a unterschiedliche Werte, weil der Wert $c zugewiesen wird, bevor $a sich ändert.

$a = 7
$c = $a++
$a

$c

Der Dekrementoperator -- verringert den Wert einer Variablen um 1. Wie beim Inkrement-Operator wird auch hier 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

(--$a)

Die Präfixversion des Operators verringert eine Variable, bevor der Wert in der Anweisung verwendet wird, wie folgt:

$a = 7
$c = --$a
$a

$c

Die Postfix-Version des Operators dekrementiert eine Variable, nachdem ihr Wert in der Anweisung verwendet wurde. Im folgenden Beispiel haben die Variablen $d und $a unterschiedliche Werte, weil der Wert $d zugewiesen wird, bevor $a sich ändert.

$a = 7
$d = $a--
$a

$d

Der NULL-Sammelzuordnungsoperator

Der NULL-Sammelzuordnungsoperator??= weist den Wert seines rechten Operanden dem linken Operanden nur zu, wenn der linke Operand mit NULL ausgewertet wird. Der Operator ??= wertet seinen rechten Operanden nicht aus, wenn der linke Operand mit ungleich NULL auswertet wird.

$x = $null
$x ??= 100
$x

Weitere Informationen finden Sie unter Null-Koaleszenz-Operator.

Microsoft .NET-Typen

Wenn eine Variable standardmäßig nur einen Wert aufweist, bestimmt der Wert, der der Variablen zugewiesen ist, den Datentyp der Variablen. Mit dem folgenden Befehl wird beispielsweise eine Variable erstellt, die den System.Int32- Typ aufweist:

$a = 6

Um den .NET-Typ einer Variablen zu finden, verwenden Sie die GetType--Methode und dessen FullName-Eigenschaft. Achten Sie darauf, die Klammern nach dem GetType Methodennamen einzuschließen, auch wenn der Methodenaufruf keine Argumente hat:

$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

Sie können eine neue Skalar-Variable in einen beliebigen .NET-Typ umwandeln, indem Sie den Typnamen in eckige Klammern setzen, die entweder dem Variablennamen oder dem ersten Zuweisungswert vorangestellt werden. Wenn Sie eine Variable casten, definieren Sie den Typ der Daten, die in der Variable gespeichert werden können.

Der folgende Befehl castet die Variable zum Beispiel als String:

[string]$a = 27
$a += 3
$a

Das folgende Beispiel castet den ersten Wert, anstatt die Variable zu casten:

$a = [string]27

Sie können den Datentyp einer vorhandenen Variablen nicht neucasten, wenn der Wert nicht in den neuen Datentyp konvertiert werden kann.

$a = "string"
[int]$a

InvalidArgument: Cannot convert value "string" to type "System.Int32". Error:
"The input string 'string' was not in a correct format."

Um den Datentyp zu ändern, müssen Sie den Wert wie folgt ersetzen:

[int]$a = 3

Wenn Sie einem Variablennamen einen Datentyp vorangestellt haben, ist der Typ dieser Variable außerdem gesperrt, es sei denn, Sie überschreiben den Typ explizit durch die Angabe eines anderen Datentyps. Wenn Sie versuchen, einen Wert zuzuweisen, der nicht mit dem vorhandenen Typ kompatibel ist, und Sie den Typ nicht explizit außer Kraft setzen, zeigt PowerShell einen Fehler an, wie im folgenden Beispiel gezeigt:

$a = 3
$a = "string"
[int]$a = 3
$a = "string"

MetadataError:
Line |
   2 |  $a = "string"
     |  ~~~~~~~~~~~~~
     | Cannot convert value "string" to type "System.Int32". Error: "The input
string 'string' was not in a correct format."

[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. Sofern einer Array-Variablen nicht ausdrücklich ein Datentyp zugewiesen wird, 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 string []-Arraytyp um.

[string []] $a = "one", "two", "three"

PowerShell-Variablen können ein beliebiger .NET-Datentyp sein. Darüber hinaus können Sie jeden vollständig qualifizierten .NET-Datentyp verwenden, 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 datentyp System.DateTime entspricht. Der Wert der $a Variablen lautet wie folgt:

Tuesday, May 31, 2005 12:00:00 AM

Zuweisung von mehreren Variablen

In PowerShell können Sie mehreren Variablen Werte mithilfe eines einzigen Befehls zuweisen. Das erste Element des Zuordnungswerts wird der ersten Variablen zugewiesen, das zweite Element der zweiten Variablen und das dritte Element der dritten Variablen. Dies wird als Mehrfachzuweisung bezeichnet.

Mit dem folgenden Befehl wird beispielsweise der variablen $a der Wert 1, dem Wert 2 der variablen $b und dem Wert 3 der variablen $c zugewiesen:

$a, $b, $c = 1, 2, 3

Wenn der Zuordnungswert 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 $a den Wert 1 und der Variablen $b den Wert 2 zu. Sie weist die Werte 3, 4 und 5 der variablen $c zu. Verwenden Sie das folgende Format, um die Werte in der variablen $c drei anderen Variablen zuzuweisen:

$d, $e, $f = $c

Mit diesem Befehl wird der Variable $d der Wert 3, der Variable $e der Wert 4 und der Variable $f der Wert 5 zugewiesen.

Wenn der Zuordnungswert weniger Elemente als Variablen enthält, werden die verbleibenden Variablen dem Wert $nullzugewiesen. Der folgende Befehl enthält beispielsweise drei Variablen und zwei Werte:

$a, $b, $c = 1, 2

Daher weist PowerShell der Variablen $a den Wert 1 und der Variablen $b den Wert 2 zu. Die Variable $c ist $null.

Sie können mehreren Variablen auch einen einzelnen Wert zuweisen, indem Sie die Variablen verketten. Der folgende Befehl weist beispielsweise allen vier Variablen den Wert "drei" zu:

$a = $b = $c = $d = "three"

Zusätzlich zu einer Zuweisungs-Operation, um einen Variablenwert festzulegen, können Sie auch das Cmdlet Set-Variable verwenden. Der folgende Befehl verwendet z. B. Set-Variable, um der variablen $a ein Array von 1, 2, 3 zuzuweisen.

Set-Variable -Name a -Value 1, 2, 3