about_Arithmetic_Operators

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.

Der Additionsoperator (+) und der Multiplikationsoperator (*) funktionieren auch für Zeichenfolgen, Arrays und Hashtabellen. 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. Die bitweisen Operatoren funktionieren nur für Ganzzahltypen.

PowerShell unterstützt die folgenden arithmetischen Operatoren:

Addition (+) – Fügt Zahlen hinzu, 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 (-): Subtrahiert oder negiert Zahlen.

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

Multiplikation (): Multiplikation :* Multiplikation von Zahlen oder Kopieren von Zeichenfolgen und Arrays mit der angegebenen Anzahl von Malen
```
6 * 2       # result = 12
@("!") * 4  # result = @("!","!","!","!")
"!" * 3     # result = "!!!"
```
Division (/) – Dividiert Zahlen
```
6 / 2  # result = 3
```
Modulus (%): Gibt den Rest eines Divisionsvorgangs zurück.
```
7 % 2  # result = 1
```
Bitweises AND (-band)
```
5 -band 3  # result = 1
```
Bitweises NOT (-bnot)
```
-bnot 5  # result = -6
```
Bitweise OR (-bor)
```
5 -bor 0x03  # result = 7
```
Bitweises 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
```

Rangfolge der Operatoren

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:

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, 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] entspricht 1, nicht 0. Daher weist die -Anweisung , nicht $b[0], einen Wert zu$b[1].

Der obige Code entspricht Folgendem:

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

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 in 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 an 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 immer identisch mit einem der Operanden. 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 einer der Operanden den Decimal-Typ aufweist, lautet das Ergebnis Decimal-Typ . 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

Immer wenn Sie ein Ergebnis haben, das den Bereich des Typs überschreitet, riskieren Sie, dass die Genauigkeit aufgrund der Typkonvertierung verloren geht. Wenn Sie z. B. eine ausreichend große [long] Hinzufügen hinzufügen, werden [int] die Operanden in konvertiert [double]. In diesem Beispiel 9223372036854775807 ist der Höchstwert einer [long] ganzen Zahl. Das Hinzufügen zu einem -Wert überläuft den Bereich von [long].

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

Die Umwandlung des Ergebnisses in [ulong] ergibt ein ungenaues Ergebnis, da die Operanden zuerst geerciert [double] wurden.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

Wenn Sie zuerst den größeren Wert als [ulong] definieren, wird das Problem vermieden und das richtige Ergebnis erzeugt.

PS> 9223372036854775807ul + 2
9223372036854775809

Eine Überschreitung des Bereichs von [ulong] führt jedoch zu einem [double].

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

Bigint-Arithmetik

Wenn Sie arithmetische Operationen für [bigint] Zahlen ausführen, konvertiert PowerShell mit alle Operanden in [bigint], was zu einer Abschneidung nicht ganzzahliger Werte führt. Der Wert 1.9 wird beispielsweise in abgeschnitten1, [double] wenn er in [bigint]konvertiert wird.

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

Dieses Verhalten unterscheidet sich vom Verhalten anderer numerischer Typen. In diesem Beispiel führt eine [int] geteilt durch eine [double] zu einer [double]. Die Umwandlung 1.9 in ein [int] rundet den Wert 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 jedoch keine Hashtabellen multiplizieren.

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-Typ des am weitesten links stehenden Objekts im Vorgang bestimmt. PowerShell versucht, alle Objekte im Vorgang in den .NET-Typ des ersten Objekts zu konvertieren. Wenn die -Objekte erfolgreich konvertiert werden, wird der Vorgang ausgeführt, der dem .NET-Typ des ersten Objekts entspricht. 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.

$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, durch das am weitesten links stehende Objekt bestimmt wird, sind Addition und Multiplikation in PowerShell nicht streng kommutativ. Beispielsweise (a + b) ist 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 etwas anderer Fall. Sie können Hashtabellen einer anderen Hashtabelle hinzufügen, solange die hinzugefügten Hashtabellen keine doppelten Schlüssel aufweisen.

Im folgenden Beispiel wird gezeigt, 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 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 jedoch keiner Hashtabelle einen anderen Typ hinzufügen.

$hash1 + 2

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

Obwohl die Additionsoperatoren sehr nützlich sind, verwenden Sie die Zuweisungsoperatoren, um Hashtabellen und Arrays Elemente 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..2).foreach{ $array += $_ }
$array

0
1
2

Arithmetische Operatoren und Variablen

Sie können auch arithmetische Operatoren mit Variablen verwenden. Die Operatoren handeln auf die Werte der Variablen. In den folgenden Beispielen wird die Verwendung arithmetischer Operatoren mit Variablen veranschaulicht:

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 Klammeroperator erzwingt die Auswertung des Get-Date Cmdlets und die Auswertung des New-TimeSpan -Day 1 Cmdlet-Ausdrucks in dieser Reihenfolge. Beide Ergebnisse werden dann mithilfe des + -Operators 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 er 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 (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`	Bitweises OR (inklusive)	`10 -bor 3`	11
`-bxor`	Bitweises OR (exklusiv)	`10 -bxor 3`	9
`-bnot`	Bitweises NOT	`-bNot 10`	-11
`-shl`	UMSCHALT NACH LINKS	`102 -shl 2`	408
`-shr`	Umschalt nach 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.

Bei 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)

Bei einem bitweisen OR-Vorgang (inklusive) wird das resultierende Bit auf 1 festgelegt, wenn eines oder beide Eingabebits 1 sind. Das resultierende Bit ist nur dann 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 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, 0xFFFFFFF5)

Bei einer bitweisen Verschiebung nach links werden alle Bits "n" Stellen nach links verschoben, wobei "n" der Wert des rechten Operanden ist. An der eins-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 Umschaltvorgang nach rechts werden alle Bits "n" stellenweise nach rechts verschoben, wobei "n" vom rechten Operanden angegeben wird. Der Shift-Right-Operator (-shr) kopiert das Vorzeichenbit an die ganz linksste Stelle, wenn ein vorzeichenierter Wert verschoben wird. Bei Werten ohne Vorzeichen wird eine Null an der ganz linken Position eingefügt.

expression	Ergebnis	Binary	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

Freigeben über