about_Arithmetic_Operators

Artikel
04/06/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 addieren, subtrahieren, multiplizieren und dividieren und den Re Standard der (Modulus) eines Divisionsvorgangs zu berechnen.

Der Additionsoperator (+) und der Multiplikationsoperator (*) werden auch für Zeichenfolgen, Arrays und Hashtables verwendet. Der Additionsoperator verkettet die Eingabe. Der Multiplikationsoperator gibt mehrere Kopien der Eingabe zurück. Sie können objekttypen sogar in einer arithmetischen Anweisung mischen. Die Methode, die zum Auswerten der Anweisung verwendet wird, wird durch den Typ des äußerst linken Objekts im Ausdruck bestimmt.

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

Ab PowerShell 3.0 werden die -shr (umschalt-rechts) und -shl (umschalt-links) hinzugefügt, um bitweise Arithmetik in PowerShell zu unterstützen. Die bitweisen Operatoren funktionieren nur für ganzzahlige Typen.

PowerShell unterstützt die folgenden arithmetischen Operatoren:

Addition (+) – Addiert Zahlen, verkettet Zeichenfolgen, Arrays und Hashtabellen

6 + 2                        # result = 8
"file" + "name"              # result = "filename"
@(1, "one") + @(2.0, "two")  # result = @(1, "one", 2.0, "two")
@{"one" = 1} + @{"two" = 2}  # result = @{"one" = 1; "two" = 2}

Subtraktion (-) - Subtrahieren oder Negieren von Zahlen

6 - 2   # result = 4
- -6    # result = 6
(Get-Date).AddDays(-1) # Yesterday's date

Multiplikation (*) - Multiplizieren von Zahlen oder Kopieren von Zeichenfolgen und Arrays die angegebene Anzahl von Malen
```
6 * 2       # result = 12
@("!") * 4  # result = @("!","!","!","!")
"!" * 3     # result = "!!!"
```
Division (/) - Dividiert Zahlen
```
6 / 2  # result = 3
```
Modulus (%) - gibt den Re Standard der eines Divisionsvorgangs zurück.
```
7 % 2  # result = 1
```
Bitweise UND (-band)
```
5 -band 3  # result = 1
```
Bitweise NICHT (-bnot)
```
-bnot 5  # result = -6
```
Bitweise ODER (-bor)
```
5 -bor 0x03  # result = 7
```
Bitweiser XOR (-bxor)
```
5 -bxor 3   # result = 6
```
Verschiebt Bits nach links (-shl)
```
102 -shl 2  # result = 408
```
Verschiebt Bits nach rechts (-shr)
```
102 -shr 2  # result = 25
```

Operatorrangfolge

PowerShell verarbeitet arithmetische Operatoren in der folgenden Reihenfolge:

Rangfolge	Operator	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 von links nach rechts gemäß den Rangfolgeregeln. Die folgenden Beispiele zeigen die Auswirkung der Rangfolgeregeln:

3+6/3*4    # result = 11
3+6/(3*4)  # result = 3.5
(3+6)/3*4  # result = 12

Die Reihenfolge, in der PowerShell Ausdrücke auswertet, unterscheidet sich möglicherweise von anderen Programmier- und Skriptsprachen, die Sie verwendet haben. Das folgende Beispiel zeigt eine komplizierte Zuordnungsanweisung.

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

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

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

Der obige Code entspricht folgendem Code:

$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 ab. Wenn der Wert ist .5, wird er auf die nächste gerade ganze Zahl gerundet.

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

PS> [int]( 5 / 2 )  # Result is rounded down
2

PS> [int]( 7 / 2 )  # Result is rounded up
4

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

PS> [int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero)
3

PS> [int][Math]::Ceiling(5 / 2)
3

PS> [int][Math]::Floor(5 / 2)
2

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

Typkonvertierung zur Aufnahme des Ergebnisses

PowerShell wählt automatisch den numerischen .NET-Typ aus, der das Ergebnis am besten ausdrückt, ohne genauigkeitslos zu verlieren. Zum 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 Ergebnistyp so erweitert, dass es sich um das Ergebnis handelt, wie im folgenden Beispiel gezeigt:

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

System.Int32
System.Double

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

([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 einer der Operanden den Dezimaltyp aufweist, ist das Ergebnis "Dezimaltyp ". Jedes Ergebnis, das für den Dezimalwert zu groß ist, ist ein Fehler.

PS> [Decimal]::maxvalue
79228162514264337593543950335

PS> [Decimal]::maxvalue + 1
RuntimeException: Value was either too large or too small for a Decimal.

Potenzieller Genauigkeitsverlust

Wenn Sie ein Ergebnis haben, das den Bereich des Typs überschreitet, riskieren Sie, dass die Genauigkeit aufgrund der Typkonvertierung verloren geht. Beispielsweise wird ein ausreichend großes [long] Element hinzugefügt und [int] führt dazu, dass die Operanden in konvertiert [double]werden. In diesem Beispiel 9223372036854775807 ist der Maximalwert einer [long] ganzen Zahl angegeben. Das Hinzufügen zu Wert überläuft den Bereich von [long].

PS> (9223372036854775807 + 2).GetType().FullName
System.Double

Das Ergebnis wird [ulong] in ein ungenaues Ergebnis umgewandelt, da die Operanden zuerst umgewandelt [double] wurden.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

Das Definieren des größeren Werts als [ulong] erstes vermeidet das Problem und erzeugt das richtige Ergebnis.

PS> 9223372036854775807ul + 2
9223372036854775809

Überschreitet jedoch den Bereich der [ulong] Ergebnisse in einem [double].

PS> ([ulong]::MaxValue + 1).GetType().FullName
System.Double

Bigint Arithmetik

Wenn Sie arithmetische Operationen für [bigint] Zahlen ausführen, verwendet PowerShell alle Operanden in [bigint], was zu einem Abschneiden von nicht ganzzahligen Werten führt. Beispielsweise wird der [double] Wert abgeschnitten1, wenn er in konvertiert wird[bigint]1.9.

PS> [bigint]1 / 1.9
1
PS> 1 / [bigint]1.9
1

Dieses Verhalten unterscheidet sich vom Verhalten anderer numerischer Typen. In diesem Beispiel wird ein [int] dividiert durch ein [double] Ergebnis in einem [double]. Umwandlung 1.9 in einen [int] Rundungswert auf 2.

PS> 1 / 1.9
0.526315789473684
PS> 1 / [int]1.9
0.5

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. Sie können Hashtabellen jedoch nicht multiplizieren.

Wenn Sie Zeichenfolgen, Arrays oder Hashtabellen hinzufügen, werden die Elemente verkettet. Wenn Sie Auflistungen wie Arrays oder Hashtabellen verketten, 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 anschließend hinzugefügt:

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

1
2
3
A
B
C

Sie können auch arithmetische Vorgänge für Objekte unterschiedlicher Typen ausführen. Der Von PowerShell ausgeführte Vorgang wird durch den Microsoft .NET-Typ des ganz links im Vorgangsobjekt bestimmt. PowerShell versucht, alle Objekte im Vorgang in den .NET-Typ des ersten Objekts zu konvertieren. Wenn es erfolgreich ist, die Objekte zu konvertieren, führt sie den für den .NET-Typ des ersten Objekts geeigneten Vorgang aus. Wenn eines der Objekte nicht konvertiert werden kann, schlägt der Vorgang fehl.

Die folgenden Beispiele veranschaulichen die Verwendung der Additions- und Multiplikationsoperatoren in Vorgängen, die unterschiedliche Objekttypen enthalten.

$array = 1,2,3
$red = [ConsoleColor]::Red
$blue = [ConsoleColor]::Blue

"file" + 16      # result = "file16"
$array + 16      # result = 1,2,3,16
$array + "file"  # result = 1,2,3,"file"
$array * 2       # result = 1,2,3,1,2,3
"file" * 3       # result = "filefilefile"
$blue + 3        # result = Red
$red - 3         # result = Blue
$blue - $red     # result = -3
+ '123'          # result = 123

Da die Methode, die zum Auswerten von Anweisungen verwendet wird, vom äußerst linken Objekt bestimmt wird, sind Addition und Multiplikation in PowerShell nicht streng kommutativ. Ist z. B (a + b) . nicht immer gleich (b + a)und (ab) nicht immer gleich (ba).

Die folgenden Beispiele veranschaulichen dieses Prinzip:

PS> "file" + 16
file16

PS> 16 + "file"
InvalidArgument: can't convert value "file" to type "System.Int32". Error:
"Input string wasn't in a correct format."

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

Das folgende Beispiel zeigt, wie Hashtabellen einander hinzugefügt werden.

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

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

OperationStopped:
Line |
   3 |  $hash1 + $hash2
     |  ~~~~~~~~~~~~~~~
     | Item has already been added. Key in dictionary: 'c'  Key being added: 'c'

Außerdem können Sie einer Matrix 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

InvalidOperation: A hash table can only be added to another hash table.

Obwohl die Zusatzoperatoren sehr nützlich sind, verwenden Sie die Zuordnungsoperatoren, um Elemente zu Hashtabellen und Arrays hinzuzufügen. Weitere Informationen finden Sie unter about_assignment_operators. In den folgenden Beispielen wird der += Zuordnungsoperator zum Hinzufügen von Elementen zu einem Array verwendet:

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

0
1
2

Arithmetische Operatoren und Variablen

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

PS> $intA = 6
PS> $intB = 4
PS> $intA + $intB
10

PS> $a = "Power"
PS> $b = "Shell"
PS> $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 Befehle zurückgeben, 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 Klammernoperator erzwingt die Auswertung des Get-Date Cmdlets und der Auswertung des New-TimeSpan -Day 1 Cmdlet-Ausdrucks 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 2; multipliziert und das Ergebnis verglichen, um 50mb festzustellen, ob er größer ist als das.

Bitweise Operatoren

PowerShell unterstützt die standardmäßigen bitweisen Operatoren, einschließlich bitweise-AND (-band), der inklusiven und exklusiven Bitweise-OR-Operatoren (-bor und -bxor) und bitweise-NOT (-bnot).

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

Ab PowerShell 3.0 werden die -shr (umschalt-rechts) und -shl (umschalt-links) 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 ODER (einschließlich)	`10 -bor 3`	11
`-bxor`	Bitweise ODER (exklusiv)	`10 -bxor 3`	9
`-bnot`	Bitweises NOT	`-bNot 10`	-11
`-shl`	Shift-Left-	`102 -shl 2`	408
`-shr`	Shift-Right-	`102 -shr 1`	51

Bitweise Operatoren reagieren 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 bis 3 zu vergleichen, werden die einzelnen Bits in jedem Byte verglichen.

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

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

Bei einem bitweisen ODER -Vorgang (einschließlich) wird das resultierende Bit auf 1 festgelegt, wenn eine oder beide Eingabebits 1 sind. Das resultierende Bit wird nur auf 0 festgelegt, wenn beide Eingabebits auf 0 festgelegt sind.

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

Bei einem bitweisen OR -Vorgang (exklusiv) wird das resultierende Bit nur 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 die binäre Ergänzung des Werts erzeugt. Ein Bit von 1 ist auf 0 festgelegt, und ein Bit von 0 ist auf 1 festgelegt.

Beispielsweise ist die binäre Ergänzung von 0 -1, die maximale nicht signierte ganze Zahl (0xFFFFFFFF) und die binäre Ergänzung von -1 ist 0.

-bNot 10

-11

0000 0000 0000 1010  (10)
------------------------- bNOT
1111 1111 1111 0101  (-11, 0xFFFFFFF5)

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

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

Bei einem bitweisen Umschalt-rechts-Vorgang werden alle Bits "n" nach rechts verschoben, wobei "n" durch den rechten Operanden angegeben wird. Der Umschalt-rechts-Operator (-shr) kopiert das Zeichenbit am weitesten links nach links, wenn ein signierter Wert verschoben wird. Bei nicht signierten Werten wird eine Null an der linken Position eingefügt.

expression	Ergebnis	Binär	Hex
`21 -shr 0`	21	00010101	0x15
`21 -shr 1`	10	00001010	0x0A
`21 -shr 2`	5	00000101	0x05
`21 -shr 31`	0	00000000	0x00
`21 -shr 32`	21	00010101	0x15
`21 -shr 64`	21	00010101	0x15
`21 -shr 65`	10	00001010	0x0A
`21 -shr 66`	5	00000101	0x05
`[int]::MaxValue -shr 1`	1073741823	00111111111111111111111111111111	0x3FFFFFFF
`[int]::MinValue -shr 1`	-1073741824	11000000000000000000000000000000	0xC0000000
`-1 -shr 1`	-1	11111111111111111111111111111111	0xFFFFFFFF
`(-21 -shr 1)`	-11	11111111111111111111111111110101	0xFFFFFFF5
`(-21 -shr 2)`	-6	11111111111111111111111111111010	0xFFFFFFF4