about_Arithmetic_Operators

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ási operátor (+) és a szorzás operátor (*) sztringeken, tömbökön és kivonattáblá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 kezdődően a -shr (shift-right) és a -shl (shift-left) a PowerShell bitenkénti számtani támogatására lesznek 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ámokat von ki vagy negál

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 NOT (-bnot)
```
-bnot 5  # result = -6
```
Bitenkénti OR (-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 ELSŐBBSÉGE

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

Elsőbbség	Operátor	Leírás
1	`()`	Zárójel
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 $a++ kifejezés kiértékelése $b[$a]előtt történik. A $a++ kiértékelése módosítja a $a értékét az utasításban $c[$a++], de a $b[$a]előtt. A $a változó $b[$a] értéke 1, nem pedig 0. Az utasítás ezért nem $b[1], hanem $b[0]rendel hozzá értéket.

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 .5, akkor a legközelebbi páros 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

A [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ÍPUSÁTALAKÍTÁS AZ EREDMÉNY ELHELYEZÉSÉHEZ

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éldául:

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ő át aláíratlan egész számra, és az aláíratlan egész szám túl nagy ahhoz, hogy 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 nagy [long] és [int] ad hozzá, az operandusok [double]lesznek átalakítva. Ebben a példában 9223372036854775807 egy [long] egész szám maximális értéke. Az érték hozzáadása túlcsordul a [long]tartományán.

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

Az eredmény [ulong] való megadása pontatlan eredményt ad, mivel az operandusok először [double] lettek kényszerítve.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

A nagyobb érték [ulong] definiálása először elkerüli a problémát, és a megfelelő eredményt eredményezi.

PS> 9223372036854775807ul + 2
9223372036854775809

A [ulong] tartományának túllépése azonban [double]eredményez.

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

Bigint aritmetika

Ha számtani műveleteket hajt végre [bigint] számokon, a PowerShell az összes operandus [bigint]lesz, ami nem egész számértékek csonkítását eredményezi. A [double] érték 1.9 például 1 lesz csonkítva [bigint].

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 egy [int] osztva [double] egy [double]eredményez. Az 1.9 egy [int] kerekítése 2értékre kerekít.

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 (a + b) nem mindig egyenlő (b + a), é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

ARITMETIKAI 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

ARITMETIKAI 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 a Get-Date parancsmag kiértékelését és a New-TimeSpan -Day 1 parancsmagkifejezés kiértékelését kényszeríti ebben a sorrendben. Ezután a rendszer mindkét eredményt hozzáadja a + 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 2; és az eredményt összehasonlítva 50mb, hogy kiderüljön, nagyobb-e ennél.

BITENKÉNTI OPERÁTOROK

A PowerShell támogatja a szabványos bitenkénti operátorokat, beleértve a bitwise-AND (-band), a befogadó és kizárólagos bitenkénti VAGY operátorokat (-bor és -bxor), valamint a bitwise-NOT (-bnot).

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 a -shl (shift-left) a PowerShell bitenkénti számtani támogatására kerülnek bevezetésre.

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

Operátor	Leírás	Kifejezés	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.

Kifejezés	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) az aláírt érték eltolásakor a bal oldali helyre másolja az előjelbitet. Aláíratlan értékek esetén a bal szélső pozícióba nulla kerül.

Kifejezés	Eredmény	Bináris	Rontás
`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

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-09-24