about_Arithmetic_Operators

Artykuł
06/21/2023

Krótki opis

Opisuje operatory, które wykonują 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.

Ponadto operator dodawania (+) i operator mnożenia (*) również działa 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).

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

Operator	Opis	Przykład
+	Dodaje liczby całkowite; Łączy	`6 + 2`
	ciągi, tablice i tabele skrótów.	`"file" + "name"`
		`@(1, "one") + @(2.0, "two")`
		`@{"one" = 1} + @{"two" = 2}`
+	Tworzy liczbę poza obiektem	+ 123
-	Odejmuje jedną wartość z innej	`6 - 2`
	wartość
-	Oblicza przeciwną liczbę	`- -6`
		`(Get-Date).AddDays(-1)`
*	Mnożenie liczb lub kopiowanie ciągów	`6 * 2`
	i tablice o określonej liczbie	`@("!") * 4`
	razy.	`"!" * 3`
/	Dzieli dwie wartości.	`6 / 2`
%	Modulus - zwraca resztę	`7 % 2`
	operacja dzielenia.
-Zespół	Bitowe ORAZ	`5 -band 3`
-bnot	Bitowe NOT	`-bnot 5`
-Bor	Bitowe OR	`5 -bor 0x03`
-bxor	Bitowy XOR	`5 -bxor 3`
-Shl	Przesuwa bity po lewej stronie	`102 -shl 2`
-Shr	Przesuwa bity po prawej stronie	`102 -shr 2`

Operatory bitowe działają tylko na typach całkowitych.

Pierwszeństwo operatorów

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
4	`+`, `-`	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 przedstawiono efekt reguł pierwszeństwa:

Wyrażenie	Wynik
`3+6/3*4`	`11`
`3+6/(3*4)`	`3.5`
`(3+6)/3*4`	`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 oceniane przed $b[$a]. Ocenianie $a++ zmienia wartość $a wartości po jej użyciu w instrukcji $c[$a++], ale przed jej zastosowaniem w $b[$a]pliku . Zmienna $a w $b[$a] zmiennej jest równa 1, a nie 0; więc 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 iloraz 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 równej liczby całkowitej.

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

Wyrażenie	Wynik
`[int]( 5 / 2 )`	`2`
`[int]( 7 / 2 )`	`4`

Zwróć uwagę, jak wartość 5/2 = 2,5 jest zaokrąglona do 2. Ale 7/2 = 3,5 zostaje zaokrąglone do 4.

Za pomocą [Math] klasy można uzyskać różne zachowanie zaokrąglania.

Wyrażenie	Wynik
`[int][Math]::Round(5 / 2,[MidpointRounding]::AwayFromZero)`	`3`
`[int][Math]::Ceiling(5 / 2)`	`3`
`[int][Math]::Floor(5 / 2)`	`2`

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

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 platformy Microsoft .NET obiektu po lewej stronie w operacji. Program PowerShell próbuje przekonwertować wszystkie obiekty w operacji na typ .NET pierwszego obiektu. Jeśli konwersja obiektów zakończy się pomyślnie, 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 przedstawiono użycie operatorów dodawania i mnożenia; w operacjach zawierających różne typy obiektów. Załóżmy$array = 1,2,3, , , $red = [ConsoleColor]::Red$blue = [ConsoleColor]::Blue:

Wyrażenie	Wynik
`"file" + 16`	`file16`
`$array + 16`	`1`,`2`,`3`,`16`
`$array + "file"`	`1`,`2`,`3`,`file`
`$array * 2`	`1`,`2`,`3`,`1`,`2`,`3`
`"file" * 3`	`filefilefile`
`$blue + 3`	`Red`
`$red - 3`	`Blue`
`$blue - $red`	`-3`
`+ '123'`	`123`

Ponieważ metoda używana do oceny instrukcji jest określana przez najbardziej lewy obiekt, 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 równa (ba).

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

Wyrażenie	Wynik
`"file" + 16`	`file16`
`16 + "file"`	`Cannot convert value "file" to type "System.Int32".`
	`Error: "Input string was not in a correct format."`
	`At line:1 char:1`
	`+ 16 + "file"`

Tabele skrótów są nieco inne. Tabele skrótów można dodać 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 nawzajem.

$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

Item has already been added. Key in dictionary: 'c'  Key being added: 'c'
At line:3 char:1
+ $hash1 + $hash2
+ ~~~~~~~~~~~~~~~
    + CategoryInfo          : OperationStopped: (:) [], ArgumentException
    + FullyQualifiedErrorId : System.ArgumentException

Ponadto można dodać tabelę skrótów do tablicy; a 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

A hash table can only be added to another hash table.
At line:3 char:1
+ $hash1 + 2

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 użyto += operatora przypisania, aby dodać elementy do tablicy:

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

0
1
2

Konwersja typu w celu dostosowania 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 musi być taki sam jak jeden z operandów. W poniższym przykładzie nie można rzutować wartości ujemnej na niepodpisaną liczbę całkowitą, a liczba całkowita bez znaku jest zbyt duża, aby rzutować do Int32elementu :

([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óryś z operandów ma typ dziesiętny , wynik będzie typu dziesiętnego. Jeśli wynik jest zbyt duży dla typu dziesiętnego , nie będzie rzutowy na wartość Podwójna. Zamiast tego wynik błędu.

Wyrażenie	Wynik
`[Decimal]::maxvalue`	`79228162514264337593543950335`
`[Decimal]::maxvalue + 1`	`Value was either too large or too small for a`
	`Decimal.`

Operatory i zmienne arytmetyczne

Można również używać 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:

Wyrażenie	Wynik
`$intA = 6` `$intB = 4` `$intA + $intB`	`10`
`$a = "Power"` `$b = "Shell"` `$a + $b`	`PowerShell`

Operatory i polecenia arytmetyczne

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 i z 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 wynik, w porównaniu z wartością 50mb , aby sprawdzić, czy jest on większy niż.

Operatory bitowe

Program PowerShell obsługuje standardowe operatory bitowe, w tym bitowe AND (), inkluzywne i wyłączne operatory bitowe OR (-bAnd-bOr i -bXor) oraz bitowe NOT (-bNot).

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

Począwszy od programu PowerShell 3.0, -shr wprowadzono (shift-right) i -shl (shift-left) obsługę arytmetyki bitowej w programie PowerShell.

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

Operator	Opis	Wyrażenie	Wynik
`-band`	Bitowe ORAZ	`10 -band 3`	2
`-bor`	Bitowe OR (włącznie)	`10 -bor 3`	11
`-bxor`	Bitowe OR (wykluczające)	`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 bitowa 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 są 1.

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

W bitowej operacji OR (włącznie) wynikowy bit jest ustawiony na 1, gdy bity wejściowe lub oba są 1. Wynikowy bit jest ustawiony na wartość 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łączność) wynikowy bit jest ustawiony na wartość 1 tylko wtedy, gdy jeden bit wejściowy to 1.

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

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

Na przykład binarne uzupełnienie wartości 0 to -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, xfffffff5)

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

Gdy lewy operand jest wartością Całkowita (32-bitowa), dolne 5 bitów prawego operandu określają liczbę bitów lewego operandu.

Gdy lewy operand jest wartością Long (64-bitową), dolne 6 bitów prawego operandu określają, ile bitów lewego operandu jest przesunięty.

Wyrażenie	Wynik	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) wstawia zero w lewym miejscu, gdy przesuwa wartość dodatnią lub niepodpisaną po prawej stronie.