about_Arithmetic_Operators

Artikel
04/06/2024

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 op te tellen, af te trekken, te vermenigvuldigen en te delen, en om de rest (modulus) van een delingsbewerking te berekenen.

De operator voor optellen (+) en de operator voor vermenigvuldigen (*) werken ook op tekenreeksen, matrices en hashtabellen. De toevoegingsoperator 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 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 bitsgewijze rekenkundige bewerkingen in PowerShell. De bitsgewijze operatoren werken alleen voor gehele getallen.

PowerShell ondersteunt de volgende rekenkundige operatoren:

Optellen (+) - Getallen optellen, tekenreeksen, matrices en hash-tabellen samenvoegen

6 + 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 aftrekken

6 - 2   # result = 4
- -6    # result = 6
(Get-Date).AddDays(-1) # Yesterday's date

Vermenigvuldiging (*) - Getallen vermenigvuldigen of tekenreeksen kopiëren en matrices het opgegeven aantal keren
```
6 * 2       # result = 12
@("!") * 4  # result = @("!","!","!","!")
"!" * 3     # result = "!!!"
```
Delen (/) - Deelt getallen
```
6 / 2  # result = 3
```
Modulus (%) - retourneert de rest van een delingsbewerking.
```
7 % 2  # result = 1
```
Bitwise AND (-band)
```
5 -band 3  # result = 1
```
Bitwise NOT (-bnot)
```
-bnot 5  # result = -6
```
Bitsgewijze OR (-bor)
```
5 -bor 0x03  # result = 7
```
Bitwise 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
```

Operatorprioriteit

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++ 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 in $b[$a] is gelijk aan 1, niet 0. Daarom 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

Delen en afronden

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.

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 verschillende afrondingsgedrag te krijgen.

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 .NET-type dat het resultaat het beste uitdrukt zonder precisie te verliezen. Voorbeeld:

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 te verwerken, 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 niet-ondertekend geheel getal en is het niet-ondertekende gehele getal te groot om te worden omgezet in 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 decimale type heeft, is het resultaat Het type Decimaal . Een resultaat dat te groot is voor de decimale waarde, is een fout.

PS> [Decimal]::maxvalue
79228162514264337593543950335

PS> [Decimal]::maxvalue + 1
RuntimeException: Value was either too large or too small for a Decimal.

Potentieel verlies van precisie

Wanneer u een resultaat hebt dat het bereik van het type overschrijdt, loopt u het risico dat u precisie verliest vanwege typeconversie. Bijvoorbeeld het toevoegen van een voldoende grote [long] en [int] resulteert in de operanden die worden geconverteerd naar [double]. In dit voorbeeld 9223372036854775807 is dit de maximumwaarde van een [long] geheel getal. Als u toevoegt aan waarde, wordt het bereik van [long].

PS> (9223372036854775807 + 2).GetType().FullName
System.Double

Het resultaat gieten om [ulong] een onnauwkeurig resultaat te geven, omdat de operanden eerst werden [double] gecodeerd.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

Als u de grotere waarde definieert, [ulong] voorkomt u eerst het probleem en produceert u het juiste resultaat.

PS> 9223372036854775807ul + 2
9223372036854775809

Het overschrijden van het bereik van [ulong] resultaten in een [double].

PS> ([ulong]::MaxValue + 1).GetType().FullName
System.Double

Rekenkundige bigint

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 wanneer 1 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 wordt een [int] gedeeld door een [double] resultaat in een [double]. Het gieten 1.9 naar een [int] rondt de waarde naar boven af 2.

PS> 1 / 1.9
0.526315789473684
PS> 1 / [int]1.9
0.5

Niet-numerieke typen toevoegen en vermenigvuldigen

U kunt getallen, tekenreeksen, matrices en hash-tabellen toevoegen. En u kunt getallen, tekenreeksen en matrices vermenigvuldigen. U kunt echter geen hash-tabellen 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 hash-tabellen 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.

$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 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:

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 hash-tabel, zolang de toegevoegde hash-tabellen 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 hash-tabellen wordt 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 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

InvalidOperation: A hash table can only be added to another hash table.

Hoewel de toevoegingsoperatoren erg nuttig zijn, gebruikt u de toewijzingsoperatoren 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 gebruiken met variabelen. De operators handelen op 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 operators 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 operator haakjes dwingt de evaluatie van de Get-Date cmdlet en de evaluatie van de New-TimeSpan -Day 1 cmdlet-expressie af, in die volgorde. 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 met 2; en, het resultaat, vergeleken met 50mb om te zien of deze groter is dan dat.

Bitsgewijze operatoren

PowerShell ondersteunt de standaardoperators voor bitwise, 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	Expressie	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 (gebaseerd op 1 byte) en de bitstructuur voor het getal 3 is 00000011. Wanneer u een bitsgewijze operator gebruikt om 10 te vergelijken met 3, 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 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 bitsgewijze 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 bitsgewijze NOT-operator is een unaire operator die het binaire complement van de waarde produceert. Een bit van 1 is ingesteld op 0 en een bit van 0 is ingesteld op 1.

Het binaire complement van 0 is bijvoorbeeld -1, het maximum 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 is van de rechteroperand. Er wordt een nul ingevoegd op de plaats.

Expressie	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-right-bewerking worden alle bits naar rechts verplaatst, waarbij 'n' wordt opgegeven door de rechteroperand. De operator naar rechts van shift (-shr) kopieert de teken-bit naar de meest linkse plaats bij het verplaatsen van een ondertekende waarde. Voor niet-ondertekende waarden wordt een nul ingevoegd in de meest linkse positie.

Expressie	Resultaat	Binary	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

Delen via