about_Assignment_Operators

  • Artikel

Kurze Beschreibung

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

Lange Beschreibung

Zuordnungsoperatoren weisen einer Variablen mindestens einen Wert zu. Das Gleichheitszeichen (=) ist der PowerShell-Zuordnungsoperator. PowerShell verfügt außerdem über die folgenden verbundzuordnungsoperatoren: +=, -=, , *=, %=, ++, . --??= Zusammengesetzte Zuordnungsoperatoren führen Vorgänge für die Werte vor der Zuordnung aus.

Syntax

Die Syntax der Zuordnungsoperatoren lautet wie folgt:

  • <assignable-expression> <assignment-operator> <value>

Zuzuweisende 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 Operatoren "Inkrement" und "Decrement" sind unäre Operatoren. Jede verfügt über Präfix- und Postfixversionen.

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

Der Wert des zuzuweisenden Ausdrucks muss eine Zahl sein, oder er muss in eine Zahl konvertierbar sein.

Verwenden des Zuordnungsoperators

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 der Variablen beispielsweise den Wert PowerShell zu $MyShell :

$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 Wert 6 zu $a. Die zweite Zuordnungsanweisung weist dem 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 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 $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 kleiner $b als 0 ist. Er weist den Wert des $b Werts zu $a , wenn der Wert von $b nicht kleiner als 0 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 Hashtable zuzuweisen:

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

Um einer Variablen Hexadezimalwerte zuzuweisen, stellen Sie dem Wert den Wert voran.0x PowerShell konvertiert den Hexadezimalwert (0x10) in einen Dezimalwert (in diesem Fall 16) und weist diesen Wert der $a Variablen zu. Wenn Sie der Variablen beispielsweise einen Wert von 0x10 zuweisen möchten $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. Geben Sie beispielsweise Folgendes ein, um der Variablen einen Wert von 3,1415 1.000 $a zuzuweisen:

$a = 3.1415e3

PowerShell kann auch Kilobyte, Megabyte KBMBund Gigabyte GB in Bytes konvertieren. Wenn Sie der Variablen beispielsweise einen Wert von 10 Kb zuweisen möchten $a , geben Sie Folgendes ein:

$a = 10kb

Verwenden von Verbundzuordnungsoperatoren

Zusammengesetzte Zuordnungsoperatoren führen numerische Vorgänge für die Werte vor der Zuordnung aus.

Wichtig

Zusammengesetzte Zuordnungsoperatoren verwenden keine dynamische Bereichsdefinition. Die Variable befindet sich immer im aktuellen Bereich.

Im folgenden Beispiel wird die Variable $x im globalen Bereich definiert. Die geschweiften Klammern erstellen 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 }

1

Wenn Sie den regulären Zuordnungsoperator verwenden, erhalten Sie eine Kopie der Variablen aus dem übergeordneten Bereich. Beachten Sie jedoch, 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 Zuordnung nach Additionsoperator

Die Zuordnung durch additionsoperator += 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 ü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 Vorgänge. Zuerst wird sie 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 Wert auf der rechten Seite des Operators. Anschließend weist der Operator der Variablen den resultierenden Wert zu. Das folgende Beispiel zeigt, wie der += Operator verwendet wird, 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

and

$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.

Mit dem folgenden Befehl wird beispielsweise der $a Variablen eine Hashtabelle zugewiesen. Anschließend wird der += Operator verwendet, um eine weitere Hashtabelle an die vorhandene Hashtabelle anzufügen, wodurch der vorhandenen Hashtabelle effektiv 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

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

Die Zuordnung nach Subtraktionsoperator

Die Zuordnung durch den Subtraktionsoperator -= erhöht 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 Vorgänge. Zuerst subtrahiert sie und weist sie dann zu. Daher sind die folgenden Anweisungen gleichwertig:

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

Das folgende Beispiel zeigt, wie der -= Operator verwendet wird, um den Wert einer Variablen zu verringern:

$a = 8
$a -= 2
$a

6

Sie können den Zuordnungsoperator -= auch 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. Wenn Sie alle Werte löschen möchten, die einer Variablen zugewiesen sind, verwenden Sie die Cmdlets "Clear-Item " oder "Clear-Variable ", um der Variablen einen Wert oder $null"" eine Variable zuzuweisen.

$a = $null

Um einen bestimmten Wert aus einem Array zu löschen, verwenden Sie die Arraynotation, um dem jeweiligen Element einen Wert $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 das Cmdlet Remove-Variable , um eine Variable zu löschen. 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 Zuordnung durch 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. Das folgende Beispiel zeigt beispielsweise, wie der *= Operator zum Multiplizieren des Werts einer Variablen verwendet wird:

$a = 3
$a *= 4
$a

12

In diesem Fall kombiniert der *= Operator zwei Vorgänge. Zuerst wird sie multipliziert und dann 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 Abteilungsoperator

Die Zuordnung nach 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 Vorgänge. Zuerst wird sie 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 dividieren, verwenden Sie einen Index, um das Element zu identifizieren, das Sie ändern möchten. Mit dem folgenden Befehl wird beispielsweise das zweite Element im Array (Indexposition 1) durch 2 dividiert:

$a[1] /= 2

Die Zuordnung nach Modulusoperator

Die Zuordnung durch modulus operator %= dividiert den Wert einer Variablen durch den Wert auf der rechten Seite des Operators. Anschließend weist der %= Operator der Variablen den re Standard der (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. Zuerst wird der re Standard der dividiert und bestimmt, und anschließend wird der Variablen der re Standard der zugewiesen. Daher sind die folgenden Anweisungen gleichwertig:

$a %= 2
$a = ($a % 2)

Das folgende Beispiel zeigt, wie der Operator zum Speichern des %= Moduls eines Quotienten verwendet wird:

$a = 7
$a %= 4
$a

3

Die Operatoren für Inkrementierung und Dekrementierung

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 zu erzwingen, dass ein Wert zurückgegeben wird, 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) eine Variable platziert werden. Die Präfixversion des Operators erhöht eine Variable, bevor der Wert in der Anweisung verwendet wird, wie folgt:

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

8

$c

8

Die Postfix-Version des Operators erhöht eine Variable, nachdem der Wert in der Anweisung verwendet wurde. Im folgenden Beispiel weisen die $c Variablen $a unterschiedliche Werte auf, da der Wert vor $a Änderungen zugewiesen $c 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 erhöht eine Variable, bevor der Wert in der Anweisung verwendet wird, wie folgt:

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

6

$c

6

Die Postfix-Version des Operators dekrementiert eine Variable, nachdem der Wert in der Anweisung verwendet wurde. Im folgenden Beispiel weisen die $d Variablen $a unterschiedliche Werte auf, da der Wert vor $a Änderungen zugewiesen $d wird:

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

6

$d

7

Zuordnungsoperator "Null-Koalescing"

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

100

Weitere Informationen finden Sie unter Null-Koppierungsoperator.

Microsoft .NET-Typen

Wenn eine Variable standardmäßig nur einen Wert aufweist, bestimmt der Wert, der der Variablen zugewiesen ist, den Datentyp der Variablen. Der folgende Befehl erstellt beispielsweise eine Variable mit dem Typ "System.Int32 ":

$a = 6

Verwenden Sie die GetType-Methode und die FullName-Eigenschaft , um den .NET-Typ einer Variablen zu finden. 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 skalare Variable als jeden .NET-Typ umwandeln, indem Sie den Typnamen in Klammern setzen, die entweder dem Variablennamen oder dem ersten Zuordnungswert vorausgehen. Wenn Sie eine Variable umwandeln, definieren Sie den Datentyp, der in der Variablen gespeichert werden kann.

Der folgende Befehl wandelt die Variable beispielsweise als Zeichenfolgentyp um:

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

273

Das folgende Beispiel wandelt den ersten Wert um, anstatt die Variable zu umwandeln:

$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, 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 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 kein Datentyp 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. Der folgende Befehl wandelt die Variable beispielsweise als Arraytyp um string [] :

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

PowerShell-Variablen können ein beliebiger .NET-Datentyp sein. Darüber hinaus können Sie jedem 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 lautet wie folgt:

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

Zuweisen mehrerer 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 wird der zweiten Variable, dem dritten Element, zugewiesen. Dies wird als Mehrfachzuweisung bezeichnet.

Der folgende Befehl weist beispielsweise der $a Variablen den Wert 1, den Wert 2 der $b Variablen und den Wert 3 der $c Variablen zu:

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

Wenn der Zuordnungswert mehr Elemente als Variablen enthält, werden der letzten Variablen alle Erneut Standard werte 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 $a Variablen den Wert 1 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

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

Wenn der Zuordnungswert weniger Elemente als Variablen enthält, werden dem Wert $nulldie variablen neu Standard zugewiesen. Der folgende Befehl enthält beispielsweise drei Variablen und zwei Werte:

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

Daher weist PowerShell der $a Variablen den Wert 1 und den Wert 2 der $b Variablen zu. Die $c Variable 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 zur Verwendung eines Zuordnungsvorgangs zum Festlegen eines Variablenwerts können Sie auch das Cmdlet Set-Variable verwenden. Mit dem folgenden Befehl wird Set-Variable beispielsweise der Variablen ein Array von 1, 2, 3 zugewiesen $a .

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

Weitere Informationen