Informationen zu arithmetischen Operatoren

Artikel
05/09/2024

KURZE BESCHREIBUNG

Beschreibt die Operatoren, die Arithmetik in PowerShell ausführen.

LANGE BESCHREIBUNG

Arithmetische Operatoren berechnen numerische Werte. Sie können einen oder mehrere arithmetische Operatoren verwenden, um Werte hinzuzufügen, zu subtrahieren, zu multiplizieren und zu dividieren und den Rest (Modulus) eines Divisionsvorgangs zu berechnen.

Darüber hinaus werden der Additionsoperator (+) und der Multiplikationsoperator (*) auch für Zeichenfolgen, Arrays und Hashtabellen ausgeführt. Der Additionsoperator verkettet die Eingabe. Der Multiplikationsoperator gibt mehrere Kopien der Eingabe zurück. Sie können sogar Objekttypen in einer arithmetischen Anweisung mischen. Die Methode, die zum Auswerten der Anweisung verwendet wird, wird durch den Typ des am weitesten links stehenden Objekts im Ausdruck bestimmt.

Ab PowerShell 2.0 arbeiten alle arithmetischen Operatoren mit 64-Bit-Zahlen.

Ab PowerShell 3.0 werden die -shr -Elemente (umschaltbar nach rechts) und -shl (umschalt-links) hinzugefügt, um bitweise Arithmetik in PowerShell zu unterstützen.

PowerShell unterstützt die folgenden arithmetischen Operatoren:

Operator	BESCHREIBUNG	Beispiel
+	Fügt ganze Zahlen hinzu; Verkettet	`6 + 2`
	Zeichenfolgen, Arrays und Hashtabellen.	`"file" + "name"`
		`@(1, "one") + @(2.0, "two")`
		`@{"one" = 1} + @{"two" = 2}`
-	Subtrahiert einen Wert von einem anderen	`6 - 2`
	value
-	Macht eine Zahl zu einer negativen Zahl	`-6`
		`(Get-Date).AddDays(-1)`
*	Multiplizieren von Zahlen oder Kopieren von Zeichenfolgen	`6 * 2`
	und arrays die angegebene Zahl	`@("!") * 4`
	von Zeiten.	`"!" * 3`
/	Dividiert zwei Werte.	`6 / 2`
%	Modulus : Gibt den Rest von zurück.	`7 % 2`
	ein Divisionsvorgang.
-Band	Bitweises AND	`5 -band 3`
-bnot	Bitweises NOT	`-bnot 5`
-Bor	Bitweises OR	`5 -bor 0x03`
-bxor	Bitweises XOR	`5 -bxor 3`
-Shl	Verschiebt Bits nach links	`102 -shl 2`
-Shr	Verschiebt Bits nach rechts	`102 -shr 2`

Die bitweisen Operatoren funktionieren nur für Ganzzahltypen.

OPERATORRANGFOLGE

PowerShell verarbeitet arithmetische Operatoren in der folgenden Reihenfolge:

Rangfolge	Betreiber	BESCHREIBUNG
1	`()`	Klammern
2	`-`	Für eine negative Zahl oder einen unären Operator
3	`*`, `/`, `%`	Für Multiplikation und Division
4	`+`, `-`	Für Addition und Subtraktion
5	`-band`, `-bnot`	Für bitweise Vorgänge
5	`-bor`, `-bxor`	Für bitweise Vorgänge
5	`-shr`, `-shl`	Für bitweise Vorgänge

PowerShell verarbeitet die Ausdrücke gemäß den Rangfolgeregeln von links nach rechts. Die folgenden Beispiele zeigen die Auswirkungen der Rangfolgeregeln:

expression	Ergebnis
`3+6/3*4`	`11`
`3+6/(3*4)`	`3.5`
`(3+6)/3*4`	`12`

Die Reihenfolge, in der PowerShell Ausdrücke auswertet, kann sich von anderen Programmier- und Skriptsprachen unterscheiden, die Sie verwendet haben. Das folgende Beispiel zeigt eine komplizierte Zuweisungsanweisung.

$a = 0
$b = @(1,2)
$c = @(-1,-2)

$b[$a] = $c[$a++]

In diesem Beispiel wird der Ausdruck $a++ vor $b[$a]ausgewertet. Das Auswerten $a++ ändert den Wert von $a , nachdem er in der -Anweisung $c[$a++]verwendet wird, aber bevor er in $b[$a]verwendet wird. Die Variable $a in $b[$a] ist gleich 1, nicht 0. Daher weist die -Anweisung , nicht $b[0], einen Wert zu$b[1].

Der obige Code entspricht:

$a = 0
$b = @(1,2)
$c = @(-1,-2)

$tmp = $c[$a]
$a = $a + 1
$b[$a] = $tmp

DIVISION UND RUNDUNG

Wenn der Quotient eines Divisionsvorgangs eine ganze Zahl ist, rundet PowerShell den Wert auf die nächste ganze Zahl. Wenn der Wert ist .5, wird er auf die nächste gerade ganze Zahl gerundet.

Das folgende Beispiel zeigt den Effekt der Rundung auf die nächste gerade ganze Zahl.

expression	Ergebnis
`[int]( 5 / 2 )`	`2`
`[int]( 7 / 2 )`	`4`

Beachten Sie, dass 5/2 = 2,5 auf 2 gerundet wird. Aber 7/2 = 3,5 wird auf 4 gerundet.

Sie können die [Math] -Klasse verwenden, um ein anderes Rundungsverhalten zu erhalten.

expression	Ergebnis
`[int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero)`	`3`
`[int][Math]::Ceiling(5 / 2)`	`3`
`[int][Math]::Floor(5 / 2)`	`2`

Weitere Informationen finden Sie in der Math.Round-Methode .

HINZUFÜGEN UND MULTIPLIZIEREN NICHT NUMERISCHER TYPEN

Sie können Zahlen, Zeichenfolgen, Arrays und Hashtabellen hinzufügen. Außerdem können Sie Zahlen, Zeichenfolgen und Arrays multiplizieren. Hashtabellen können jedoch nicht multipliziert werden.

Wenn Sie Zeichenfolgen, Arrays oder Hashtabellen hinzufügen, werden die Elemente verkettet. Wenn Sie Auflistungen verketten, z. B. Arrays oder Hashtabellen, wird ein neues Objekt erstellt, das die Objekte aus beiden Auflistungen enthält. Wenn Sie versuchen, Hashtabellen mit demselben Schlüssel zu verketten, schlägt der Vorgang fehl.

Mit den folgenden Befehlen werden beispielsweise zwei Arrays erstellt und dann hinzugefügt:

$a = 1,2,3
$b = "A","B","C"
$a + $b

1
2
3
A
B
C

Sie können auch arithmetische Operationen für Objekte verschiedener Typen ausführen. Der Vorgang, den PowerShell ausführt, wird durch den Microsoft .NET Framework Typ des am weitesten links stehenden Objekts im Vorgang bestimmt. PowerShell versucht, alle Objekte im Vorgang in den .NET Framework Typ des ersten Objekts zu konvertieren. Wenn die -Objekte erfolgreich konvertiert werden, wird der Vorgang ausgeführt, der für den .NET Framework Typ des ersten Objekts geeignet ist. Wenn keines der Objekte konvertiert werden kann, schlägt der Vorgang fehl.

Die folgenden Beispiele veranschaulichen die Verwendung der Additions- und Multiplikationsoperatoren; in Vorgängen, die verschiedene Objekttypen enthalten. Angenommen $array = 1,2,3:

expression	Ergebnis
`"file" + 16`	`file16`
`$array + 16`	`1`,`2`,`3`,`16`
`$array + "file"`	`1`,`2`,`3`,`file`
`$array * 2`	`1`,`2`,`3`,`1`,`2`,`3`
`"file" * 3`	`filefilefile`

Da die Methode, die zum Auswerten von Anweisungen verwendet wird, vom linkssten Objekt bestimmt wird, sind Addition und Multiplikation in PowerShell nicht streng kommutativ. Beispielsweise (a + b) ist nicht immer gleich (b + a), und (ab) ist nicht immer gleich (ba).

Die folgenden Beispiele veranschaulichen dieses Prinzip:

expression	Ergebnis
`"file" + 16`	`file16`
`16 + "file"`	`Cannot convert value "file" to type "System.Int32".`
	`Error: "Input string was not in a correct format."`
	`At line:1 char:1`
	+ 16 + "Datei"

Hashtabellen sind ein etwas anderer Fall. Sie können Hashtabellen einer anderen Hashtabelle hinzufügen, solange die hinzugefügten Hashtabellen keine doppelten Schlüssel aufweisen.

Das folgende Beispiel zeigt, wie Sie Hashtabellen einander hinzufügen.

$hash1 = @{a=1; b=2; c=3}
$hash2 = @{c1="Server01"; c2="Server02"}
$hash1 + $hash2

Name                           Value
----                           -----
c2                             Server02
a                              1
b                              2
c1                             Server01
c                              3

Im folgenden Beispiel wird ein Fehler ausgelöst, da einer der Schlüssel in beiden Hashtabellen dupliziert ist.

$hash1 = @{a=1; b=2; c=3}
$hash2 = @{c1="Server01"; c="Server02"}
$hash1 + $hash2

Item has already been added. Key in dictionary: 'c'  Key being added: 'c'
At line:3 char:1
+ $hash1 + $hash2
+ ~~~~~~~~~~~~~~~
    + CategoryInfo          : OperationStopped: (:) [], ArgumentException
    + FullyQualifiedErrorId : System.ArgumentException

Außerdem können Sie einem Array eine Hashtabelle hinzufügen. und die gesamte Hashtabelle wird zu einem Element im Array.

$array1 = @(0, "Hello World", [datetime]::Now)
$hash1 = @{a=1; b=2}
$array2 = $array1 + $hash1
$array2

0
Hello World

Monday, June 12, 2017 3:05:46 PM

Key   : a
Value : 1
Name  : a

Key   : b
Value : 2
Name  : b

Sie können einer Hashtabelle jedoch keinen anderen Typ hinzufügen.

$hash1 + 2

A hash table can only be added to another hash table.
At line:3 char:1
+ $hash1 + 2

Obwohl die Additionsoperatoren sehr nützlich sind, verwenden Sie die Zuweisungsoperatoren, um Elemente zu Hashtabellen und Arrays hinzuzufügen. Weitere Informationen finden Sie unter about_assignment_operators. In den folgenden Beispielen wird der Zuweisungsoperator += verwendet, um einem Array Elemente hinzuzufügen:

$array = @()
(0..9).foreach{ $array += $_ }
$array

0
1
2

TYPKONVERTIERUNG, UM DAS ERGEBNIS ZU BERÜCKSICHTIGEN

PowerShell wählt automatisch den .NET Framework numerischen Typ aus, der das Ergebnis am besten ausdrückt, ohne die Genauigkeit zu verlieren. Beispiel:

2 + 3.1

(2). GetType().FullName
(2 + 3.1).GetType().FullName

5.1
System.Int32
System.Double

Wenn das Ergebnis eines Vorgangs für den Typ zu groß ist, wird der Typ des Ergebnisses erweitert, um das Ergebnis zu berücksichtigen, wie im folgenden Beispiel gezeigt:

(512MB).GetType().FullName
(512MB * 512MB).GetType().FullName

System.Int32
System.Double

Der Typ des Ergebnisses ist nicht unbedingt mit einem der Operanden identisch. Im folgenden Beispiel kann der negative Wert nicht in eine ganze Zahl ohne Vorzeichen umgewandelt werden, und die ganze Zahl ohne Vorzeichen ist zu groß, um in umgewandelt zu Int32werden:

([int32]::minvalue + [uint32]::maxvalue).gettype().fullname

System.Int64

In diesem Beispiel Int64 können beide Typen berücksichtigt werden.

Der System.Decimal Typ ist eine Ausnahme. Wenn ein Operand über den Decimal-Typ verfügt, ist das Ergebnis vom Typ Decimal. Wenn das Ergebnis für den Decimal-Typ zu groß ist, wird es nicht in Double umgewandelt. Stattdessen tritt ein Fehler auf.

expression	Ergebnis
`[Decimal]::maxvalue`	`79228162514264337593543950335`
`[Decimal]::maxvalue + 1`	`Value was either too large or too small for a`
	`Decimal.`

ARITHMETISCHE OPERATOREN UND VARIABLEN

Sie können auch arithmetische Operatoren mit Variablen verwenden. Die Operatoren wirken auf die Werte der Variablen. Die folgenden Beispiele veranschaulichen die Verwendung von arithmetischen Operatoren mit Variablen:

expression	Ergebnis
`$intA = 6` `$intB = 4` `$intA + $intB`	`10`
`$a = "Power"` `$b = "Shell"` `$a + $b`	`PowerShell`

ARITHMETISCHE OPERATOREN UND BEFEHLE

In der Regel verwenden Sie die arithmetischen Operatoren in Ausdrücken mit Zahlen, Zeichenfolgen und Arrays. Sie können jedoch auch arithmetische Operatoren mit den Objekten verwenden, die von Befehlen zurückgegeben werden, und mit den Eigenschaften dieser Objekte.

Die folgenden Beispiele zeigen, wie die arithmetischen Operatoren in Ausdrücken mit PowerShell-Befehlen verwendet werden:

(get-date) + (new-timespan -day 1)

Der Klammeroperator erzwingt die Auswertung des get-date Cmdlets und die Auswertung des new-timespan -day 1 Cmdletausdrucks in dieser Reihenfolge. Beide Ergebnisse werden dann mit dem + Operator hinzugefügt.

Get-Process | Where-Object { ($_.ws * 2) -gt 50mb }

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
   1896      39    50968      30620   264 1,572.55   1104 explorer
  12802      78   188468      81032   753 3,676.39   5676 OUTLOOK
    660       9    36168      26956   143    12.20    988 PowerShell
    561      14     6592      28144   110 1,010.09    496 services
   3476      80    34664      26092   234 ...45.69    876 svchost
    967      30    58804      59496   416   930.97   2508 WINWORD

Im obigen Ausdruck wird jeder Prozessarbeitsbereich ($_.ws) mit 2multipliziert, und das Ergebnis wird mit 50mb verglichen, um zu sehen, ob es größer ist.

Bitweise Operatoren

PowerShell unterstützt die bitweisen Standardoperatoren, einschließlich bitweise-AND (-bAnd), die inklusiven und exklusiven bitweisen OR-Operatoren (-bOr und -bXor) und bitweise-NOT (-bNot).

Ab PowerShell 2.0 arbeiten alle bitweisen Operatoren mit 64-Bit-Ganzzahlen.

Ab PowerShell 3.0 werden die -shr (shift-right) und -shl (shift-left) eingeführt, um bitweise Arithmetik in PowerShell zu unterstützen.

PowerShell unterstützt die folgenden bitweisen Operatoren.

Operator	BESCHREIBUNG	Ausdruck	Ergebnis
`-band`	Bitweises AND	`10 -band 3`	2
`-bor`	Bitweise OR (inklusive)	`10 -bor 3`	11
`-bxor`	Bitweise OR (exklusiv)	`10 -bxor 3`	9
`-bnot`	Bitweises NOT	`-bNot 10`	-11
`-shl`	Umschalt nach links	`102 -shl 2`	408
`-shr`	Umschalt rechts	`102 -shr 1`	51

Bitweise Operatoren wirken auf das Binärformat eines Werts. Beispielsweise ist die Bitstruktur für die Zahl 10 00001010 (basierend auf 1 Byte), und die Bitstruktur für die Zahl 3 ist 00000011. Wenn Sie einen bitweisen Operator verwenden, um 10 mit 3 zu vergleichen, werden die einzelnen Bits in jedem Byte verglichen.

In einem bitweisen AND-Vorgang wird das resultierende Bit nur dann auf 1 festgelegt, wenn beide Eingabebits 1 sind.

1010      (10)
0011      ( 3)
--------------  bAND
0010      ( 2)

In einem bitweisen OR-Vorgang (inklusive) wird das resultierende Bit auf 1 festgelegt, wenn eines oder beide Eingabebits 1 sind. Das resultierende Bit wird nur dann auf 0 festgelegt, wenn beide Eingabebits auf 0 festgelegt sind.

1010      (10)
0011      ( 3)
--------------  bOR (inclusive)
1011      (11)

In einem bitweisen ODER -Vorgang (exklusiv) wird das resultierende Bit nur dann auf 1 festgelegt, wenn ein Eingabebit 1 ist.

1010      (10)
0011      ( 3)
--------------  bXOR (exclusive)
1001      ( 9)

Der bitweise NOT-Operator ist ein unärer Operator, der das binäre Komplement des Werts erzeugt. Ein Bit von 1 ist auf 0 und ein Bit von 0 auf 1 festgelegt.

Beispielsweise ist das binäre Komplement von 0 -1, die maximale ganze Zahl ohne Vorzeichen (0xffffffff) und das binäre Komplement von -1 ist 0.

-bNot 10

-11

0000 0000 0000 1010  (10)
------------------------- bNOT
1111 1111 1111 0101  (-11, xfffffff5)

Bei einem bitweisen Umschalt-Links-Vorgang werden alle Bits "n" nach links verschoben, wobei "n" der Wert des rechten Operanden ist. An der eins-Stelle wird eine Null eingefügt.

Wenn der linke Operand ein Ganzzahlwert (32-Bit) ist, bestimmen die unteren 5 Bits des rechten Operanden, wie viele Bits des linken Operanden verschoben werden.

Wenn der linke Operand ein Long-Wert (64 Bit) ist, bestimmen die unteren 6 Bits des rechten Operanden, wie viele Bits des linken Operanden verschoben werden.

expression	Ergebnis	Binäres Ergebnis
`21 -shl 0`	21	0001 0101
`21 -shl 1`	42	0010 1010
`21 -shl 2`	84	0101 0100

In einem bitweisen Umschalt-Rechts-Vorgang werden alle Bits "n" nach rechts verschoben, wo "n" vom rechten Operanden angegeben wird. Der Shift-Right-Operator (-shr) fügt beim Verschieben eines positiven oder unsignierten Werts nach rechts eine Null ein.