about_Arithmetic_Operators

Artikel
04/06/2024

Kort beskrivning

Beskriver operatorerna som utför aritmetik i PowerShell.

Lång beskrivning

Aritmetiska operatorer beräknar numeriska värden. Du kan använda en eller flera aritmetiska operatorer för att lägga till, subtrahera, multiplicera och dividera värden och beräkna resten (modulus) av en divisionsåtgärd.

Additionsoperatorn (+) och multiplikationsoperatorn (*) fungerar också på strängar, matriser och hashtables. Additionsoperatorn sammanfogar indata. Multiplikationsoperatorn returnerar flera kopior av indata. Du kan till och med blanda objekttyper i en aritmetiksats. Den metod som används för att utvärdera -instruktionen bestäms av typen av det vänstra objektet i uttrycket.

Från och med PowerShell 2.0 fungerar alla aritmetiska operatorer på 64-bitarsnummer.

Från och med PowerShell 3.0 -shr läggs (skift-höger) och -shl (skift-vänster) till för att stödja bitvis aritmetik i PowerShell. Bitvisoperatorerna fungerar bara på heltalstyper.

PowerShell stöder följande aritmetiska operatorer:

Addition (+) – Lägger till tal, sammanfogar strängar, matriser och hash-tabeller

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 (-) – Subtraherar eller negerar tal

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

Multiplikation (*) – Multiplicera tal eller kopieringssträngar och matriser det angivna antalet gånger
```
6 * 2       # result = 12
@("!") * 4  # result = @("!","!","!","!")
"!" * 3     # result = "!!!"
```
Division (/) – Delar upp tal
```
6 / 2  # result = 3
```
Modulus (%) – returnerar resten av en divisionsåtgärd.
```
7 % 2  # result = 1
```
Bitvis OCH (-band)
```
5 -band 3  # result = 1
```
Bitvis INTE (-bnot)
```
-bnot 5  # result = -6
```
Bitvis ELLER (-bor)
```
5 -bor 0x03  # result = 7
```
Bitvis XOR (-bxor)
```
5 -bxor 3   # result = 6
```
Flyttar bitar till vänster (-shl)
```
102 -shl 2  # result = 408
```
Flyttar bitar till höger (-shr)
```
102 -shr 2  # result = 25
```

Prioritet för operator

PowerShell bearbetar aritmetiska operatorer i följande ordning:

Prioritet	Operatör	beskrivning
1	`()`	Parenteser
2	`-`	För ett negativt tal eller en unary-operator
3	`*`, , `/%`	För multiplikation och division
4	`+`, `-`	För addition och subtraktion
5	`-band`, `-bnot`	För bitvis åtgärder
5	`-bor`, `-bxor`	För bitvis åtgärder
5	`-shr`, `-shl`	För bitvis åtgärder

PowerShell bearbetar uttrycken från vänster till höger enligt prioritetsreglerna. I följande exempel visas effekten av prioritetsreglerna:

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

I vilken ordning PowerShell utvärderar uttryck kan det skilja sig från andra programmerings- och skriptspråk som du har använt. I följande exempel visas en komplicerad tilldelningssats.

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

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

I det här exemplet utvärderas uttrycket $a++ före $b[$a]. När du utvärderar $a++ ändras värdet $a för när det används i -instruktionen $c[$a++], men innan det används i $b[$a]. Variabeln $a i $b[$a] är lika med 1, inte 0. Därför tilldelar -instruktionen ett värde till $b[1], inte $b[0].

Koden ovan motsvarar:

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

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

Division och avrundning

När kvoten för en divisionsåtgärd är ett heltal avrundar PowerShell värdet till närmaste heltal. När värdet är .5avrundas det till närmaste jämna heltal.

I följande exempel visas effekten av avrundning till närmaste jämna heltal.

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

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

Du kan använda [Math] klassen för att få olika avrundningsbeteende.

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

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

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

Mer information finns i metoden Math.Round .

Typkonvertering för att hantera resultat

PowerShell väljer automatiskt den numeriska .NET-typ som bäst uttrycker resultatet utan att förlora precision. Till exempel:

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

5.1
System.Int32
System.Double

Om resultatet av en åtgärd är för stort för typen utvidgas resultatets typ för att passa resultatet, som i följande exempel:

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

System.Int32
System.Double

Typen av resultat är inte alltid densamma som en av operanderna. I följande exempel kan det negativa värdet inte gjutas till ett osignerat heltal och det osignerade heltalet är för stort för att kunna gjutas till Int32:

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

System.Int64

I det här exemplet Int64 kan du hantera båda typerna.

Typen System.Decimal är ett undantag. Om någon av operanderna har decimaltypen är resultatet decimaltyp . Eventuella resultat som är för stora för decimalvärdet är ett fel.

PS> [Decimal]::maxvalue
79228162514264337593543950335

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

Potentiell förlust av precision

När du har ett resultat som överskrider typintervallet riskerar du att förlora precision på grund av typkonvertering. Om du till exempel lägger till en tillräckligt stor [long] och [int] resulterar i att operanderna konverteras till [double]. I det här exemplet 9223372036854775807 är det maximala värdet för ett [long] heltal. Om du lägger till i värdet flödar intervallet för [long].

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

Att kasta resultatet till [ulong] ger ett felaktigt resultat, eftersom operanderna tvingades att [double] först.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

Att definiera det större värdet som [ulong] först undviker problemet och ger rätt resultat.

PS> 9223372036854775807ul + 2
9223372036854775809

Men om du överskrider intervallet av [ulong] resultat i en [double].

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

Bigint-aritmetik

När du utför aritmetiska åtgärder på [bigint] tal, konverterar PowerShell alla operander till [bigint], vilket resulterar i trunkering av icke-heltalsvärden. Till exempel [double] trunkeras värdet 1.9 till 1 när det konverteras till [bigint].

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

Det här beteendet skiljer sig från beteendet för andra numeriska typer. I det här exemplet resulterar en [int] dividerad med en [double] i .[double] Gjutning 1.9 till en [int] avrundar värdet upp till 2.

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

Lägga till och multiplicera icke-numeriska typer

Du kan lägga till tal, strängar, matriser och hash-tabeller. Och du kan multiplicera tal, strängar och matriser. Du kan dock inte multiplicera hash-tabeller.

När du lägger till strängar, matriser eller hash-tabeller sammanfogas elementen. När du sammanfogar samlingar, till exempel matriser eller hash-tabeller, skapas ett nytt objekt som innehåller objekten från båda samlingarna. Om du försöker sammanfoga hash-tabeller som har samma nyckel misslyckas åtgärden.

Följande kommandon skapar till exempel två matriser och lägger sedan till dem:

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

1
2
3
A
B
C

Du kan också utföra aritmetiska åtgärder på objekt av olika typer. Den åtgärd som PowerShell utför bestäms av Microsoft .NET-typen för objektet längst till vänster i åtgärden. PowerShell försöker konvertera alla objekt i åtgärden till .NET-typen för det första objektet. Om det lyckas konvertera objekten utför det den åtgärd som är lämplig för .NET-typen för det första objektet. Om det inte går att konvertera något av objekten misslyckas åtgärden.

Följande exempel visar användningen av additions- och multiplikationsoperatorer i åtgärder som innehåller olika objekttyper.

$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

Eftersom metoden som används för att utvärdera instruktioner bestäms av det vänstra objektet, är addition och multiplikation i PowerShell inte helt kommutativa. Till exempel (a + b) är inte alltid lika med (b + a), och (ab) är inte alltid lika med (ba).

Följande exempel visar den här principen:

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

Hash-tabeller är ett något annorlunda skiftläge. Du kan lägga till hash-tabeller i en annan hash-tabell, så länge de tillagda hash-tabellerna inte har dubblettnycklar.

I följande exempel visas hur du lägger till hash-tabeller till varandra.

$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

I följande exempel genereras ett fel eftersom en av nycklarna dupliceras i båda hash-tabellerna.

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

Du kan också lägga till en hash-tabell i en matris. och hela hash-tabellen blir ett objekt i matrisen.

$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

Du kan dock inte lägga till någon annan typ i en hash-tabell.

$hash1 + 2

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

Även om tilläggsoperatorerna är mycket användbara använder du tilldelningsoperatorerna för att lägga till element i hash-tabeller och matriser. Mer information finns i about_assignment_operators. I följande exempel används += tilldelningsoperatorn för att lägga till objekt i en matris:

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

0
1
2

Aritmetiska operatorer och variabler

Du kan också använda aritmetiska operatorer med variabler. Operatorerna agerar på variablernas värden. Följande exempel visar användningen av aritmetiska operatorer med variabler:

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

PS> $a = "Power"
PS> $b = "Shell"
PS> $a + $b
PowerShell

Aritmetiska operatorer och kommandon

Vanligtvis använder du de aritmetiska operatorerna i uttryck med tal, strängar och matriser. Du kan dock också använda aritmetiska operatorer med de objekt som kommandona returnerar och med egenskaperna för dessa objekt.

I följande exempel visas hur du använder aritmetiska operatorer i uttryck med PowerShell-kommandon:

(Get-Date) + (New-TimeSpan -day 1)

Parentesoperatorn tvingar utvärderingen av cmdleten Get-Date och utvärderingen av cmdlet-uttrycket i den New-TimeSpan -Day 1 ordningen. Båda resultaten läggs sedan till med operatorn + .

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

I uttrycket ovan multipliceras 2varje processarbetsutrymme ($_.ws) med ; och resultatet jämfört med 50mb för att se om det är större än så.

Bitvisa operatorer

PowerShell stöder standardoperatorer för bitvis, inklusive bitwise-AND (-band), inkluderande och exklusiva bitwise-OR-operatorer (-bor och -bxor), och bitwise-NOT (-bnot).

Från och med PowerShell 2.0 fungerar alla bitvis-operatorer med 64-bitars heltal.

Från och med PowerShell 3.0 -shr introduceras (skift-höger) och -shl (skift-vänster) för att stödja bitvis aritmetik i PowerShell.

PowerShell stöder följande bitvis-operatorer.

Operatör	beskrivning	Uttryck	Result
`-band`	Bitvis OCH	`10 -band 3`	2
`-bor`	Bitvis ELLER (inkluderande)	`10 -bor 3`	11
`-bxor`	Bitvis ELLER (exklusivt)	`10 -bxor 3`	9
`-bnot`	Bitvis INTE	`-bNot 10`	-11
`-shl`	Skift till vänster	`102 -shl 2`	408
`-shr`	Skift-höger	`102 -shr 1`	51

Bitvis-operatorer fungerar på binärformatet för ett värde. Bitstrukturen för talet 10 är till exempel 00001010 (baserat på 1 byte) och bitstrukturen för talet 3 är 00000011. När du använder en bitvis operator för att jämföra 10 till 3 jämförs de enskilda bitarna i varje byte.

I en bitvis AND-åtgärd är den resulterande biten inställd på 1 endast när båda indatabitarna är 1.

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

I en bitvis OR-åtgärd (inkluderande) är den resulterande biten inställd på 1 när endera eller båda indatabitarna är 1. Den resulterande biten är inställd på 0 endast när båda indatabitarna är inställda på 0.

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

I en bitvis OR-åtgärd (exklusiv) är den resulterande biten inställd på 1 endast när en indatabit är 1.

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

Bitwise NOT-operatorn är en unary-operator som producerar det binära komplementet av värdet. En bit av 1 är inställd på 0 och en bit av 0 är inställd på 1.

Det binära komplementet på 0 är till exempel -1, det maximala osignerade heltalet (0xFFFFFFFF) och det binära komplementet på -1 är 0.

-bNot 10

-11

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

I en bitvis skift-vänster-åtgärd flyttas alla bitar "n" till vänster, där "n" är värdet för den högra operanden. En nolla infogas på enplatsen.

Uttryck	Result	Binärt resultat
`21 -shl 0`	21	0001 0101
`21 -shl 1`	42	0010 1010
`21 -shl 2`	84	0101 0100

I en bitvis skift-höger-åtgärd flyttas alla bitar "n" platser till höger, där "n" anges av rätt operand. Skift-höger-operatorn (-shr) kopierar teckenbiten till den vänstra platsen när ett signerat värde flyttas. För osignerade värden infogas en nolla i den vänstra positionen.

Uttryck	Result	Binära	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