Om aritmetiska operatorer

Artikel
05/09/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 för att beräkna resten (modulus) av en divisionsåtgärd.

Dessutom körs additionsoperatorn (+) och multiplikationsoperatorn (*) på strängar, matriser och hash-tabeller. 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 med 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.

PowerShell stöder följande aritmetiska operatorer:

Operator	Beskrivning	Exempel
+	Lägger till heltal; Sammanfogar	`6 + 2`
	strängar, matriser och hash-tabeller.	`"file" + "name"`
		`@(1, "one") + @(2.0, "two")`
		`@{"one" = 1} + @{"two" = 2}`
-	Subtraherar ett värde från ett annat	`6 - 2`
	värde
-	Gör ett tal till ett negativt tal	`-6`
		`(Get-Date).AddDays(-1)`
*	Multiplicera siffror eller kopieringssträngar	`6 * 2`
	och matriser det angivna talet	`@("!") * 4`
	gånger.	`"!" * 3`
/	Delar upp två värden.	`6 / 2`
%	Modulus – returnerar resten av	`7 % 2`
	en divisionsåtgärd.
-Band	Bitvis OCH	`5 -band 3`
-bnot	Bitvis INTE	`-bnot 5`
-bor	Bitvis ELLER	`5 -bor 0x03`
-bxor	Bitvis XOR	`5 -bxor 3`
-Shl	Flyttar bitar till vänster	`102 -shl 2`
-Shr	Flyttar bitar åt höger	`102 -shr 2`

Bitvisoperatorerna fungerar bara med heltalstyper.

OPERATORPRIORITET

PowerShell bearbetar aritmetiska operatorer i följande ordning:

Prioritet	Operator	Beskrivning
1	`()`	Parentes
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:

Uttryck	Resultat
`3+6/3*4`	`11`
`3+6/(3*4)`	`3.5`
`(3+6)/3*4`	`12`

Den ordning i vilken PowerShell utvärderar uttryck kan 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 efter att det har använts i -instruktionen $c[$a++], men innan det används i $b[$a]. Variabeln $a i $b[$a] är lika med 1, inte 0; så instruktionen tilldelar 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.

Uttryck	Resultat
`[int]( 5 / 2 )`	`2`
`[int]( 7 / 2 )`	`4`

Observera hur 5/2 = 2,5 avrundas till 2. Men 7/2 = 3,5 avrundas till 4.

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

Uttryck	Resultat
`[int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero)`	`3`
`[int][Math]::Ceiling(5 / 2)`	`3`
`[int][Math]::Floor(5 / 2)`	`2`

Mer information finns i metoden Math.Round .

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 Framework typ av objektet längst till vänster i åtgärden. PowerShell försöker konvertera alla objekt i åtgärden till den .NET Framework typen av det första objektet. Om den lyckas konvertera objekten utför den den åtgärd som är lämplig för den .NET Framework typen av 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 operatorerna addition och multiplikation. i åtgärder som innehåller olika objekttyper. Anta $array = 1,2,3:

Uttryck	Resultat
`"file" + 16`	`file16`
`$array + 16`	`1`,`2`,`3`,`16`
`$array + "file"`	`1`,`2`,`3`,`file`
`$array * 2`	`1`,`2`,`3`,`1`,`2`,`3`
`"file" * 3`	`filefilefile`

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

Följande exempel visar den här principen:

Uttryck	Resultat
`"file" + 16`	`file16`
`16 + "file"`	`Cannot convert value "file" to type "System.Int32".`
	`Error: "Input string was not in a correct format."`
	`At line:1 char:1`
	+ 16 + "fil"'

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

Item has already been added. Key in dictionary: 'c'  Key being added: 'c'
At line:3 char:1
+ $hash1 + $hash2
+ ~~~~~~~~~~~~~~~
    + CategoryInfo          : OperationStopped: (:) [], ArgumentException
    + FullyQualifiedErrorId : System.ArgumentException

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

A hash table can only be added to another hash table.
At line:3 char:1
+ $hash1 + 2

Även om tilläggsoperatorerna är mycket användbara kan du använda 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..9).foreach{ $array += $_ }
$array

0
1
2

TYPKONVERTERING FÖR ATT HANTERA RESULTAT

PowerShell väljer automatiskt den .NET Framework numeriska typen som bäst uttrycker resultatet utan att förlora precisionen. 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 hantera resultatet, som i följande exempel:

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

System.Int32
System.Double

Resultatets typ är inte nödvändigtvis samma som en av operanderna. I följande exempel kan det negativa värdet inte omvandlas till ett osignerat heltal och det osignerade heltalet är för stort för att omvandlas till Int32:

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

System.Int64

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

Typen System.Decimal är ett undantag. Om någon av operanderna har typen Decimal blir resultatet av typen Decimal. Om resultatet är för stort för decimaltypen omvandlas det inte till Double. I stället resulterar ett fel.

Uttryck	Resultat
`[Decimal]::maxvalue`	`79228162514264337593543950335`
`[Decimal]::maxvalue + 1`	`Value was either too large or too small for a`
	`Decimal.`

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:

Uttryck	Resultat
`$intA = 6` `$intB = 4` `$intA + $intB`	`10`
`$a = "Power"` `$b = "Shell"` `$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 kommandon returnerar och med egenskaperna för dessa objekt.

I följande exempel visas hur du använder de aritmetiska operatorerna 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 bitvis OCH (-bAnd), inkluderande och exklusiva bitvis-OR-operatorer (-bOr och -bXor) och bitvis-NOT (-bNot).

Från och med PowerShell 2.0 fungerar alla bitvisa 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 bitvisa operatorer.

Operator	Beskrivning	Uttryck	Resultat
`-band`	Bitvis OCH	`10 -band 3`	2
`-bor`	Bitvis ELLER (inklusiv)	`10 -bor 3`	11
`-bxor`	Bitvis ELLER (exklusivt)	`10 -bxor 3`	9
`-bnot`	Bitvis INTE	`-bNot 10`	-11
`-shl`	Skift-vänster	`102 -shl 2`	408
`-shr`	Skift-höger	`102 -shr 1`	51

Bitvisa operatorer fungerar i 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 anges den resulterande biten endast till 1 när båda indatabitarna är 1.

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

I en bitvis ELLER-åtgärd (inklusiv) anges den resulterande biten till 1 när antingen eller båda indatabitarna är 1. Den resulterande biten anges endast till 0 när båda indatabitarna är inställda på 0.

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

I en bitvis ELLER-åtgärd (exklusiv) anges den resulterande biten endast till 1 när en indatabit är 1.

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

Den bitvisa NOT-operatorn är en enställig operator som producerar värdets binära komplement. Lite av 1 är inställt på 0 och lite av 0 är inställt 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, xfffffff5)

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.

När den vänstra operanden är ett heltalsvärde (32-bitars) avgör de nedre 5 bitarna av den högra operanden hur många bitar av den vänstra operanden som flyttas.

När den vänstra operanden är ett långt (64-bitars) värde avgör de lägre 6 bitarna av den högra operanden hur många bitar av den vänstra operanden som flyttas.

Uttryck	Resultat	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. Operatorn shift-right (-shr) infogar en nolla längst till vänster när du flyttar ett positivt eller osignerat värde till höger.