about_Arithmetic_Operators
Korte beschrijving
Hierin worden de operators beschreven die berekeningen 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.
Bovendien werken de operator voor optellen (+) en de vermenigvuldigingsoperator (*) ook op tekenreeksen, matrices en hashtabellen. De operator voor optellen voegt de invoer samen. De operator voor vermenigvuldigen 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.
PowerShell ondersteunt de volgende rekenkundige operatoren:
| Operator | Beschrijving | Voorbeeld |
|---|---|---|
| + | Hiermee worden gehele getallen toegevoegd; samenvoegingen | 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 de andere 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 | Bits naar links verplaatsen | 102 -shl 2 |
| -shr | Bits naar rechts verplaatsen | 102 -shr 2 |
De bitwise operators werken alleen op 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 afwijken 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++ 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 1gelijk aan , niet 0. De instructie wijst dus een waarde toe aan , niet $b[0].$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 delingsbewerking een geheel getal is, rondt PowerShell de waarde af op het dichtstbijzijnde gehele getal. Wanneer de waarde is, wordt .5deze afgerond op het dichtstbijzijnde even gehele getal.
In het volgende voorbeeld ziet u het effect van afronding op 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 ander afrondingsgedrag op te halen.
| 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 optellen en vermenigvuldigen
U kunt getallen, tekenreeksen, matrices en hash-tabellen toevoegen. En u kunt getallen, tekenreeksen en matrices vermenigvuldigen. U kunt hash-tabellen echter niet vermenigvuldigen.
Wanneer u tekenreeksen, matrices of hash-tabellen toevoegt, worden de elementen samengevoegd. Wanneer u verzamelingen, zoals matrices of hash-tabellen, samenvoegt, wordt er een nieuw object gemaakt dat de objecten uit beide verzamelingen bevat. Als u hashtabellen met dezelfde sleutel probeert samen te stellen, 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 die verschillende objecttypen bevatten.
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 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:
| 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 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
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 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
A hash table can only be added to another hash table.
At line:3 char:1
+ $hash1 + 2
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..9).foreach{ $array += $_ }
$array
0
1
2
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 noodzakelijkerwijs 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 te worden gecast naar Int32:
([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 van het type Decimaal. Als het resultaat te groot is voor het type Decimaal , wordt het niet naar Dubbel gecast. 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 basis van 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 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 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-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 op 1 ingesteld als 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 op 0 ingesteld 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, xfffffff5)
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.
Wanneer de linkeroperand een geheel getal (32-bits) is, bepaalt de onderste 5 bits van de rechteroperand hoeveel bits van de linkeroperand worden verschoven.
Wanneer de linkeroperand een lange waarde (64-bits) is, bepaalt 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 bitsgewijze shift-rechts-bewerking worden alle bits 'n' naar rechts verplaatst, waar 'n' wordt opgegeven door de rechteroperand. Met de operator shift-right (-shr) wordt een nul op de meest linkse plaats ingevoegd wanneer een positieve of niet-ondertekende waarde naar rechts wordt verplaatst.
Wanneer de linkeroperand een geheel getal (32-bits) is, bepaalt de onderste 5 bits van de rechteroperand hoeveel bits van de linkeroperand worden verschoven.
Wanneer de linkeroperand een lange waarde (64-bits) is, bepaalt 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 |