about_Arithmetic_Operators

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.

Toplama 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, PowerShell'de bit tabanlı aritmetiği desteklemek için -shr (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	Operatör	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, $a++ ifadesi $b[$a]önce değerlendirilir. $a++ değerlendirmek, $adeyiminde kullanıldıktan sonra ancak $c[$a++]kullanılmadan önce $b[$a] değerini değiştirir. $a içindeki $b[$a] değişkeni 1değil 0eşittir. Bu nedenle, deyimi $b[1]değil $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ğer .5olduğunda, 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

Farklı yuvarlama davranışı elde etmek için [Math] sınıfını kullanabilirsiniz.

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 BARıNDıRMAK 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. Mesela:

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ı Int32için atanamayacak kadar büyük:

([int32]::MinValue + [uint32]::MaxValue).GetType().FullName

System.Int64

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

System.Decimal türü bir özel durumdur. İşlenenlerden biri Ondalık türüne sahipse, sonuç Ondalık türü olur. Ondalık değeri için fazla büyük sonuçlar 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 bir [long] ve [int] eklemek işlenenlerin [double]dönüştürülmesiyle sonuçlanır. Bu örnekte, 9223372036854775807 bir [long] tamsayısının en büyük değeridir. değere ekleme, [long]aralığını taştır.

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

sonucun [ulong] ataması yanlış bir sonuç verir çünkü işlenenler önce [double] için zorunlu olarak alındı.

PS> [ulong](9223372036854775807 + 2)
9223372036854775808

Daha büyük değerin [ulong] olarak tanımlanması önce sorundan kaçınarak doğru sonucu verir.

PS> 9223372036854775807ul + 2
9223372036854775809

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

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

Bigint aritmetik

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

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, [int] bölünen bir [double][double]ile sonuçlanmıştır. 1.9 bir [int] ataması, değeri 2kadar yuvarlar.

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 (b + a)eşit değildir ve (ab) her zaman (ba)eşit 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 bir 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, Get-Date cmdlet'in değerlendirilmesini ve New-TimeSpan -Day 1 cmdlet ifadesinin bu sırada değerlendirilmesini 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) 2ile çarpılır; ve sonuç, daha büyük olup olmadığını görmek için 50mb karşı karşılaştırın.

BIT DÜZEYINDE IŞLEÇLER

PowerShell, bit düzeyinde AND (-band), dahil ve özel bit tabanlı OR işleçleri (-bor ve -bxor) ve bit 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, PowerShell'de bit tabanlı aritmetiği desteklemek için -shr (shift-right) ve -shl (shift-left) kullanıma sunulmuştur.

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

Operatör	Açıklama	İfade	Sonuç
`-band`	Bit Düzeyinde VE	`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.

İfade	Sonuç	İ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. 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.

İfade	Sonuç	İkili	Büyü
`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

Ayrıca bakınız

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-09-24