about_Arithmetic_Operators
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 Hashtabellen6 + 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 Zahlen6 - 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 Malen6 * 2 # result = 12 @("!") * 4 # result = @("!","!","!","!") "!" * 3 # result = "!!!"
Division (
/
) - Dividiert Zahlen6 / 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 Int32
in :
([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 |
Weitere Informationen
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für