about_Arithmetic_Operators
Korte beschrijving
Beschrijft de operators die rekenkundige bewerkingen uitvoeren in PowerShell.
Lange beschrijving
Rekenkundige operatoren berekenen numerieke waarden. U kunt een of meer rekenkundige operatoren gebruiken om waarden toe te voegen, af te trekken, te vermenigvuldigen en te delen, en om de rest (modulus) van een delingsbewerking te berekenen.
Daarnaast werkt de operator voor optellen (+) en de operator voor vermenigvuldigen (*) 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-right) en -shl (shift-left) toegevoegd ter ondersteuning van bitgewijze rekenkundige bewerkingen in PowerShell.
PowerShell ondersteunt de volgende rekenkundige operators:
| Operator | Beschrijving | Voorbeeld |
|---|---|---|
| + | Voegt gehele getallen toe; samenvoegen | 6 + 2 |
| tekenreeksen, matrices en hash-tabellen. | "file" + "name" |
|
@(1, "one") + @(2.0, "two") |
||
@{"one" = 1} + @{"two" = 2} |
||
| + | Een getal van een object maken | + 123 |
| - | De ene waarde van een andere waarde aftrekken | 6 - 2 |
| waarde | ||
| - | Berekent het tegenovergestelde getal | - -6 |
(Get-Date).AddDays(-1) |
||
| * | Getallen vermenigvuldigen of tekenreeksen kopiëren | 6 * 2 |
| en matrices het opgegeven getal | @("!") * 4 |
|
| van tijden. | "!" * 3 |
|
| / | Verdeelt twee waarden. | 6 / 2 |
| % | Modulus - retourneert de rest van | 7 % 2 |
| een delingsbewerking. | ||
| -band | Bitsgewijze AND | 5 -band 3 |
| -bnot | Bitwise NOT | -bnot 5 |
| -bor | Bitsgewijze OR | 5 -bor 0x03 |
| -bxor | Bitwise XOR | 5 -bxor 3 |
| -shl | Hiermee worden bits naar links verplaatst | 102 -shl 2 |
| -shr | Hiermee worden bits naar rechts verplaatst | 102 -shr 2 |
De bitsgewijze operatoren werken alleen voor gehele getallen.
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:
| Expression | Resultaat |
|---|---|
3+6/3*4 |
11 |
3+6/(3*4) |
3.5 |
(3+6)/3*4 |
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 ingewikkelde toewijzingsinstructie.
$a = 0
$b = @(1,2)
$c = @(-1,-2)
$b[$a] = $c[$a++]
In dit voorbeeld wordt de expressie $a++ eerder $b[$a]geëvalueerd.
Bij het evalueren van $a++ wijzigingen wordt de waarde gewijzigd van $a nadat deze in de instructie $c[$a++]is gebruikt, maar voordat deze wordt gebruikt in $b[$a]. De variabele $a is $b[$a] gelijk aan 1, niet 0; dus wijst de instructie een waarde toe aan $b[1], niet $b[0].
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 delingsbewerking een geheel getal is, rondt PowerShell de waarde af op het dichtstbijzijnde gehele getal. Wanneer de waarde is .5, wordt deze afgerond op het dichtstbijzijnde even gehele getal.
In het volgende voorbeeld ziet u het effect van afronding naar het dichtstbijzijnde even gehele getal.
| Expression | Resultaat |
|---|---|
[int]( 5 / 2 ) |
2 |
[int]( 7 / 2 ) |
4 |
U ziet hoe 5/2 = 2,5 wordt afgerond op 2. Maar 7/2 = 3,5 wordt afgerond op 4.
U kunt de [Math] klasse gebruiken om verschillende afrondingsgedrag te krijgen.
| Expression | Resultaat |
|---|---|
[int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero) |
3 |
[int][Math]::Ceiling(5 / 2) |
3 |
[int][Math]::Floor(5 / 2) |
2 |
Zie de methode Math.Round voor meer informatie.
Niet-numerieke typen toevoegen en vermenigvuldigen
U kunt getallen, tekenreeksen, matrices en hashtabellen toevoegen. En u kunt getallen, tekenreeksen en matrices vermenigvuldigen. U kunt echter geen hashtabellen vermenigvuldigen.
Wanneer u tekenreeksen, matrices of hash-tabellen 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 probeert samen te voegen, 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 een van de objecten niet kan worden geconverteerd, mislukt de bewerking.
In de volgende voorbeelden ziet u het gebruik van de operatoren voor optellen en vermenigvuldigen; in bewerkingen met verschillende objecttypen.
Stel, $array = 1,2,3$red = [ConsoleColor]::Red, $blue = [ConsoleColor]::Blue:
| Expression | Resultaat |
|---|---|
"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 |
$blue + 3 |
Red |
$red - 3 |
Blue |
$blue - $red |
-3 |
+ '123' |
123 |
Omdat de methode die wordt gebruikt om instructies te evalueren, wordt bepaald door het meest linkse object, zijn optellen en vermenigvuldigen in PowerShell niet strikt commutatief. Is bijvoorbeeld (a + b) niet altijd gelijk (b + a)en (ab) is niet altijd gelijk (ba).
In de volgende voorbeelden ziet u dit principe:
| Expression | Resultaat |
|---|---|
"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 + "file"' |
Hash-tabellen zijn iets anders. U kunt hashtabellen toevoegen aan een andere hash-tabel, zolang de toegevoegde hashtabellen geen dubbele sleutels hebben.
In het volgende voorbeeld ziet u hoe u hashtabellen 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 wordt gedupliceerd.
$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
U kunt ook een hash-tabel toevoegen aan een matrix; en de hele hash-tabel wordt 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
A hash table can only be added to another hash table.
At line:3 char:1
+ $hash1 + 2
Hoewel de toevoegingsoperatoren erg nuttig zijn, kunt u de toewijzingsoperatoren gebruiken 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..9).foreach{ $array += $_ }
$array
0
1
2
Typeconversie voor resultaat
PowerShell selecteert automatisch het numerieke .NET-type dat het resultaat het beste uitdrukt zonder precisie te verliezen. 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 van het resultaat uitgebreid om het resultaat mogelijk te maken, zoals in het volgende voorbeeld:
(512MB).GetType().FullName
(512MB * 512MB).GetType().FullName
System.Int32
System.Double
Het type resultaat is niet noodzakelijkerwijs hetzelfde als een van de operanden.
In het volgende voorbeeld kan de negatieve waarde niet worden omgezet in een niet-ondertekend geheel getal en is het niet-ondertekende gehele getal te groot om te worden gecast naar Int32:
([int32]::minvalue + [uint32]::maxvalue).gettype().fullname
System.Int64
In dit voorbeeld Int64 kunnen beide typen worden gebruikt.
Het System.Decimal type is een uitzondering. Als een van beide operanden het decimaaltype heeft, wordt het resultaat van het decimaaltype. Als het resultaat te groot is voor het decimaaltype , wordt het niet gecast naar Dubbel. In plaats daarvan treedt er een fout op.
| Expression | Resultaat |
|---|---|
[Decimal]::maxvalue |
79228162514264337593543950335 |
[Decimal]::maxvalue + 1 |
Value was either too large or too small for a |
Decimal. |
Rekenkundige operatoren en variabelen
U kunt ook rekenkundige operatoren met variabelen gebruiken. De operators handelen op de waarden van de variabelen. In de volgende voorbeelden ziet u het gebruik van rekenkundige operatoren met variabelen:
| Expression | Resultaat |
|---|---|
$intA = 6$intB = 4$intA + $intB |
10 |
$a = "Power"$b = "Shell"$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 deze 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 haakjesoperator 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 2met ; 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-right) en -shl (shift-left) geïntroduceerd ter ondersteuning van bitsgewijze rekenkundige bewerkingen in PowerShell.
PowerShell ondersteunt de volgende bitsgewijze operators.
| Operator | Beschrijving | Expression | Resultaat |
|---|---|---|---|
-band |
Bitsgewijze AND | 10 -band 3 |
2 |
-bor |
Bitwise OR (inclusief) | 10 -bor 3 |
11 |
-bxor |
Bitwise OR (exclusief) | 10 -bxor 3 |
9 |
-bnot |
Bitwise NOT | -bNot 10 |
-11 |
-shl |
Shift-left | 102 -shl 2 |
408 |
-shr |
Shift-right | 102 -shr 1 |
51 |
Bitwise-operators handelen in 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 bitwise-operator gebruikt om 10 te vergelijken met 3, worden de afzonderlijke bits in elke byte vergeleken.
In een bitwise AND-bewerking wordt de resulterende bit alleen ingesteld op 1 wanneer beide invoer-bits 1 zijn.
1010 (10)
0011 ( 3)
-------------- bAND
0010 ( 2)
In een bitwise OR-bewerking (inclusief) wordt de resulterende bit ingesteld op 1 wanneer een of beide invoerbits 1 zijn. De resulterende bit is alleen ingesteld op 0 wanneer beide invoerbits zijn ingesteld op 0.
1010 (10)
0011 ( 3)
-------------- bOR (inclusive)
1011 (11)
In een bitwise OR-bewerking (exclusief) 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 de binaire aanvulling van de waarde produceert. Een bit van 1 is ingesteld op 0 en een bit van 0 is ingesteld op 1.
De binaire aanvulling van 0 is bijvoorbeeld -1, het maximum niet-ondertekende gehele getal (0xffffffff) en de binaire aanvulling van -1 is 0.
-bNot 10
-11
0000 0000 0000 1010 (10)
------------------------- bNOT
1111 1111 1111 0101 (-11, xfffffff5)
In een bitwise shift-left-bewerking worden alle bits naar links verplaatst, waarbij 'n' de waarde van de rechteroperand is. Er wordt een nul ingevoegd op de ene plaats.
Wanneer de linkeroperand een integerwaarde (32-bits) is, bepalen de onderste 5 bits van de rechteroperand hoeveel bits van de linkeroperand worden verschoven.
Wanneer de linkeroperand een lange (64-bits) waarde is, bepalen de onderste 6 bits van de rechteroperand hoeveel bits van de linkeroperand worden verschoven.
| Expression | Resultaat | Binair resultaat |
|---|---|---|
21 -shl 0 |
21 | 0001 0101 |
21 -shl 1 |
42 | 0010 1010 |
21 -shl 2 |
84 | 0101 0100 |
In een bitwise shift-right-bewerking worden alle bits naar rechts verplaatst, waarbij 'n' wordt opgegeven door de juiste operand. Met de operator shift-right (-shr) wordt een nul ingevoegd op de meest linkse plaats wanneer een positieve of niet-ondertekende waarde naar rechts wordt verplaatst.
Wanneer de linkeroperand een integerwaarde (32-bits) is, bepalen de onderste 5 bits van de rechteroperand hoeveel bits van de linkeroperand worden verschoven.
Wanneer de linkeroperand een lange (64-bits) waarde is, bepalen de onderste 6 bits van de rechteroperand hoeveel bits van de linkeroperand worden verschoven.
| Expression | Resultaat | Binair | Hex |
|---|---|---|---|
21 -shr 0 |
21 | 0001 0101 | 0x15 |
21 -shr 1 |
10 | 0000 1010 | 0x0A |
21 -shr 2 |
5 | 0000 0101 | 0x05 |
21 -shr 31 |
0 | 0000 0000 | 0x00 |
21 -shr 32 |
21 | 0001 0101 | 0x15 |
21 -shr 64 |
21 | 0001 0101 | 0x15 |
21 -shr 65 |
10 | 0000 1010 | 0x0A |
21 -shr 66 |
5 | 0000 0101 | 0x05 |
[int]::MaxValue -shr 1 |
1073741823 | 0x3FFFFFFF | |
[int]::MinValue -shr 1 |
-1073741824 | 0xC0000000 | |
-1 -shr 1 |
-1 | 0xFFFFFFFF |