Aracılığıyla paylaş


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.

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

Ayrıca bkz.