about_Arithmetic_Operators
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-tabeller6 + 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 tal6 - 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ånger6 * 2 # result = 12 @("!") * 4 # result = @("!","!","!","!") "!" * 3 # result = "!!!"
Division (
/
) – Delar upp tal6 / 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 .5
avrundas 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 2
varje 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 |
Se även
Feedback
https://aka.ms/ContentUserFeedback.
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i:Skicka och visa feedback för