about_Arithmetic_Operators

Artikel
04/06/2024

Deskripsi singkat

Menjelaskan operator yang melakukan aritmetika di PowerShell.

Deskripsi panjang

Operator aritmatika menghitung nilai numerik. Anda dapat menggunakan satu atau beberapa operator aritmatika untuk menambahkan, mengurangi, mengalikan, dan membagi nilai, dan untuk menghitung sisa (modulus) operasi pembagian.

Operator penambahan (+) dan operator perkalian (*) juga beroperasi pada string, array, dan hashtable. Operator penambahan menggabungkan input. Operator perkalian mengembalikan beberapa salinan input. Anda bahkan dapat mencampur jenis objek dalam pernyataan aritmatika. Metode yang digunakan untuk mengevaluasi pernyataan ditentukan oleh jenis objek paling kiri dalam ekspresi.

Dimulai di PowerShell 2.0, semua operator aritmatika bekerja pada angka 64-bit.

Dimulai di PowerShell 3.0, -shr (shift-right) dan -shl (shift-left) ditambahkan untuk mendukung aritmatika bitwise di PowerShell. Operator bitwise hanya bekerja pada jenis bilangan bulat.

PowerShell mendukung operator aritmatika berikut:

Penambahan (+) - Menambahkan angka, menggabungkan string, array, dan tabel hash

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}

Pengurangan (-) - Mengurangi atau meniadakan angka

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

Perkalian (*) - Mengalikan angka atau menyalin string dan array berapa kali yang ditentukan

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

Pembagian (/) - Membagi angka
```
6 / 2  # result = 3
```
Modulus (%) - mengembalikan sisa operasi pembagian.
```
7 % 2  # result = 1
```
Bitwise DAN (-band)
```
5 -band 3  # result = 1
```
Bitwise NOT (-bnot)
```
-bnot 5  # result = -6
```
Bitwise ATAU (-bor)
```
5 -bor 0x03  # result = 7
```
Bitwise XOR (-bxor)
```
5 -bxor 3   # result = 6
```
Menggeser bit ke kiri (-shl)
```
102 -shl 2  # result = 408
```
Menggeser bit ke kanan (-shr)
```
102 -shr 2  # result = 25
```

Prioritas operator

PowerShell memproses operator aritmatika dalam urutan berikut:

Prioritas	Operator	Deskripsi
1	`()`	Tanda Kurung
2	`-`	Untuk angka negatif atau operator unary
3	`*`, , `/%`	Untuk perkalian dan pembagian
4	`+`, `-`	Untuk penambahan dan pengurangan
5	`-band`, `-bnot`	Untuk operasi bitwise
5	`-bor`, `-bxor`	Untuk operasi bitwise
5	`-shr`, `-shl`	Untuk operasi bitwise

PowerShell memproses ekspresi dari kiri ke kanan sesuai dengan aturan prioritas. Contoh berikut menunjukkan efek aturan prioritas:

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

Urutan di mana PowerShell mengevaluasi ekspresi mungkin berbeda dari bahasa pemrograman dan skrip lain yang telah Anda gunakan. Contoh berikut menunjukkan pernyataan penugasan yang rumit.

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

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

Dalam contoh ini, ekspresi $a++ dievaluasi sebelum $b[$a]. Mengevaluasi $a++ perubahan nilai $a setelah digunakan dalam pernyataan $c[$a++], tetapi sebelum digunakan di $b[$a]. Variabel $a dalam sama dengan 1, bukan 0$b[$a] . Oleh karena itu, pernyataan menetapkan nilai ke $b[1], bukan $b[0].

Kode di atas setara dengan:

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

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

Pembagian dan pembulatan

Saat kuota operasi pembagian adalah bilangan bulat, PowerShell membulatkan nilai ke bilangan bulat terdekat. Ketika nilainya adalah .5, nilai dibulatkan ke bilangan bulat genap terdekat.

Contoh berikut menunjukkan efek pembulatan ke bilangan bulat genap terdekat.

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

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

Anda dapat menggunakan [Math] kelas untuk mendapatkan perilaku pembulatan yang berbeda.

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

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

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

Untuk informasi selengkapnya, lihat metode Math.Round .

Konversi jenis untuk mengakomodasi hasil

PowerShell secara otomatis memilih jenis numerik .NET yang paling baik mengekspresikan hasilnya tanpa kehilangan presisi. Contohnya:

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

5.1
System.Int32
System.Double

Jika hasil operasi terlalu besar untuk jenisnya, jenis hasilnya diperlebar untuk mengakomodasi hasilnya, seperti dalam contoh berikut:

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

System.Int32
System.Double

Jenis hasilnya tidak selalu sama dengan salah satu operand. Dalam contoh berikut, nilai negatif tidak dapat ditransmisikan ke bilangan bulat yang tidak ditandatangani, dan bilangan bulat yang tidak ditandatangani terlalu besar untuk ditransmisikan ke Int32:

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

System.Int64

Dalam contoh ini, Int64 dapat mengakomodasi kedua jenis.

Jenisnya System.Decimal adalah pengecualian. Jika salah satu operan memiliki jenis Desimal , hasilnya adalah Jenis desimal . Hasil apa pun yang terlalu besar untuk nilai Desimal adalah kesalahan.

PS> [Decimal]::maxvalue
79228162514264337593543950335

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

Potensi hilangnya presisi

Setiap kali Anda memiliki hasil yang melebihi rentang jenis, Anda berisiko kehilangan presisi karena konversi jenis. Misalnya, menambahkan cukup besar [long] dan [int] menghasilkan operan yang dikonversi ke [double]. Dalam contoh ini, 9223372036854775807 adalah nilai maksimum bilangan [long] bulat. Menambahkan ke nilai meluap ke rentang [long].

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

Mentransmisikan hasil untuk [ulong] menghasilkan hasil yang tidak akurat, karena operan dipaksa untuk [double] terlebih dahulu.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

Menentukan nilai yang lebih besar karena [ulong] pertama-tama menghindari masalah dan menghasilkan hasil yang benar.

PS> 9223372036854775807ul + 2
9223372036854775809

Namun, melebihi rentang [ulong] hasil dalam .[double]

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

Aritmatika bigint

Saat Anda melakukan operasi aritmatika pada [bigint] angka, PowerShell menggunakan mengonversi semua operand ke [bigint], yang menghasilkan pemotongan nilai non-bilangan bulat. Misalnya, [double] nilai 1.9 dipotong menjadi 1 ketika dikonversi ke [bigint].

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

Perilaku ini berbeda dari perilaku jenis numerik lainnya. Dalam contoh ini, [int] dibagi dengan hasil [double] dalam .[double] Transmisi 1.9 ke membulatkan [int] nilai hingga 2.

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

Menambahkan dan mengalikan jenis non numerik

Anda dapat menambahkan angka, string, array, dan tabel hash. Dan, Anda dapat mengalikan angka, string, dan array. Namun, Anda tidak dapat mengalikan tabel hash.

Saat Anda menambahkan string, array, atau tabel hash, elemen digabungkan. Saat Anda menggabungkan koleksi, seperti array atau tabel hash, objek baru dibuat yang berisi objek dari kedua koleksi. Jika Anda mencoba menggabungkan tabel hash yang memiliki kunci yang sama, operasi gagal.

Misalnya, perintah berikut membuat dua array lalu menambahkannya:

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

1
2
3
A
B
C

Anda juga dapat melakukan operasi aritmatika pada objek dari berbagai jenis. Operasi yang dilakukan PowerShell ditentukan oleh jenis Microsoft .NET dari objek paling kiri dalam operasi. PowerShell mencoba mengonversi semua objek dalam operasi ke jenis .NET dari objek pertama. Jika berhasil mengonversi objek, objek akan melakukan operasi yang sesuai dengan jenis .NET objek pertama. Jika gagal mengonversi salah satu objek, operasi gagal.

Contoh berikut menunjukkan penggunaan operator penambahan dan perkalian dalam operasi yang mencakup berbagai jenis objek.

$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

Karena metode yang digunakan untuk mengevaluasi pernyataan ditentukan oleh objek paling kiri, penambahan dan perkalian di PowerShell tidak benar-benar komuttif. Misalnya, (a + b) tidak selalu sama dengan (b + a), dan (ab) tidak selalu sama dengan (ba).

Contoh berikut menunjukkan prinsip ini:

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

Tabel hash adalah kasus yang sedikit berbeda. Anda dapat menambahkan tabel hash ke tabel hash lain, selama tabel hash yang ditambahkan tidak memiliki kunci duplikat.

Contoh berikut menunjukkan cara menambahkan tabel hash satu sama lain.

$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

Contoh berikut melemparkan kesalahan karena salah satu kunci diduplikasi dalam kedua tabel 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'

Selain itu, Anda dapat menambahkan tabel hash ke array; dan, seluruh tabel hash menjadi item dalam array.

$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

Namun, Anda tidak dapat menambahkan jenis lain ke tabel hash.

$hash1 + 2

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

Meskipun operator penambahan sangat berguna, gunakan operator penugasan untuk menambahkan elemen ke tabel hash dan array. Untuk informasi selengkapnya, lihat about_assignment_operators. Contoh berikut menggunakan += operator penugasan untuk menambahkan item ke array:

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

0
1
2

Operator dan variabel aritmatika

Anda juga dapat menggunakan operator aritmatika dengan variabel. Operator bertindak berdasarkan nilai variabel. Contoh berikut menunjukkan penggunaan operator aritmatika dengan variabel:

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

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

Operator dan perintah aritmatika

Biasanya, Anda menggunakan operator aritmatika dalam ekspresi dengan angka, string, dan array. Namun, Anda juga dapat menggunakan operator aritmatika dengan objek yang dikembalikan perintah dan dengan properti objek tersebut.

Contoh berikut menunjukkan cara menggunakan operator aritmetika dalam ekspresi dengan perintah PowerShell:

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

Operator tanda kurung memaksa evaluasi Get-Date cmdlet dan evaluasi ekspresi cmdlet, dalam urutan tersebut New-TimeSpan -Day 1 . Kedua hasil kemudian ditambahkan menggunakan + operator.

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

Dalam ekspresi di atas, setiap ruang kerja proses ($_.ws) dikalikan dengan 2; dan, hasilnya, dibandingkan 50mb dengan untuk melihat apakah lebih besar dari itu.

Operator bitwise

PowerShell mendukung operator bitwise standar, termasuk bitwise-AND (-band), operator bitwise-OR inklusif dan eksklusif (-bor dan -bxor), dan bitwise-NOT (-bnot).

Dimulai di PowerShell 2.0, semua operator bitwise bekerja dengan bilangan bulat 64-bit.

Dimulai di PowerShell 3.0, -shr (shift-right) dan -shl (shift-left) diperkenalkan untuk mendukung aritmatika bitwise di PowerShell.

PowerShell mendukung operator bitwise berikut.

Operator	Deskripsi	Ekspresi	Hasil
`-band`	Bitwise AND	`10 -band 3`	2
`-bor`	Bitwise OR (inklusif)	`10 -bor 3`	11
`-bxor`	Bitwise OR (eksklusif)	`10 -bxor 3`	9
`-bnot`	Bitwise NOT	`-bNot 10`	-11
`-shl`	Shift-kiri	`102 -shl 2`	408
`-shr`	Shift-right	`102 -shr 1`	51

Operator bitwise bertindak pada format biner dari sebuah nilai. Misalnya, struktur bit untuk angka 10 00001010 (berdasarkan 1 byte), dan struktur bit untuk angka 3 00000011. Saat Anda menggunakan operator bitwise untuk membandingkan 10 hingga 3, bit individual di setiap byte dibandingkan.

Dalam operasi BITWISE AND, bit yang dihasilkan diatur ke 1 hanya ketika kedua bit input adalah 1.

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

Dalam operasi bitwise OR (inklusif), bit yang dihasilkan diatur ke 1 ketika salah satu atau kedua bit input adalah 1. Bit yang dihasilkan diatur ke 0 hanya ketika kedua bit input diatur ke 0.

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

Dalam operasi bitwise OR (eksklusif), bit yang dihasilkan diatur ke 1 hanya ketika satu bit input 1.

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

Operator BITWISE NOT adalah operator unary yang menghasilkan pelengkap biner dari nilai . Sedikit 1 diatur ke 0 dan sedikit 0 diatur ke 1.

Misalnya, pelengkap biner 0 adalah -1, bilangan bulat maksimum yang tidak ditandatangani (0xFFFFFFFF), dan pelengkap biner -1 adalah 0.

-bNot 10

-11

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

Dalam operasi shift-left bitwise, semua bit dipindahkan "n" tempat ke kiri, di mana "n" adalah nilai operand kanan. Nol disisipkan di tempat yang ada.

Ekspresi	Hasil	Hasil Biner
`21 -shl 0`	21	0001 0101
`21 -shl 1`	42	0010 1010
`21 -shl 2`	84	0101 0100

Dalam operasi shift-right bitwise, semua bit dipindahkan "n" tempat ke kanan, di mana "n" ditentukan oleh operand kanan. Operator shift-right (-shr) menyalin bit tanda ke tempat paling kiri saat menggeser nilai yang ditandatangani. Untuk nilai yang tidak ditandatangani, nol disisipkan di posisi paling kiri.

Ekspresi	Hasil	Biner	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