about_Arithmetic_Operators
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 hash6 + 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 angka6 - 2 # result = 4 - -6 # result = 6 (Get-Date).AddDays(-1) # Yesterday's date
Perkalian (
*
) - Mengalikan angka atau menyalin string dan array berapa kali yang ditentukan6 * 2 # result = 12 @("!") * 4 # result = @("!","!","!","!") "!" * 3 # result = "!!!"
Pembagian (
/
) - Membagi angka6 / 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 $b[$a]
, bukan 1
0
. 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 |