about_Arithmetic_Operators

Kurzbeschreibung

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 Rest (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 Rest 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
  

RANGFOLGE DES OPERATORS

PowerShell verarbeitet arithmetische Operatoren in der folgenden Reihenfolge:

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. Das Auswerten $a++ ändert den Wert $a, nachdem er in der Anweisung $c[$a++]verwendet wurde, aber bevor er in $b[$a]verwendet wird. Die Variable $a in $b[$a] entspricht 1, nicht 0. Daher weist die Anweisung $b[1]einen Wert zu, 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 .5ist, 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 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 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 in Int32umgewandelt zu werden:

([int32]::MinValue + [uint32]::MaxValue).GetType().FullName

System.Int64

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

Der System.Decimal Typ ist eine Ausnahme. Wenn ein Operand den Typ Dezimalzeichen aufweist, wird das Ergebnis Typ "Dezimal". Jedes Ergebnis, das zu groß für den wert Decimal 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 führt das Hinzufügen einer ausreichend großen [long] und [int] dazu, dass die Operanden in [double]konvertiert werden. In diesem Beispiel ist 9223372036854775807 der Maximalwert einer [long] ganzen Zahl. Das Hinzufügen zu Wert überläuft den Bereich von [long].

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

Die Umwandlung des Ergebnisses in [ulong] führt zu einem ungenauen Ergebnis, da die Operanden zuerst in [double] umgewandelt wurden.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

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

PS> 9223372036854775807ul + 2
9223372036854775809

Das Überschreiten des Bereichs [ulong] führt jedoch zu einer [double].

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

Bigint Arithmetik

Wenn Sie arithmetische Vorgänge für [bigint] Zahlen ausführen, konvertiert PowerShell alle Operanden in [bigint], was zu einem Abschneiden von nicht ganzzahligen Werten führt. Beispielsweise wird der [double] Wert 1.9 beim Konvertieren in 1auf [bigint] abgeschnitten.

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] dividiert durch einen [double] zu einer [double]. Das Umwandeln 1.9 in eine [int] rundet den Wert auf 2ab.

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. Beispielsweise ist (a + b) nicht immer gleich (b + a), und (ab) ist 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 cmdlets Get-Date 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 im Vergleich zu 50mb, um festzustellen, ob dies größer ist.

BITWISE-OPERATOREN

PowerShell unterstützt die standardmäßigen bitweisen Operatoren, einschließlich bitweise-AND (-band), die 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.

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.

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.

Siehe auch

• about_Arrays
• about_Hash_Tables
• about_Operators
• about_Assignment_Operators
• about_Comparison_Operators
• about_Variables
• Get-Date-
• New-TimeSpan-