about_Arithmetic_Operators
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ów6 + 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 liczb6 - 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 razy6 * 2 # result = 12 @("!") * 4 # result = @("!","!","!","!") "!" * 3 # result = "!!!"
Dzielenie (
/
) — dzieli liczby6 / 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.9
wartość po przekonwertowaniu na 1
[bigint]
.
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 2
wartość ; 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 -bxor
bitowe 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 |