about_Arithmetic_Operators

Cikk
04/06/2024

Rövid leírás

A PowerShellben aritmetikai műveleteket végző operátorokat ismerteti.

Hosszú leírás

Számtani operátorok numerikus értékeket számolnak ki. Egy vagy több aritmetikai operátor használatával hozzáadhat, kivonhat, szorozhat és oszthat értékeket, és kiszámíthatja az osztási művelet fennmaradó részét (modulusát).

Az összeadás operátor (+) és a szorzási operátor (*) sztringeken, tömbökön és kivonatolókon is működik. Az összeadási operátor összefűzi a bemenetet. A szorzási operátor a bemenet több példányát adja vissza. Az objektumtípusokat aritmetikai utasításban is kombinálhatja. Az utasítás kiértékeléséhez használt metódust a kifejezés bal szélső objektumának típusa határozza meg.

A PowerShell 2.0-tól kezdve minden számtani operátor 64 bites számokon dolgozik.

A PowerShell 3.0-tól kezdve a -shr (shift-right) és -shl a (shift-left) a PowerShell bitenkénti számtani támogatására lesz hozzáadva. A bitenkénti operátorok csak egész számtípusokon működnek.

A PowerShell a következő számtani operátorokat támogatja:

Hozzáadás (+) – Számokat ad hozzá, sztringeket, tömböket és kivonattáblákat fűz össze

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}

Kivonás (-) – Számok kivonása vagy tagadása

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

Szorzás (*) – Számok szorzása vagy sztringek másolása és tömbök szorzása a megadott számú alkalommal
```
6 * 2       # result = 12
@("!") * 4  # result = @("!","!","!","!")
"!" * 3     # result = "!!!"
```
Osztás (/) – Számok osztása
```
6 / 2  # result = 3
```
Modulus (%) – az osztási művelet hátralévő részét adja vissza.
```
7 % 2  # result = 1
```
Bitenkénti ÉS (-band)
```
5 -band 3  # result = 1
```
Bitenkénti NEM (-bnot)
```
-bnot 5  # result = -6
```
Bitenkénti VAGY (-bor)
```
5 -bor 0x03  # result = 7
```
Bitenkénti XOR (-bxor)
```
5 -bxor 3   # result = 6
```
Bitek balra váltása (-shl)
```
102 -shl 2  # result = 408
```
Bitek jobbra váltása (-shr)
```
102 -shr 2  # result = 25
```

Operátorok műveleti sorrendje

A PowerShell az alábbi sorrendben dolgozza fel az aritmetikai operátorokat:

Prioritás	Operátor	Leírás
0	`()`	Zárójelek
2	`-`	Negatív szám vagy nem szereplő operátor esetén
3	`*`, , `/%`	Szorzáshoz és osztáshoz
4	`+`, `-`	Összeadáshoz és kivonáshoz
5	`-band`, `-bnot`	Bitenkénti műveletekhez
5	`-bor`, `-bxor`	Bitenkénti műveletekhez
5	`-shr`, `-shl`	Bitenkénti műveletekhez

A PowerShell balról jobbra dolgozza fel a kifejezéseket az elsőbbségi szabályok szerint. Az alábbi példák az elsőbbségi szabályok hatását mutatják be:

3+6/3*4    # result = 11
3+6/(3*4)  # result = 3.5
(3+6)/3*4  # result = 12

A PowerShell kifejezéseinek kiértékelési sorrendje eltérhet a használt más programozási és szkriptelési nyelvektől. Az alábbi példa egy bonyolult hozzárendelési utasítást mutat be.

$a = 0
$b = @(1,2)
$c = @(-1,-2)

$b[$a] = $c[$a++]

Ebben a példában a kifejezés $a++ kiértékelése előtt $b[$a]történik. Az érték kiértékelése az utasításban $c[$a++]való használat után, de még a használat előtt módosítja a függvény értékét$b[$a].$a$a++ A változó $a$b[$a] értéke egyenlő 1, nem 0. Ezért az utasítás egy értéket rendel hozzá $b[1], nem $b[0].

A fenti kód a következőnek felel meg:

$a = 0
$b = @(1,2)
$c = @(-1,-2)

$tmp = $c[$a]
$a = $a + 1
$b[$a] = $tmp

Osztás és kerekítés

Ha egy osztási művelet hányadosa egész szám, a PowerShell az értéket a legközelebbi egész számra kerekíti. Ha az érték, .5akkor a legközelebbi egész számra kerekül.

Az alábbi példa a legközelebbi egész számra történő kerekítés hatását mutatja be.

PS> [int]( 5 / 2 )  # Result is rounded down
2

PS> [int]( 7 / 2 )  # Result is rounded up
4

Az [Math] osztály használatával különböző kerekítési viselkedést kaphat.

PS> [int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero)
3

PS> [int][Math]::Ceiling(5 / 2)
3

PS> [int][Math]::Floor(5 / 2)
2

További információ: Math.Round metódus.

Típuskonvertálás az eredménynek megfelelően

A PowerShell automatikusan kiválasztja azt a .NET-numerikus típust, amely a pontosság elvesztése nélkül fejezi ki a legjobban az eredményt. Példa:

2 + 3.1
(2).GetType().FullName
(2 + 3.1).GetType().FullName

5.1
System.Int32
System.Double

Ha egy művelet eredménye túl nagy a típushoz, az eredmény típusának ki lesz szélesítve az eredményhez való igazodáshoz, ahogyan az alábbi példában látható:

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

System.Int32
System.Double

Az eredmény típusa nem mindig ugyanaz, mint az egyik operandus. Az alábbi példában a negatív érték nem vethető alá egy aláíratlan egész számra, és az aláíratlan egész szám túl nagy ahhoz, hogy a következőre lehessen leadni Int32:

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

System.Int64

Ebben a példában Int64 mindkét típust el tudja fogadni.

A System.Decimal típus kivétel. Ha bármelyik operandus decimális típussal rendelkezik, az eredmény decimális típus. A decimális értékhez túl nagy eredmény hiba.

PS> [Decimal]::maxvalue
79228162514264337593543950335

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

A pontosság lehetséges elvesztése

Ha olyan eredményt ad meg, amely meghaladja a típus tartományát, a típuskonvertálás miatt elveszíti a pontosságot. Ha például elég nagyot [long] ad hozzá, és [int] az operandusok átalakítva [double]lesznek. Ebben a példában 9223372036854775807 egy egész szám maximális értéke [long] látható. Az érték hozzáadása túlcsordul a tartományon [long].

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

Az eredmény [ulong] megadása pontatlan eredményt ad, mert az operandusokat az elsőre [double] kényszerítették.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

A nagyobb érték elsőként való [ulong] definiálása elkerüli a problémát, és a megfelelő eredményt eredményezi.

PS> 9223372036854775807ul + 2
9223372036854775809

Az eredménytartomány túllépése [ulong] azonban a [double].

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

Bigint aritmetika

Ha számokon [bigint] aritmetikai műveleteket hajt végre, a PowerShell az összes operandust [bigint]átalakítja , ami nem egész számértékek csonkolását eredményezi. Az értéket például [double] csonkolja a 1 program a konvertáláskor[bigint].1.9

PS> [bigint]1 / 1.9
1
PS> 1 / [bigint]1.9
1

Ez a viselkedés eltér a többi numerikus típus viselkedésétől. Ebben a példában a [int] találatok [double] osztva egy [double]. Az érték 1.9 egy [int] adott értékre kerekítése felfelé kerekít.2

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

Nem numerikus típusok hozzáadása és szorzása

Hozzáadhat számokat, sztringeket, tömböket és kivonattáblákat. Számokat, sztringeket és tömböket szorozhat. A kivonattáblák azonban nem szorozhatók.

Sztringek, tömbök vagy kivonattáblák hozzáadásakor a rendszer összefűzi az elemeket. Gyűjtemények, például tömbök vagy kivonattáblák összefűzésekor létrejön egy új objektum, amely mindkét gyűjtemény objektumait tartalmazza. Ha ugyanazzal a kulccsal rendelkező kivonattáblákat próbál összefűzni, a művelet meghiúsul.

A következő parancsok például két tömböt hoznak létre, majd hozzáadják őket:

$a = 1,2,3
$b = "A","B","C"
$a + $b

1
2
3
A
B
C

A különböző típusú objektumokon aritmetikai műveleteket is végrehajthat. A PowerShell által végrehajtott műveletet a művelet bal szélső objektumának Microsoft .NET-típusa határozza meg. A PowerShell megpróbálja átalakítani a művelet összes objektumát az első objektum .NET-típusára. Ha sikeresen konvertálja az objektumokat, végrehajtja az első objektum .NET-típusának megfelelő műveletet. Ha egyik objektumot sem konvertálja, a művelet meghiúsul.

Az alábbi példák az összeadási és szorzási operátorok különböző objektumtípusokat tartalmazó műveletekben való használatát mutatják be.

$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

Mivel az utasítások kiértékelésére használt metódust a bal szélső objektum határozza meg, a PowerShellben a hozzáadás és a szorzás nem szigorúan inmutatív. Például nem mindig egyenlő (b + a), (a + b) és (ab) nem mindig egyenlő (ba).

Az alábbi példák ezt az elvet mutatják be:

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."

A kivonattáblák kissé eltérőek. Kivonattáblákat egy másik kivonattáblához is hozzáadhat, amíg a hozzáadott kivonattáblák nem rendelkeznek duplikált kulcsokkal.

Az alábbi példa bemutatja, hogyan adhat egymáshoz kivonattáblákat.

$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

Az alábbi példa hibát jelez, mert az egyik kulcs mindkét kivonattáblában duplikálva van.

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

Emellett hozzáadhat egy kivonattáblát egy tömbhöz; és a teljes kivonattábla a tömb egyik elemévé válik.

$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

A kivonattáblákhoz azonban nem adhat hozzá más típust.

$hash1 + 2

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

Bár az összeadási operátorok nagyon hasznosak, a hozzárendelési operátorokkal elemeket adhat hozzá kivonattáblákhoz és tömbökhöz. További információ: about_assignment_operators. Az alábbi példák a += hozzárendelési operátor használatával adnak hozzá elemeket egy tömbhöz:

$array = @()
(0..2).foreach{ $array += $_ }
$array

0
1
2

Számtani operátorok és változók

Az aritmetikai operátorokat változókkal is használhatja. Az operátorok a változók értékeire reagálnak. Az alábbi példák az aritmetikai operátorok változókkal való használatát mutatják be:

PS> $intA = 6
PS> $intB = 4
PS> $intA + $intB
10

PS> $a = "Power"
PS> $b = "Shell"
PS> $a + $b
PowerShell

Számtani operátorok és parancsok

Az aritmetikai operátorokat általában számokkal, sztringekkel és tömbökkel rendelkező kifejezésekben használja. Az aritmetikai operátorokat azonban a parancsok által visszaadott objektumokkal és az objektumok tulajdonságaival is használhatja.

Az alábbi példák bemutatják, hogyan használhatók az aritmetikai operátorok a PowerShell-parancsokkal rendelkező kifejezésekben:

(Get-Date) + (New-TimeSpan -day 1)

A zárójel operátor ebben a sorrendben kényszeríti a Get-Date parancsmag kiértékelését és a New-TimeSpan -Day 1 parancsmagkifejezés kiértékelését. Ezután a rendszer mindkét eredményt hozzáadja az + operátorral.

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

A fenti kifejezésben a folyamat minden munkaterét ($_.ws) megszorozza 2az ; és az eredmény, összehasonlítva 50mb azzal, hogy nagyobb-e ennél.

Bitenkénti operátorok

A PowerShell támogatja a szokásos bitenkénti operátorokat, beleértve a bitenkénti ÉS (-band), a befogadó és kizárólagos bitenkénti VAGY operátorokat (-bor és -bxor), és a bitenkénti-NOT (-bnot) operátorokat.

A PowerShell 2.0-tól kezdve minden bitenkénti operátor 64 bites egész számokkal dolgozik.

A PowerShell 3.0-tól kezdve a -shr (shift-right) és -shl a (shift-left) a PowerShell bitenkénti aritmetikai támogatása érdekében kerül bevezetésre.

A PowerShell a következő bitenkénti operátorokat támogatja.

Operátor	Leírás	Expression	Eredmény
`-band`	Bitenkénti ÉS	`10 -band 3`	2
`-bor`	Bitenkénti VAGY (beleértve)	`10 -bor 3`	11
`-bxor`	Bitenkénti VAGY (kizárólagos)	`10 -bxor 3`	9
`-bnot`	Bitenkénti NEM	`-bNot 10`	-11
`-shl`	Shift-left	`102 -shl 2`	408
`-shr`	Shift-right	`102 -shr 1`	51

A bitenkénti operátorok egy érték bináris formátumán működnek. A 10-es szám bitstruktúrája például 00001010 (1 bájt alapján), a 3-at pedig 00000011. Ha bitenkénti operátorral hasonlítja össze a 10-3-at, az egyes bájtok egyes bitjeinek összehasonlítása történik.

Bitenkénti ÉS művelet esetén az eredményül kapott bit értéke csak akkor 1, ha mindkét bemeneti bit 1.

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

Bitenkénti VAGY (befogadó) művelet esetén az eredményül kapott bit értéke 1, ha vagy mindkét bemeneti bit 1. Az eredményként kapott bit értéke csak akkor 0, ha mindkét bemeneti bit értéke 0.

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

Bitenkénti VAGY (kizárólagos) művelet esetén az eredményül kapott bit csak akkor van 1-re állítva, ha egy bemeneti bit 1.

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

A bitenkénti NOT operátor egy unary operátor, amely az érték bináris kiegészítését hozza létre. Az 1 bit értéke 0, a 0 pedig 1.

A 0 bináris kiegészítése például -1, a maximális aláíratlan egész szám (0xFFFFFFFF), a -1 bináris kiegészítése pedig 0.

-bNot 10

-11

0000 0000 0000 1010  (10)
------------------------- bNOT
1111 1111 1111 0101  (-11, 0xFFFFFFF5)

Egy bitenkénti shift-left műveletben a rendszer az összes bitet balról az "n" helyre helyezi át, ahol az "n" a jobb operandus értéke. A beszúrt zérus az egyes helyeken van beszúrva.

Expression	Eredmény	Bináris eredmény
`21 -shl 0`	21	0001 0101
`21 -shl 1`	42	0010 1010
`21 -shl 2`	84	0101 0100

Egy bitenkénti shift-right műveletben az összes bit jobbra kerül az "n" helyre, ahol az "n" értéket a jobb operandus adja meg. A shift-right operátor (-shr) átmásolja a jelbitet a bal oldali helyre egy aláírt érték eltolásakor. Aláíratlan értékek esetén a bal szélső pozícióba nulla kerül.

Expression	Eredmény	Bináris	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