about_Arithmetic_Operators

Rövid leírás

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

Hosszú leírás

Az aritmetikai operátorok numerikus értékeket számolnak ki. Egy vagy több aritmetikai operátort használhat értékek összeadására, kivonására, szorzására és osztására, valamint egy osztási művelet maradékának (modulusának) kiszámítására.

Az összeadási operátor (+) és a szorzási 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. Akár az objektumtípusokat is kombinálhatja egy aritmetikai utasításban. 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 aritmetikai operátor 64 bites számokon dolgozik.

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

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

  • Összeadá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 negálása

    6 - 2   # result = 4
    - -6    # result = 6
    (Get-Date).AddDays(-1) # Yesterday's date
    
  • Szorzás (*) – Számok szorzása vagy sztringek és tömbök másolása a megadott számú alkalommal

    6 * 2       # result = 12
    @("!") * 4  # result = @("!","!","!","!")
    "!" * 3     # result = "!!!"
    
  • Osztás (/) – Számokat oszt

    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:

Precedencia Operátor Leírás
1 () Kerek zárójelek
2 - Negatív szám vagy unáris 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 haladva 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 kifejezések PowerShell-kiértékelési sorrendje eltérhet a többi használt programnyelvtől és szkriptelési nyelvtő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 korábban $b[$a]történik. $a++ Az értékelés megváltoztatja $a az utasításban $c[$a++]használt érték értékét, de még azelőtt, hogy felhasználja.$b[$a] A változó $a egyenlő1, $b[$a] 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 az .5, akkor a legközelebbi páros egész számra kerekít.

Az alábbi példa a legközelebbi páros egész számra való 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ót a Math.Round metódusban talál.

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 az elemek összefűződnek. 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 sikertelen lesz.

A következő parancsok például létrehoznak két tömböt, 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égezhet. 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 tudja konvertálni, a művelet sikertelen lesz.

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éhez használt metódust a bal szélső objektum határozza meg, a PowerShellben való összeadás és szorzás nem szigorúan ingmutatí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. A kivonattáblákat hozzáadhatja egy másik kivonattáblához, ha a hozzáadott kivonattáblák nem rendelkeznek ismétlődő 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 duplikálva van mindkét kivonattáblában.

$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 kivonattáblát is hozzáadhat egy tömbhöz; és a teljes kivonattábla a tömb 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átorral adnak hozzá elemeket egy tömbhöz:

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

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é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ípusa az alábbi példához hasonlóan ki lesz szélesedve:

(512MB).GetType().FullName
(512MB * 512MB).GetType().FullName
System.Int32
System.Double

Az eredmény típusa nem mindig egyezik meg az operandusok egyikével. A következő példában a negatív értéket nem lehet aláíratlan egész számra átírni, é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ípusú, az eredmény Tizedes 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.

Aritmetikai operátorok és változók

Aritmetikai operátorokat változókkal is használhat. 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 Kifejezésekben PowerShell-parancsokkal:

(get-date) + (new-timespan -day 1)

A zárójel operátor a parancsmag kiértékelését Get-Date és a New-TimeSpan -Day 1 parancsmagkifejezés kiértékelését kényszeríti ki ebben a sorrendben. 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 2a ; és az eredmény összeszorozza 50mb , hogy megállapítsa, nagyobb-e ennél.

Bitenkénti operátorok

A PowerShell támogatja a szabványos 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 BitWise aritmetikai támogatásához vezet be a PowerShellben.

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 OR (beleértve) 10 -bor 3 11
-bxor Bitenkénti OR (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 csak akkor van 1-re állítva, ha mindkét bemeneti bit 1.

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

Bitenkénti VAGY (inkluzív) 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 unáris operátor, amely az érték bináris kiegészítését állítja elő. Az 1 bit értéke 0, a bit 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, xfffffff5)

Egy bitenkénti shift-left műveletben az összes bit "n" helyre kerül balra, ahol az "n" a jobb operandus értéke. Az egyes helyeken egy nulla van beszúrva.

Ha a bal operandus egész szám (32 bites) érték, a jobb operandus alsó 5 bitje határozza meg, hogy a bal operandus hány bitje tolódik el.

Ha a bal operandus hosszú (64 bites) érték, a jobb operandus alsó 6 bitje határozza meg, hogy a bal operandus hány bitet tol el.

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

A bitenkénti shift-right műveletben az összes bit jobbra kerül az "n" helyre, ahol az "n" értéket a jobb operandus határozza meg. A shift-right operátor (-shr) egy nullát szúr be a bal szélső helyre, amikor pozitív vagy aláíratlan értéket helyez jobbra.

Ha a bal operandus egész szám (32 bites) érték, a jobb operandus alsó 5 bitje határozza meg, hogy a bal operandus hány bitje tolódik el.

Ha a bal operandus hosszú (64 bites) érték, a jobb operandus alsó 6 bitje határozza meg, hogy a bal operandus hány bitet tol el.

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

Lásd még