about_Arithmetic_Operators
Korte beschrijving
Hierin worden de operators beschreven die rekenkundige bewerkingen uitvoeren in PowerShell.
Lange beschrijving
Rekenkundige operatoren berekenen numerieke waarden. U kunt een of meer rekenkundige operatoren gebruiken om waarden op te tellen, af te trekken, te vermenigvuldigen en te delen, en om de rest (modulus) van een delingsbewerking te berekenen.
De optellingsoperator (+
) en de vermenigvuldigingsoperator (*
) werken ook op tekenreeksen, matrices en hashtabellen. De operator voor optellen voegt de invoer samen.
De vermenigvuldigingsoperator retourneert meerdere kopieën van de invoer. U kunt zelfs objecttypen combineren in een rekenkundige instructie. De methode die wordt gebruikt om de instructie te evalueren, wordt bepaald door het type van het meest linkse object in de expressie.
Vanaf PowerShell 2.0 werken alle rekenkundige operatoren op 64-bits getallen.
Vanaf PowerShell 3.0 worden de -shr
(shift-rechts) en -shl
(shift-left) toegevoegd ter ondersteuning van bitsgewijze rekenkundige berekeningen in PowerShell. De bitsgewijze operatoren werken alleen voor typen gehele getallen.
PowerShell ondersteunt de volgende rekenkundige operators:
Optellen (
+
): telt getallen op, voegt tekenreeksen, matrices en hashtabellen toe6 + 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}
Aftrekken () -
-
Getallen aftrekken of verwijderen6 - 2 # result = 4 - -6 # result = 6 (Get-Date).AddDays(-1) # Yesterday's date
Vermenigvuldigen (
*
): getallen vermenigvuldigen of tekenreeksen en matrices kopiëren naar het opgegeven aantal keren6 * 2 # result = 12 @("!") * 4 # result = @("!","!","!","!") "!" * 3 # result = "!!!"
Deling (
/
) - verdeelt getallen6 / 2 # result = 3
Modulus (
%
): retourneert de rest van een delingbewerking.7 % 2 # result = 1
Bitwise AND (
-band
)5 -band 3 # result = 1
Bitwise NOT (
-bnot
)-bnot 5 # result = -6
Bitwise OR (
-bor
)5 -bor 0x03 # result = 7
Bitsgewijze XOR (
-bxor
)5 -bxor 3 # result = 6
Hiermee worden bits naar links verplaatst (
-shl
)102 -shl 2 # result = 408
Hiermee worden bits naar rechts verplaatst (
-shr
)102 -shr 2 # result = 25
Bewerkingsvolgorde van operators
PowerShell verwerkt rekenkundige operators in de volgende volgorde:
Prioriteit | Operator | Beschrijving |
---|---|---|
1 | () |
Haakjes |
2 | - |
Voor een negatief getal of een unaire operator |
3 | * , / , % |
Voor vermenigvuldigen en delen |
4 | + , - |
Voor optellen en aftrekken |
5 | -band , -bnot |
Voor bitsgewijze bewerkingen |
5 | -bor , -bxor |
Voor bitsgewijze bewerkingen |
5 | -shr , -shl |
Voor bitsgewijze bewerkingen |
PowerShell verwerkt de expressies van links naar rechts volgens de prioriteitsregels. In de volgende voorbeelden ziet u het effect van de prioriteitsregels:
3+6/3*4 # result = 11
3+6/(3*4) # result = 3.5
(3+6)/3*4 # result = 12
De volgorde waarin PowerShell expressies evalueert, kan verschillen van andere programmeer- en scripttalen die u hebt gebruikt. In het volgende voorbeeld ziet u een gecompliceerde toewijzingsinstructie.
$a = 0
$b = @(1,2)
$c = @(-1,-2)
$b[$a] = $c[$a++]
In dit voorbeeld wordt de expressie $a++
geëvalueerd vóór $b[$a]
. Als u evalueert $a++
, wordt de waarde van $a
gewijzigd nadat deze is gebruikt in de -instructie $c[$a++]
, maar voordat deze wordt gebruikt in $b[$a]
. De variabele $a
in $b[$a]
is 1
gelijk aan , niet 0
. Daarom wijst de -instructie een waarde toe aan , niet $b[0]
aan $b[1]
.
De bovenstaande code is gelijk aan:
$a = 0
$b = @(1,2)
$c = @(-1,-2)
$tmp = $c[$a]
$a = $a + 1
$b[$a] = $tmp
Deling en afronding
Wanneer het quotiënt van een delingbewerking een geheel getal is, rondt PowerShell de waarde af op het dichtstbijzijnde gehele getal. Wanneer de waarde is, wordt .5
deze afgerond op het dichtstbijzijnde even gehele getal.
In het volgende voorbeeld ziet u het effect van afronding op het dichtstbijzijnde even gehele getal.
PS> [int]( 5 / 2 ) # Result is rounded down
2
PS> [int]( 7 / 2 ) # Result is rounded up
4
U kunt de [Math]
klasse gebruiken om ander afrondingsgedrag op te halen.
PS> [int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero)
3
PS> [int][Math]::Ceiling(5 / 2)
3
PS> [int][Math]::Floor(5 / 2)
2
Zie de methode Math.Round voor meer informatie.
Typeconversie voor resultaat
PowerShell selecteert automatisch het numerieke type .NET dat het resultaat het beste uitdrukt zonder verlies van precisie. Bijvoorbeeld:
2 + 3.1
(2).GetType().FullName
(2 + 3.1).GetType().FullName
5.1
System.Int32
System.Double
Als het resultaat van een bewerking te groot is voor het type, wordt het type resultaat verbreed om het resultaat te accommoderen, zoals in het volgende voorbeeld:
(512MB).GetType().FullName
(512MB * 512MB).GetType().FullName
System.Int32
System.Double
Het type resultaat is niet altijd hetzelfde als een van de operanden. In het volgende voorbeeld kan de negatieve waarde niet worden omgezet in een geheel getal zonder teken en is het niet-ondertekende gehele getal te groot om naar Int32
te worden gecast:
([int32]::minvalue + [uint32]::maxvalue).gettype().fullname
System.Int64
In dit voorbeeld Int64
is geschikt voor beide typen.
Het System.Decimal
type is een uitzondering. Als een van de operands het type Decimaal heeft, is het resultaat Decimaaltype . Elk resultaat dat te groot is voor de decimaalwaarde , is een fout.
PS> [Decimal]::maxvalue
79228162514264337593543950335
PS> [Decimal]::maxvalue + 1
RuntimeException: Value was either too large or too small for a Decimal.
Mogelijk verlies van precisie
Wanneer u een resultaat hebt dat het bereik van het type overschrijdt, loopt u het risico dat u de precisie verliest als gevolg van typeconversie. Als u bijvoorbeeld een voldoende groot [long]
en [int]
toevoegt, worden de operanden geconverteerd naar [double]
. In dit voorbeeld 9223372036854775807
is de maximumwaarde van een [long]
geheel getal.
Als u toevoegt aan waarde, wordt het bereik van [long]
overschreven.
PS> (9223372036854775807 + 2).GetType().FullName
System.Double
Casten van het resultaat naar [ulong]
een onnauwkeurig resultaat, omdat de operanden eerst zijn afgetrokken [double]
.
PS> [ulong](9223372036854775807 + 2)
9223372036854775808
Als u de grotere waarde als [ulong]
eerste definieert, wordt het probleem vermeden en wordt het juiste resultaat gegenereerd.
PS> 9223372036854775807ul + 2
9223372036854775809
Overschrijdt echter het bereik van [ulong]
resultaten in een [double]
.
PS> ([ulong]::MaxValue + 1).GetType().FullName
System.Double
Bigint-berekeningen
Wanneer u rekenkundige bewerkingen uitvoert op [bigint]
getallen, worden in PowerShell alle operanden geconverteerd naar [bigint]
, wat resulteert in afkapping van niet-gehele getallen. De waarde wordt bijvoorbeeld [double]
afgekapt tot 1
wanneer deze wordt geconverteerd naar [bigint]
.1.9
PS> [bigint]1 / 1.9
1
PS> 1 / [bigint]1.9
1
Dit gedrag verschilt van het gedrag van andere numerieke typen. In dit voorbeeld resulteert een [int]
gedeeld door een [double]
in een [double]
. Casten 1.9
naar een [int]
rondt de waarde af op 2
.
PS> 1 / 1.9
0.526315789473684
PS> 1 / [int]1.9
0.5
Niet-numerieke typen optellen en vermenigvuldigen
U kunt getallen, tekenreeksen, matrices en hashtabellen toevoegen. En u kunt getallen, tekenreeksen en matrices vermenigvuldigen. U kunt hashtabellen echter niet vermenigvuldigen.
Wanneer u tekenreeksen, matrices of hashtabellen toevoegt, worden de elementen samengevoegd. Wanneer u verzamelingen, zoals matrices of hashtabellen, samenvoegt, wordt er een nieuw object gemaakt dat de objecten uit beide verzamelingen bevat. Als u hashtabellen met dezelfde sleutel wilt samenvoegen, mislukt de bewerking.
Met de volgende opdrachten worden bijvoorbeeld twee matrices gemaakt en vervolgens toegevoegd:
$a = 1,2,3
$b = "A","B","C"
$a + $b
1
2
3
A
B
C
U kunt ook rekenkundige bewerkingen uitvoeren op objecten van verschillende typen. De bewerking die PowerShell uitvoert, wordt bepaald door het Microsoft .NET-type van het meest linkse object in de bewerking. PowerShell probeert alle objecten in de bewerking te converteren naar het .NET-type van het eerste object. Als het lukt om de objecten te converteren, wordt de bewerking uitgevoerd die geschikt is voor het .NET-type van het eerste object. Als het converteren van een van de objecten mislukt, mislukt de bewerking.
In de volgende voorbeelden ziet u het gebruik van de operatoren voor optellen en vermenigvuldigen in bewerkingen met verschillende objecttypen.
$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
Omdat de methode die wordt gebruikt voor het evalueren van instructies wordt bepaald door het meest linkse object, zijn toevoeging en vermenigvuldigen in PowerShell niet strikt commutatief. Is bijvoorbeeld (a + b)
niet altijd gelijk aan (b + a)
, en (ab)
is niet altijd gelijk aan (ba)
.
In de volgende voorbeelden ziet u dit principe:
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-tabellen zijn iets anders. U kunt hashtabellen toevoegen aan een andere hashtabel, zolang de toegevoegde hash-tabellen geen dubbele sleutels hebben.
In het volgende voorbeeld ziet u hoe u hash-tabellen aan elkaar toevoegt.
$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
In het volgende voorbeeld wordt een fout gegenereerd omdat een van de sleutels in beide hashtabellen is gedupliceerd.
$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'
U kunt ook een hash-tabel toevoegen aan een matrix; en wordt de hele hash-tabel een item in de matrix.
$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
U kunt echter geen ander type toevoegen aan een hash-tabel.
$hash1 + 2
InvalidOperation: A hash table can only be added to another hash table.
Hoewel de opteloperators erg handig zijn, gebruikt u de toewijzingsoperators om elementen toe te voegen aan hashtabellen en matrices. Zie about_assignment_operators voor meer informatie. In de volgende voorbeelden wordt de toewijzingsoperator +=
gebruikt om items toe te voegen aan een matrix:
$array = @()
(0..2).foreach{ $array += $_ }
$array
0
1
2
Rekenkundige operatoren en variabelen
U kunt ook rekenkundige operatoren met variabelen gebruiken. De operators handelen op basis van de waarden van de variabelen. In de volgende voorbeelden ziet u het gebruik van rekenkundige operatoren met variabelen:
PS> $intA = 6
PS> $intB = 4
PS> $intA + $intB
10
PS> $a = "Power"
PS> $b = "Shell"
PS> $a + $b
PowerShell
Rekenkundige operatoren en opdrachten
Normaal gesproken gebruikt u de rekenkundige operatoren in expressies met getallen, tekenreeksen en matrices. U kunt echter ook rekenkundige operatoren gebruiken met de objecten die opdrachten retourneren en met de eigenschappen van die objecten.
In de volgende voorbeelden ziet u hoe u de rekenkundige operatoren gebruikt in expressies met PowerShell-opdrachten:
(Get-Date) + (New-TimeSpan -day 1)
De operator haakjes dwingt de evaluatie van de Get-Date
cmdlet en de evaluatie van de New-TimeSpan -Day 1
cmdlet-expressie in die volgorde af. Beide resultaten worden vervolgens toegevoegd met behulp van de +
operator.
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
In de bovenstaande expressie wordt elke proceswerkruimte ($_.ws
) vermenigvuldigd 2
met ; en, het resultaat, vergeleken met 50mb
om te zien of deze groter is dan dat.
Bitsgewijze operatoren
PowerShell ondersteunt de standaard bitsgewijze operators, waaronder bitwise-AND (-band
), de inclusieve en exclusieve bitwise-OR-operators (-bor
en -bxor
), en bitwise-NOT (-bnot
).
Vanaf PowerShell 2.0 werken alle bitsgewijze operators met 64-bits gehele getallen.
Vanaf PowerShell 3.0 worden de -shr
(shift-rechts) en -shl
(shift-left) geïntroduceerd ter ondersteuning van bitsgewijze rekenkundige berekeningen in PowerShell.
PowerShell ondersteunt de volgende bitsgewijze operators.
Operator | Beschrijving | Expression | Resultaat |
---|---|---|---|
-band |
Bitsgewijze AND | 10 -band 3 |
2 |
-bor |
Bitsgewijze OR (inclusief) | 10 -bor 3 |
11 |
-bxor |
Bitwise OR (exclusief) | 10 -bxor 3 |
9 |
-bnot |
Bitwise NOT | -bNot 10 |
-11 |
-shl |
Shift-links | 102 -shl 2 |
408 |
-shr |
Shift-rechts | 102 -shr 1 |
51 |
Bitsgewijze operators werken op basis van de binaire indeling van een waarde. De bitstructuur voor het getal 10 is bijvoorbeeld 00001010 (op basis van 1 byte) en de bitstructuur voor het getal 3 is 00000011. Wanneer u een bitsgewijze operator gebruikt om 10 tot 3 te vergelijken, worden de afzonderlijke bits in elke byte vergeleken.
In een bitsgewijze AND-bewerking wordt de resulterende bit alleen ingesteld op 1 wanneer beide invoerbits 1 zijn.
1010 (10)
0011 ( 3)
-------------- bAND
0010 ( 2)
In een bitsgewijze OF -bewerking (inclusief) wordt de resulterende bit ingesteld op 1 wanneer een of beide invoerbits 1 zijn. De resulterende bit wordt alleen ingesteld op 0 wanneer beide invoerbits zijn ingesteld op 0.
1010 (10)
0011 ( 3)
-------------- bOR (inclusive)
1011 (11)
In een bitsgewijze OF (exclusieve) bewerking wordt de resulterende bit alleen ingesteld op 1 wanneer één invoerbit 1 is.
1010 (10)
0011 ( 3)
-------------- bXOR (exclusive)
1001 ( 9)
De bitwise NOT-operator is een unaire operator die het binaire complement van de waarde produceert. Een bit van 1 is ingesteld op 0 en een beetje van 0 is ingesteld op 1.
Het binaire complement van 0 is bijvoorbeeld -1, het maximale niet-ondertekende gehele getal (0xFFFFFFFF) en het binaire complement van -1 is 0.
-bNot 10
-11
0000 0000 0000 1010 (10)
------------------------- bNOT
1111 1111 1111 0101 (-11, 0xFFFFFFF5)
In een bitsgewijze shift-left-bewerking worden alle bits 'n' naar links verplaatst, waarbij 'n' de waarde van de rechteroperand is. Er wordt een nul ingevoegd op de ene plaats.
Expression | Resultaat | Binair resultaat |
---|---|---|
21 -shl 0 |
21 | 0001 0101 |
21 -shl 1 |
42 | 0010 1010 |
21 -shl 2 |
84 | 0101 0100 |
In een bitsgewijze shift-rechts-bewerking worden alle bits 'n' naar rechts verplaatst, waar 'n' wordt opgegeven door de rechteroperand. De operator shift-right (-shr
) kopieert de tekenbit naar de meest linkse plaats bij het verplaatsen van een ondertekende waarde. Voor niet-ondertekende waarden wordt een nul ingevoegd op de meest linkse positie.
Expression | Resultaat | Binair | 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 |