about_Arithmetic_Operators

Článek
04/06/2024

Krátký popis

Popisuje operátory, které provádějí aritmetické operace v PowerShellu.

Dlouhý popis

Aritmetické operátory vypočítají číselné hodnoty. Pomocí jednoho nebo více aritmetických operátorů můžete sčítat, odčítat, násobit a dělit hodnoty a vypočítat zbytek operace dělení (moduly).

Operátor sčítání (+) a operátor násobení (*) také pracují s řetězci, poli a hashtables. Operátor sčítání zřetězí vstup. Operátor násobení vrátí více kopií vstupu. V aritmetickém příkazu můžete dokonce kombinovat typy objektů. Metoda, která se používá k vyhodnocení příkazu, je určena typem levého objektu ve výrazu.

Počínaje PowerShellem 2.0 fungují všechny aritmetické operátory na 64bitových číslech.

Počínaje PowerShellem 3.0 -shr se přidávají (shift-right) a -shl (shift-left) pro podporu bitových aritmetik v PowerShellu. Bitové operátory pracují pouze na celočíselné typy.

PowerShell podporuje následující aritmetické operátory:

Sčítání (+) – sčítání čísel, zřetězení řetězců, polí a hashovacích tabulek

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}

Odčítání (-) – odečítá nebo negates čísla

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

Násobení (*) – Násobení čísel nebo kopírování řetězců a polí zadaný početkrát

6 * 2       # result = 12
@("!") * 4  # result = @("!","!","!","!")
"!" * 3     # result = "!!!"

Dělení (/) – vyděluje čísla.
```
6 / 2  # result = 3
```
Moduls (%) – vrátí zbytek operace dělení.
```
7 % 2  # result = 1
```
Bitový operátor AND (-band)
```
5 -band 3  # result = 1
```
Bitové NOT (-bnot)
```
-bnot 5  # result = -6
```
Bitový operátor OR (-bor)
```
5 -bor 0x03  # result = 7
```
Bitový XOR (-bxor)
```
5 -bxor 3   # result = 6
```
Posune bity doleva (-shl)
```
102 -shl 2  # result = 408
```
Posune bity doprava (-shr)
```
102 -shr 2  # result = 25
```

Priorita operátorů

PowerShell zpracovává aritmetické operátory v následujícím pořadí:

Pořadí podle priority	Operátor	Popis
1	`()`	Závorky
2	`-`	Záporné číslo nebo unární operátor
3	`*`, , `/%`	Pro násobení a dělení
4	`+`, `-`	Pro sčítání a odčítání
5	`-band`, `-bnot`	Pro bitové operace
5	`-bor`, `-bxor`	Pro bitové operace
5	`-shr`, `-shl`	Pro bitové operace

PowerShell zpracovává výrazy zleva doprava podle pravidel priority. Následující příklady ukazují účinek pravidel priority:

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

Pořadí, ve kterém PowerShell vyhodnocuje výrazy, se může lišit od jiných programovacích a skriptových jazyků, které jste použili. Následující příklad ukazuje složitý příkaz přiřazení.

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

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

V tomto příkladu je výraz $a++ vyhodnocen před $b[$a]. Vyhodnocení $a++ změní hodnotu $a poté, co se použije v příkazu $c[$a++], ale předtím, než se použije v $b[$a]. Proměnná $a se $b[$a] rovná 1, ne 0. Proto příkaz přiřadí hodnotu $b[1], nikoli $b[0].

Výše uvedený kód odpovídá:

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

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

Dělení a zaokrouhlování

Pokud je podíl operace dělení celé číslo, PowerShell zaokrouhlí hodnotu na nejbližší celé číslo. Pokud je .5hodnota , zaokrouhlí se na nejbližší sudé celé číslo.

Následující příklad ukazuje efekt zaokrouhlení na nejbližší sudé celé číslo.

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

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

Třídu můžete použít k získání jiného [Math] chování zaokrouhlování.

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

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

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

Další informace naleznete v metodě Math.Round .

Převod typu pro přizpůsobení výsledku

PowerShell automaticky vybere číselný typ .NET, který nejlépe vyjadřuje výsledek bez ztráty přesnosti. Příklad:

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

5.1
System.Int32
System.Double

Pokud je výsledek operace pro typ příliš velký, je typ výsledku rozšířen tak, aby vyhovoval výsledku, jako v následujícím příkladu:

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

System.Int32
System.Double

Typ výsledku není vždy stejný jako jeden z operandů. V následujícím příkladu nelze přetypovat zápornou hodnotu na celé číslo bez znaménka a celé číslo bez znaménka je příliš velké, aby bylo možné přetypovat na Int32:

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

System.Int64

V tomto příkladu Int64 lze použít oba typy.

Typ System.Decimal je výjimka. Pokud má některý operand typ Desetinné číslo , je výsledkem typ Desetinné číslo . Jakýkoli výsledek je pro desetinnou hodnotu příliš velký.

PS> [Decimal]::maxvalue
79228162514264337593543950335

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

Potenciální ztráta přesnosti

Kdykoli máte výsledek, který překračuje rozsah typu, riskujete ztrátu přesnosti z důvodu převodu typu. Například přidáním dostatečně velkého [long] operandu a [int] výsledkem je převod operandů na [double]. V tomto příkladu 9223372036854775807 je maximální hodnota celého čísla [long] . Přidání k hodnotě přeteče rozsahu [long].

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

Přetypování výsledku tak, aby [ulong] přinesl nepřesný výsledek, protože operandy byly nejprve přetěžovány na [double] první.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

Definování větší hodnoty jako [ulong] první zabrání problému a vytvoří správný výsledek.

PS> 9223372036854775807ul + 2
9223372036854775809

Avšak překročení rozsahu [ulong] výsledků v [double].

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

Bigint aritmetic

Když provádíte aritmetické operace s [bigint] čísly, PowerShell použije převod všech operandů na , což vede ke [bigint]zkrácení ne celých hodnot. Například [double] hodnota 1.9 je zkrácena na 1 při převodu na [bigint].

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

Toto chování se liší od chování jiných číselných typů. V tomto příkladu se výsledek [int] vydělí [double] výsledkem [double]. Přetypování 1.9 na [int] zaokrouhluje hodnotu nahoru na 2.

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

Přidání a násobení nečíselných typů

Můžete přidat čísla, řetězce, pole a tabulky hash. A můžete násobit čísla, řetězce a pole. Nemůžete ale násobit tabulky hash.

Když přidáte řetězce, pole nebo tabulky hash, prvky se zřetědí. Při zřetězení kolekcí, například polí nebo hash tabulek, se vytvoří nový objekt, který obsahuje objekty z obou kolekcí. Pokud se pokusíte zřetězení tabulek hash se stejným klíčem, operace selže.

Například následující příkazy vytvoří dvě pole a pak je přidají:

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

1
2
3
A
B
C

Můžete také provádět aritmetické operace s objekty různých typů. Operace, kterou Provádí PowerShell, je určena typem Microsoft .NET objektu úplně vlevo v operaci. PowerShell se pokusí převést všechny objekty v operaci na typ .NET prvního objektu. Pokud je převod objektů úspěšný, provede operaci odpovídající typu .NET prvního objektu. Pokud se nepodaří převést některý z objektů, operace selže.

Následující příklady ukazují použití operátorů sčítání a násobení v operacích, které obsahují různé typy objektů.

$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

Vzhledem k tomu, že metoda, která se používá k vyhodnocení příkazů, je určena objektem úplně vlevo, sčítání a násobení v PowerShellu nejsou výhradně commutativní. (a + b) Například se nerovná (b + a)vždy a (ab) vždy se nerovná (ba).

Následující příklady ukazují tento princip:

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

Tabulky hash se mírně liší. Do jiné tabulky hash můžete přidat tabulky hash, pokud přidané hashovací tabulky nemají duplicitní klíče.

Následující příklad ukazuje, jak do sebe přidat hashovací tabulky.

$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

Následující příklad vyvolá chybu, protože jeden z klíčů je duplikován v obou tabulkách hash.

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

Do pole můžete přidat také tabulku hash; a celá tabulka hash se stane položkou v poli.

$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

Do tabulky hash ale nemůžete přidat žádný jiný typ.

$hash1 + 2

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

I když jsou operátory sčítání velmi užitečné, pomocí operátorů přiřazení přidejte prvky do tabulek hash a polí. Další informace najdete v tématu about_assignment_operators. Následující příklady používají += operátor přiřazení k přidání položek do pole:

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

0
1
2

Aritmetické operátory a proměnné

Můžete také použít aritmetické operátory s proměnnými. Operátory fungují na hodnotách proměnných. Následující příklady ukazují použití aritmetických operátorů s proměnnými:

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

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

Aritmetické operátory a příkazy

Obvykle používáte aritmetické operátory ve výrazech s čísly, řetězci a poli. Můžete však také použít aritmetické operátory s objekty, které příkazy vrací a s vlastnostmi těchto objektů.

Následující příklady ukazují, jak používat aritmetické operátory ve výrazech s příkazy PowerShellu:

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

Operátor závorek vynutí vyhodnocení Get-Date rutiny a vyhodnocení výrazu New-TimeSpan -Day 1 rutiny v daném pořadí. Oba výsledky se pak přidají pomocí operátoru + .

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

Ve výše uvedeném výrazu se každý pracovní prostor procesu ($_.ws) vynásobí 2a výsledek ve srovnání 50mb s tím, jestli je větší.

Bitové operátory

PowerShell podporuje standardní bitové operátory, včetně bitových bitových operátorů AND (-band), inkluzivních a exkluzivních bitových operátorů OR (-bora) -bxora bitové ne.-bnot

Počínaje PowerShellem 2.0 pracují všechny bitové operátory s 64bitovými celými čísly.

Počínaje PowerShellem 3.0 -shr se zavádí (shift-right) a -shl (shift-left) pro podporu bitových aritmetik v PowerShellu.

PowerShell podporuje následující bitové operátory.

Operátor	Popis	Výraz	Výsledek
`-band`	Bitový operátor AND	`10 -band 3`	2
`-bor`	Bitový operátor OR (včetně)	`10 -bor 3`	11
`-bxor`	Bitový operátor OR (exkluzivní)	`10 -bxor 3`	9
`-bnot`	Bitové NE	`-bNot 10`	-11
`-shl`	Shift-left	`102 -shl 2`	408
`-shr`	Shift-right	`102 -shr 1`	51

Bitové operátory fungují na binárním formátu hodnoty. Například bitová struktura čísla 10 je 00001010 (na základě 1 bajtu) a bitová struktura čísla 3 je 00000011. Když použijete bitové operátory k porovnání 10 až 3, porovná se jednotlivé bity v jednotlivých bajtech.

V bitové operaci AND je výsledný bit nastaven na 1 pouze v případě, že oba vstupní bity jsou 1.

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

V bitové operaci OR (včetně) je výsledný bit nastaven na 1, pokud je jeden nebo oba vstupní bity 1. Výsledný bit je nastaven na hodnotu 0 pouze v případech, kdy jsou oba vstupní bity nastaveny na 0.

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

V bitové operaci OR (exkluzivní) se výsledný bit nastaví na 1, pouze pokud je 1 vstupní bit.

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

Bitový operátor NOT je unární operátor, který vytváří binární doplněk hodnoty. Hodnota 1 je nastavená na 0 a hodnota 0 je nastavená na hodnotu 1.

Například binární doplněk 0 je -1, maximální celé číslo bez znaménka (0xFFFFFFFF) a binární doplněk -1 je 0.

-bNot 10

-11

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

V bitové operaci posunu doleva se všechny bity přesunou na "n" místa doleva, kde "n" je hodnota pravého operandu. Na jedno místo se vloží nula.

Výraz	Výsledek	Binární výsledek
`21 -shl 0`	21	0001 0101
`21 -shl 1`	42	0010 1010
`21 -shl 2`	84	0101 0100

V bitové operaci posunu doprava se všechny bity přesunou na "n" místa doprava, kde "n" je určen správným operandem. Operátor shift-right (-shr) zkopíruje bit znaménka do levého místa při posunování hodnoty se znaménkem. U nepodepsaných hodnot se do pozice nejvíce vlevo vloží nula.

Výraz	Výsledek	Binární	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