about_Arithmetic_Operators

Artykuł
04/06/2024

Krótki opis

Opisuje operatory, które wykonują operacje arytmetyczne w programie PowerShell.

Długi opis

Operatory arytmetyczne obliczają wartości liczbowe. Można użyć co najmniej jednego operatora arytmetycznego, aby dodać, odjąć, pomnożyć i podzielić wartości oraz obliczyć resztę (modulus) operacji dzielenia.

Operator dodawania (+) i operator mnożenia (*) również działają na ciągach, tablicach i tabelach skrótów. Operator dodawania łączy dane wejściowe. Operator mnożenia zwraca wiele kopii danych wejściowych. Można nawet mieszać typy obiektów w instrukcji arytmetycznej. Metoda używana do oceny instrukcji jest określana przez typ obiektu po lewej stronie w wyrażeniu.

Począwszy od programu PowerShell 2.0, wszystkie operatory arytmetyczne działają na liczbach 64-bitowych.

Począwszy od programu PowerShell 3.0, -shr do obsługi arytmetyki bitowej w programie PowerShell są dodawane (shift-right) i -shl (shift-left). Operatory bitowe działają tylko na typach całkowitych.

Program PowerShell obsługuje następujące operatory arytmetyczne:

Dodawanie (+) — dodaje liczby, łączy ciągi, tablice i tabele skrótów

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}

Odejmowanie (-) — odejmowanie lub negowanie liczb

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

Mnożenie (*) — mnożenie liczb lub kopiowanie ciągów i tablic o określonej liczbie razy

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

Dzielenie (/) — dzieli liczby
```
6 / 2  # result = 3
```
Modulus (%) — zwraca resztę operacji dzielenia.
```
7 % 2  # result = 1
```
Bitowe AND (-band)
```
5 -band 3  # result = 1
```
Bitowa NOT (-bnot)
```
-bnot 5  # result = -6
```
Bitowe OR (-bor)
```
5 -bor 0x03  # result = 7
```
Bitowy XOR (-bxor)
```
5 -bxor 3   # result = 6
```
Przesuwa bity w lewo (-shl)
```
102 -shl 2  # result = 408
```
Przesuwa bity po prawej stronie (-shr)
```
102 -shr 2  # result = 25
```

Kolejność wykonywania działań

Operatory arytmetyczne procesów programu PowerShell w następującej kolejności:

Pierwszeństwo	Operator	opis
1	`()`	Nawiasy
2	`-`	Dla liczby ujemnej lub operatora jednoargumentowego
3	`*`, , `/%`	W przypadku mnożenia i dzielenia
100	`+`, `-`	Dodawanie i odejmowanie
5	`-band`, `-bnot`	W przypadku operacji bitowych
5	`-bor`, `-bxor`	W przypadku operacji bitowych
5	`-shr`, `-shl`	W przypadku operacji bitowych

Program PowerShell przetwarza wyrażenia od lewej do prawej zgodnie z regułami pierwszeństwa. W poniższych przykładach pokazano efekt reguł pierwszeństwa:

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

Kolejność oceniania wyrażeń przez program PowerShell może się różnić od innych używanych języków programowania i skryptów. W poniższym przykładzie przedstawiono skomplikowaną instrukcję przypisania.

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

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

W tym przykładzie wyrażenie $a++ jest obliczane przed $b[$a]. Ocenianie $a++ zmienia wartość $a wartości po jej użyciu w instrukcji $c[$a++], ale przed jej zastosowaniem w pliku $b[$a]. Zmienna w zmiennej $a jest $b[$a] równa 1, a nie 0. W związku z tym instrukcja przypisuje wartość do $b[1], a nie $b[0].

Powyższy kod jest odpowiednikiem:

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

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

Dzielenie i zaokrąglanie

Gdy cudzysłów operacji dzielenia jest liczbą całkowitą, program PowerShell zaokrągla wartość do najbliższej liczby całkowitej. Gdy wartość to .5, zaokrągla ją do najbliższej parzystej liczby całkowitej.

W poniższym przykładzie pokazano efekt zaokrąglania do najbliższej równej liczby całkowitej.

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

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

Możesz użyć [Math] klasy , aby uzyskać różne zachowanie zaokrąglania.

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

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

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

Aby uzyskać więcej informacji, zobacz metodę Math.Round .

Konwersja typu w celu uwzględnienia wyniku

Program PowerShell automatycznie wybiera typ liczbowy platformy .NET, który najlepiej wyraża wynik bez utraty dokładności. Na przykład:

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

5.1
System.Int32
System.Double

Jeśli wynik operacji jest zbyt duży dla typu, typ wyniku jest rozszerzony, aby uwzględnić wynik, jak w poniższym przykładzie:

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

System.Int32
System.Double

Typ wyniku nie zawsze jest taki sam jak jeden z operandów. W poniższym przykładzie wartość ujemna nie może być rzutowana do niepodpisanej liczby całkowitej, a liczba całkowita bez znaku jest zbyt duża, aby rzutować na Int32:

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

System.Int64

W tym przykładzie Int64 można uwzględnić oba typy.

Typ System.Decimal jest wyjątkiem. Jeśli którykolwiek operand ma typ Dziesiętny , wynik jest typem dziesiętny . Każdy wynik zbyt duży dla wartości dziesiętnej jest błędem.

PS> [Decimal]::maxvalue
79228162514264337593543950335

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

Potencjalna utrata dokładności

Za każdym razem, gdy masz wynik, który przekracza zakres typu, ryzykujesz utratę dokładności z powodu konwersji typów. Na przykład dodanie wystarczająco dużego [long] elementu i [int] powoduje przekonwertowanie operandów na [double]. W tym przykładzie 9223372036854775807 jest to maksymalna wartość liczby całkowitej [long] . Dodanie do wartości przepełnia zakres wartości [long].

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

Rzutowanie wyniku w celu [ulong] uzyskania niedokładnego wyniku, ponieważ operandy zostały zmuszane do [double] pierwszego.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

Zdefiniowanie większej wartości jako [ulong] pierwszej pozwala uniknąć problemu i daje prawidłowy wynik.

PS> 9223372036854775807ul + 2
9223372036854775809

Jednak przekroczenie zakresu [ulong] wyników w obiekcie [double].

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

Arytmetyka bigint

Podczas wykonywania operacji arytmetycznych na [bigint] liczbach program PowerShell konwertuje wszystkie operandy na [bigint], co powoduje obcięcie wartości innych niż liczba całkowita. Na przykład [double] wartość jest obcięta na 1 wartość po przekonwertowaniu na [bigint]1.9 .

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

To zachowanie różni się od zachowania innych typów liczbowych. W tym przykładzie element [int] podzielony przez [double] wyniki w obiekcie [double]. Rzutowanie 1.9 do elementu [int] zaokrągla wartość do 2.

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

Dodawanie i mnożenie typów nieliczbowych

Można dodawać liczby, ciągi, tablice i tabele skrótów. Można również pomnożyć liczby, ciągi i tablice. Nie można jednak pomnożyć tabel skrótów.

Podczas dodawania ciągów, tablic lub tabel skrótów elementy są łączone. Podczas łączenia kolekcji, takich jak tablice lub tabele skrótów, tworzony jest nowy obiekt zawierający obiekty z obu kolekcji. Jeśli spróbujesz połączyć tabele skrótów, które mają ten sam klucz, operacja zakończy się niepowodzeniem.

Na przykład następujące polecenia tworzą dwie tablice, a następnie dodaj je:

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

1
2
3
A
B
C

Można również wykonywać operacje arytmetyczne na obiektach różnych typów. Operacja wykonywana przez program PowerShell jest określana przez typ microsoft .NET obiektu najbardziej po lewej stronie operacji. Program PowerShell próbuje przekonwertować wszystkie obiekty w operacji na typ platformy .NET pierwszego obiektu. Jeśli operacja zakończy się powodzeniem podczas konwertowania obiektów, wykonuje operację odpowiednią dla typu .NET pierwszego obiektu. Jeśli nie można przekonwertować żadnego z obiektów, operacja zakończy się niepowodzeniem.

W poniższych przykładach pokazano użycie operatorów dodawania i mnożenia w operacjach obejmujących różne typy obiektów.

$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

Ponieważ metoda używana do oceny instrukcji jest określana przez obiekt najbardziej po lewej stronie, dodawanie i mnożenie w programie PowerShell nie jest ściśle dojeżdżające. Na przykład (a + b) nie zawsze jest równa (b + a), a (ab) nie zawsze jest równa (ba).

W poniższych przykładach przedstawiono tę zasadę:

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

Tabele skrótów są nieco inne. Tabele skrótów można dodawać do innej tabeli skrótów, o ile dodane tabele skrótów nie mają zduplikowanych kluczy.

W poniższym przykładzie pokazano, jak dodać tabele skrótów do siebie.

$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

Poniższy przykład zgłasza błąd, ponieważ jeden z kluczy jest zduplikowany w obu tabelach skrótów.

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

Ponadto można dodać tabelę skrótów do tablicy; i cała tabela skrótów staje się elementem w tablicy.

$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

Nie można jednak dodać żadnego innego typu do tabeli skrótów.

$hash1 + 2

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

Chociaż operatory dodawania są bardzo przydatne, użyj operatorów przypisania, aby dodać elementy do tabel skrótów i tablic. Aby uzyskać więcej informacji, zobacz about_assignment_operators. W poniższych przykładach operator przypisania służy += do dodawania elementów do tablicy:

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

0
1
2

Operatory arytmetyczne i zmienne

Można również użyć operatorów arytmetycznych ze zmiennymi. Operatory działają na wartości zmiennych. W poniższych przykładach pokazano użycie operatorów arytmetycznych ze zmiennymi:

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

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

Operatory arytmetyczne i polecenia

Zazwyczaj operatory arytmetyczne są używane w wyrażeniach z liczbami, ciągami i tablicami. Można jednak również użyć operatorów arytmetycznych z obiektami zwracanymi przez polecenia i właściwościami tych obiektów.

W poniższych przykładach pokazano, jak używać operatorów arytmetycznych w wyrażeniach za pomocą poleceń programu PowerShell:

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

Operator nawiasu wymusza ocenę Get-Date polecenia cmdlet i ocenę New-TimeSpan -Day 1 wyrażenia cmdlet w tej kolejności. Oba wyniki są następnie dodawane przy użyciu + operatora .

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

W powyższym wyrażeniu każda przestrzeń robocza procesu ($_.ws) jest mnożona przez 2wartość ; i, w porównaniu z wartością 50mb , aby sprawdzić, czy jest większa niż.

Operatory bitowe

Program PowerShell obsługuje standardowe operatory bitowe, w tym bitowe AND (-band), operatory inkluzywne i wyłączne bitowe OR (-bor i ) oraz -bxorbitowe NOT (-bnot).

Począwszy od programu PowerShell 2.0, wszystkie operatory bitowe współpracują z 64-bitowymi liczbami całkowitymi.

Począwszy od programu PowerShell 3.0, -shr (shift-right) i -shl (shift-left) są wprowadzane do obsługi arytmetyki bitowej w programie PowerShell.

Program PowerShell obsługuje następujące operatory bitowe.

Operator	opis	Expression	Result
`-band`	Bitowe AND	`10 -band 3`	2
`-bor`	Bitowe OR (włącznie)	`10 -bor 3`	11
`-bxor`	Bitowe OR (wyłączne)	`10 -bxor 3`	9
`-bnot`	Bitowe NOT	`-bNot 10`	-11
`-shl`	Shift-left	`102 -shl 2`	408
`-shr`	Shift-right	`102 -shr 1`	51

Operatory bitowe działają na formacie binarnym wartości. Na przykład struktura bitów liczby 10 jest 00001010 (na podstawie 1 bajtu), a struktura bitowa liczby 3 jest 00000011. Jeśli używasz operatora bitowego do porównania od 10 do 3, poszczególne bity w poszczególnych bajtach są porównywane.

W bitowej operacji AND wynikowy bit jest ustawiony na 1 tylko wtedy, gdy oba bity wejściowe mają wartość 1.

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

W operacji bitowej OR (inkluzywnej) wynikowy bit jest ustawiony na 1, gdy bity wejściowe lub oba mają wartość 1. Wynikowy bit jest ustawiony na 0 tylko wtedy, gdy oba bity wejściowe są ustawione na 0.

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

W bitowej operacji OR (wyłączna) wynikowy bit jest ustawiony na 1 tylko wtedy, gdy jeden bit wejściowy 1.

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

Operator bitowy NOT jest operatorem jednoargumentowym, który generuje binarne uzupełnienie wartości. Bit 1 jest ustawiony na wartość 0, a bit 0 jest ustawiony na 1.

Na przykład binarne uzupełnienie wartości 0 wynosi -1, maksymalna liczba całkowita bez znaku (0xFFFFFFFF), a uzupełnienie binarne -1 to 0.

-bNot 10

-11

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

W operacji bitowej shift-left wszystkie bity są przenoszone "n" miejsca po lewej stronie, gdzie "n" jest wartością prawego operandu. Zero jest wstawione w tym miejscu.

Expression	Result	Wynik binarny
`21 -shl 0`	21	0001 0101
`21 -shl 1`	42	0010 1010
`21 -shl 2`	84	0101 0100

W bitowej operacji shift-right wszystkie bity są przenoszone "n" miejsca po prawej stronie, gdzie "n" jest określony przez prawy operand. Operator shift-right (-shr) kopiuje bit znaku do najbardziej lewego miejsca podczas przesuwania wartości ze znakiem. W przypadku wartości niepodpisanych zero jest wstawione w pozycji najwięcej po lewej stronie.

Expression	Result	Plik binarny	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