about_Arithmetic_Operators

Makale
04/06/2024

Kısa açıklama

PowerShell'de aritmetik gerçekleştiren işleçleri açıklar.

Uzun açıklama

Aritmetik işleçler sayısal değerleri hesaplar. Değerleri eklemek, çıkarmak, çarpmak ve bölme işleminin kalan kısmını (modül) hesaplamak için bir veya daha fazla aritmetik işleç kullanabilirsiniz.

Ekleme işleci (+) ve çarpma işleci (*) dizeler, diziler ve karma tablolarda da çalışır. Toplama işleci girişi birleştirir. Çarpma işleci girişin birden çok kopyasını döndürür. Bir aritmetik deyimde nesne türlerini bile karıştırabilirsiniz. deyimini değerlendirmek için kullanılan yöntem, ifadedeki en soldaki nesnenin türüne göre belirlenir.

PowerShell 2.0'da başlayarak, tüm aritmetik işleçler 64 bit sayılar üzerinde çalışır.

PowerShell 3.0'dan başlayarak, -shr PowerShell'de bit düzeyinde aritmetiği desteklemek için (shift-right) ve -shl (shift-left) eklenir. Bit düzeyinde işleçler yalnızca tamsayı türlerinde çalışır.

PowerShell aşağıdaki aritmetik işleçleri destekler:

Toplama (+) - Sayı ekler, dizeleri, dizileri ve karma tabloları birleştirir

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}

Çıkarma (-) - Sayıları çıkarır veya çıkarır

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

Çarpma (*) - Sayıları çarpma veya dizeleri ve dizileri belirtilen sayıda kopyalama

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

Bölme (/) - Sayıları böler
```
6 / 2  # result = 3
```
Modulus (%) - bölme işleminin geri kalanını döndürür.
```
7 % 2  # result = 1
```
Bit Düzeyinde AND (-band)
```
5 -band 3  # result = 1
```
Bit Düzeyinde DEĞİl (-bnot)
```
-bnot 5  # result = -6
```
Bit Düzeyinde OR (-bor)
```
5 -bor 0x03  # result = 7
```
Bit Düzeyinde XOR (-bxor)
```
5 -bxor 3   # result = 6
```
Bitleri sola kaydırıyor (-shl)
```
102 -shl 2  # result = 408
```
Bitleri sağa kaydırıyor (-shr)
```
102 -shr 2  # result = 25
```

İşleç önceliği

PowerShell aritmetik işleçleri aşağıdaki sırayla işler:

Öncelik	Operator	Açıklama
1	`()`	Parantez
2	`-`	Negatif bir sayı veya birli işleç için
3	`*`, `/`, `%`	Çarpma ve bölme için
4	`+`, `-`	Toplama ve çıkarma için
5	`-band`, `-bnot`	Bit düzeyinde işlemler için
5	`-bor`, `-bxor`	Bit düzeyinde işlemler için
5	`-shr`, `-shl`	Bit düzeyinde işlemler için

PowerShell, ifadeleri soldan sağa öncelik kurallarına göre işler. Aşağıdaki örneklerde öncelik kurallarının etkisi gösterilmektedir:

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

PowerShell'in ifadeleri değerlendirme sırası, kullandığınız diğer programlama ve betik dillerinden farklı olabilir. Aşağıdaki örnekte karmaşık bir atama deyimi gösterilmektedir.

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

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

Bu örnekte, ifade $a++ öncesinde $b[$a]değerlendirilir. $a++ Değerlendirme, deyiminde $c[$a++]kullanıldıktan sonra ancak içinde $b[$a]kullanılmadan önce değerini $a değiştirir. içindeki $b[$a]1değişkeni $a eşittir, değil0. Bu nedenle, deyimi yerine öğesine $b[1]$b[0]bir değer atar.

Yukarıdaki kod aşağıdakilerle eşdeğerdir:

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

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

Bölme ve yuvarlama

Bölme işleminin bölümü bir tamsayı olduğunda, PowerShell değeri en yakın tamsayıya yuvarlar. değeri olduğunda .5, en yakın çift tamsayıya yuvarlar.

Aşağıdaki örnek, en yakın çift tamsayıya yuvarlamanın etkisini gösterir.

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

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

Sınıfını [Math] kullanarak farklı yuvarlama davranışı elde edebilirsiniz.

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

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

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

Daha fazla bilgi için math.round yöntemine bakın.

Sonucu karşılamak için tür dönüştürme

PowerShell, duyarlığı kaybetmeden sonucu en iyi ifade eden .NET sayısal türünü otomatik olarak seçer. Örneğin:

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

5.1
System.Int32
System.Double

Bir işlemin sonucu tür için çok büyükse, aşağıdaki örnekte olduğu gibi sonucun türü sonucu barındıracak şekilde genişletilir:

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

System.Int32
System.Double

Sonucun türü her zaman işlenenlerden biriyle aynı değildir. Aşağıdaki örnekte, negatif değer işaretsiz bir tamsayıya dönüştürülemez ve işaretsiz tamsayı için atanamayacak Int32kadar büyük:

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

System.Int64

Bu örnekte, Int64 her iki türü de barındırabilir.

Türü System.Decimal bir özel durumdur. İki işlenenden biri Ondalık türüne sahipse, sonuç Ondalık türü olur. Ondalık değeri için fazla büyük olan herhangi bir sonuç hatadır.

PS> [Decimal]::maxvalue
79228162514264337593543950335

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

Olası duyarlık kaybı

Tür aralığını aşan bir sonuç elde ettiğiniz her durumda, tür dönüştürme nedeniyle duyarlık kaybetme riskiyle karşı karşıyasınız. Örneğin, yeterince büyük [long] bir eklendiğinde işlenenlerin [int] dönüştürülmesiyle [double]sonuçlanır. Bu örnekte, 9223372036854775807 bir [long] tamsayının en büyük değeridir. değere ekleme, aralığının taşmasına neden olacak [long].

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

sonucun türetilmesi [ulong] , işlenenler önceye zorlamalı olduğundan yanlış bir sonuç verir [double] .

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

Büyük değerin ilk olarak tanımlanması [ulong] , sorundan kaçınarak doğru sonucu verir.

PS> 9223372036854775807ul + 2
9223372036854775809

Ancak, bir [double]içindeki sonuç aralığını [ulong] aşmak.

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

Bigint aritmetik

Sayılar üzerinde [bigint] aritmetik işlemler gerçekleştirdiğinizde PowerShell, tüm işlenenleri [bigint]değerine dönüştürür ve bu da tamsayı olmayan değerlerin kesilmesine neden olur. Örneğin, [double] değerine dönüştürüldüğünde [bigint]değeri 1.9 olarak kesilir1.

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

Bu davranış, diğer sayısal türlerin davranışından farklıdır. Bu örnekte, bir ile bölünmüş [double] bir [int] sonuç olarak elde edilir[double]. Bir değerine atama1.9, değeri değerine yuvarlar2.[int]

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

Sayısal olmayan türleri ekleme ve çarpma

Sayı, dize, dizi ve karma tablo ekleyebilirsiniz. Ayrıca sayıları, dizeleri ve dizileri çarpabilirsiniz. Ancak karma tabloları çarpamazsınız.

Dizeler, diziler veya karma tablolar eklediğinizde, öğeler birleştirilir. Diziler veya karma tablolar gibi koleksiyonları birleştirirken, her iki koleksiyondaki nesneleri içeren yeni bir nesne oluşturulur. Aynı anahtara sahip karma tabloları birleştirmeye çalışırsanız işlem başarısız olur.

Örneğin, aşağıdaki komutlar iki dizi oluşturur ve bunları ekler:

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

1
2
3
A
B
C

Ayrıca, farklı türlerdeki nesneler üzerinde aritmetik işlemler de gerçekleştirebilirsiniz. PowerShell'in gerçekleştirdiği işlem, işlemdeki en soldaki nesnenin Microsoft .NET türü tarafından belirlenir. PowerShell, işlemdeki tüm nesneleri ilk nesnenin .NET türüne dönüştürmeye çalışır. Nesneleri dönüştürmede başarılı olursa, ilk nesnenin .NET türüne uygun işlemi gerçekleştirir. Nesnelerden herhangi birini dönüştüremezse işlem başarısız olur.

Aşağıdaki örneklerde, farklı nesne türleri içeren işlemlerde toplama ve çarpma işleçlerinin kullanımı gösterilmektedir.

$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

Deyimleri değerlendirmek için kullanılan yöntem en soldaki nesne tarafından belirlendiğinden, PowerShell'de toplama ve çarpma tam olarak değişmez. Örneğin, (a + b) her zaman eşit (b + a)değildir ve (ab) her zaman eşit (ba)değildir.

Aşağıdaki örneklerde bu ilke gösterilmektedir:

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

Karma tablolar biraz farklıdır. Eklenen karma tablolarda yinelenen anahtarlar olmadığı sürece başka bir karma tabloya karma tablolar ekleyebilirsiniz.

Aşağıdaki örnekte karma tabloların birbirine nasıl ekleneceği gösterilmektedir.

$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

Anahtarlardan biri her iki karma tabloda da çoğaltıldığı için aşağıdaki örnek bir hata oluşturur.

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

Ayrıca, bir diziye karma tablo ekleyebilirsiniz; ve karma tablosunun tamamı dizideki bir öğeye dönüşür.

$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

Ancak, karma tabloya başka bir tür ekleyemezsiniz.

$hash1 + 2

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

Ekleme işleçleri çok yararlı olsa da, karma tablolara ve dizilere öğe eklemek için atama işleçlerini kullanın. Daha fazla bilgi için bkz. about_assignment_operators. Aşağıdaki örneklerde, diziye öğe eklemek için atama işleci kullanılır += :

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

0
1
2

Aritmetik işleçler ve değişkenler

Değişkenlerle aritmetik işleçler de kullanabilirsiniz. İşleçler değişkenlerin değerlerine göre hareket eder. Aşağıdaki örneklerde değişkenlerle aritmetik işleçlerin kullanımı gösterilmektedir:

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

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

Aritmetik işleçler ve komutlar

Genellikle sayı, dize ve dizi içeren ifadelerde aritmetik işleçleri kullanırsınız. Ancak, komutların döndüreceği nesnelerle ve bu nesnelerin özellikleriyle aritmetik işleçler de kullanabilirsiniz.

Aşağıdaki örneklerde, PowerShell komutları ile ifadelerde aritmetik işleçlerin nasıl kullanılacağı gösterilmektedir:

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

Parantez işleci, cmdlet'in değerlendirilmesini Get-Date ve cmdlet ifadesinin değerlendirilmesini New-TimeSpan -Day 1 bu sırada zorlar. Ardından her iki sonuç da işleci kullanılarak + eklenir.

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

Yukarıdaki ifadede, her işlem çalışma alanı ($_.ws) ile 2çarpılır ve sonuç, bundan büyük olup olmadığını görmek için karşılaştırılır 50mb .

Bit düzeyinde işleçler

PowerShell, bit düzeyinde AND (-band ), dahil ve özel bit tabanlı OR işleçleri (-bor ve ) ve -bxorbit düzeyinde DEĞİl (-bnot) dahil olmak üzere standart bit düzeyinde işleçleri destekler.

PowerShell 2.0'da başlayarak, tüm bit düzeyinde işleçler 64 bit tamsayılarla çalışır.

PowerShell 3.0'dan başlayarak , -shr (shift-right) ve -shl (shift-left) PowerShell'de bit tabanlı aritmetiği desteklemek için kullanıma sunulmuştur.

PowerShell aşağıdaki bit düzeyinde işleçleri destekler.

Operator	Açıklama	Expression	Result
`-band`	Bit düzeyinde AND	`10 -band 3`	2
`-bor`	Bit Düzeyinde OR (dahil)	`10 -bor 3`	11
`-bxor`	Bit Düzeyinde OR (özel)	`10 -bxor 3`	9
`-bnot`	Bit Düzeyinde DEĞİl	`-bNot 10`	-11
`-shl`	Shift-left	`102 -shl 2`	408
`-shr`	Sağa kaydırma	`102 -shr 1`	51

Bit düzeyinde işleçler bir değerin ikili biçimine göre hareket eder. Örneğin, 10 sayısının bit yapısı 00001010 (1 bayt temelinde) ve 3 sayısının bit yapısı 00000011. Bit düzeyinde işleç kullanarak 10 ile 3 karşılaştırması yaptığınızda, her bayttaki tek tek bitler karşılaştırılır.

Bit düzeyinde AND işleminde, sonuçta elde edilen bit yalnızca her iki giriş biti de 1 olduğunda 1 olarak ayarlanır.

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

Bit düzeyinde VEYA (dahil) bir işlemde, sonuçta elde edilen bit 1 olarak ayarlanır ve giriş bitlerinden biri veya her ikisi de 1 olur. Sonuçta elde edilen bit yalnızca her iki giriş biti de 0 olarak ayarlandığında 0 olarak ayarlanır.

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

Bit düzeyinde VEYA (özel) bir işlemde, sonuçta elde edilen bit yalnızca bir giriş biti 1 olduğunda 1 olarak ayarlanır.

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

Bit düzeyinde NOT işleci, değerin ikili tamamlayıcısını üreten birli işleçtir. 1 biti 0, 0 biti ise 1 olarak ayarlanır.

Örneğin, 0 ikili tamamlayıcısı -1, en fazla işaretsiz tamsayı (0xFFFFFFFF) ve -1 ikili tamamlayıcısı 0'dır.

-bNot 10

-11

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

Bit düzeyinde sola kaydırma işleminde, tüm bitler "n" yerler sola taşınır; burada "n" sağ işlenenin değeridir. Bir yere sıfır eklenir.

Expression	Result	İkili Sonuç
`21 -shl 0`	21	0001 0101
`21 -shl 1`	42	0010 1010
`21 -shl 2`	84	0101 0100

Bit düzeyinde sağa kaydırma işleminde, tüm bitler "n" yerler sağa taşınır ve burada "n" doğru işlenen tarafından belirtilir. Sağ shift-right işleci (-shr), imzalı bir değeri kaydırırken işaret bitini en soldaki yere kopyalar. İmzasız değerler için en soldaki konuma sıfır eklenir.

Expression	Result	İkilik	Onaltılık
`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