about_Assignment_Operators
Kısa açıklama
Değişkenlere değer atamak için işleçlerin nasıl kullanılacağını açıklar.
Uzun açıklama
Atama işleçleri bir değişkene bir veya daha fazla değer atar. Eşittir işareti (=), PowerShell atama işlecidir. PowerShell'de aşağıdaki bileşik atama işleçleri de vardır: +=, -=, *=, %=, ++, --, . ??=
Bileşik atama işleçleri, atamadan önceki değerler üzerinde işlemler gerçekleştirir.
Syntax
Atama işleçlerinin söz dizimi aşağıdaki gibidir:
<assignable-expression> <assignment-operator> <value>
Atanabilir ifadeler değişkenleri ve özellikleri içerir. Değer tek bir değer, değer dizisi veya komut, ifade veya deyim olabilir.
Artırma ve azaltma işleçleri birli işleçlerdir. Her biri ön ek ve sonek sürümlerine sahiptir.
<assignable-expression><operator>
<operator><assignable-expression>
Atanabilir ifade bir sayı olmalı veya sayıya dönüştürülebilir olmalıdır.
Atama işlecini kullanma
Değişkenler, değerleri depolayan bellek alanları olarak adlandırılır. Atama işlecini =kullanarak değerleri değişkenlerde depolarsınız. Yeni değer değişkenin mevcut değerinin yerini alabilir veya var olan değere yeni bir değer ekleyebilirsiniz. Örneğin, aşağıdaki deyim değişkenine PowerShell $MyShell değerini atar:
$MyShell = "PowerShell"
PowerShell'de bir değişkene değer atadığınızda, değişken henüz yoksa oluşturulur. Örneğin, aşağıdaki iki atama deyiminden ilki değişkenini $a oluşturur ve öğesine $a6 değeri atar. İkinci atama deyimine 12 $adeğeri atar. İlk deyim yeni bir değişken oluşturur. İkinci deyim yalnızca değerini değiştirir:
$a = 6
$a = 12
PowerShell'deki değişkenler, siz atamadığınız sürece belirli bir veri türüne sahip değildir. Bir değişken yalnızca bir nesne içerdiğinde, değişken bu nesnenin veri türünü alır. Bir değişken bir nesne koleksiyonu içerdiğinde, değişken System.Object veri türüne sahiptir. Bu nedenle, koleksiyona herhangi bir nesne türü atayabilirsiniz. Aşağıdaki örnekte hata oluşturmadan bir değişkene işlem nesneleri, hizmet nesneleri, dizeler ve tamsayılar ekleyebileceğiniz gösterilmektedir:
$a = Get-Process
$a += Get-Service
$a += "string"
$a += 12
Atama işleci işlem hattı işlecinden =|daha düşük önceliğe sahip olduğundan, bir komut işlem hattının sonucunu bir değişkene atamak için parantezler gerekmez. Örneğin, aşağıdaki komut bilgisayardaki hizmetleri sıralar ve ardından sıralanmış hizmetleri değişkenine $a atar:
$a = Get-Service | Sort-Object -Property name
Aşağıdaki örnekte olduğu gibi, deyimi tarafından oluşturulan değeri bir değişkene de atayabilirsiniz:
$a = if ($b -lt 0) { 0 } else { $b }
Bu örnekte değeri $b sıfırdan $a küçükse değişkenine sıfır atanır. değeri $b$a sıfırdan küçük değilse değerini $b atar.
Bir değişkene dizi (birden çok değer) atamak için, değerleri aşağıdaki gibi virgülle ayırın:
$a = "apple", "orange", "lemon", "grape"
Bir değişkene karma tablo atamak için PowerShell'de standart karma tablo gösterimini kullanın. Noktalı virgülle ayrılmış ve küme ayraçları ; içine alınmış bir at işareti @ ve ardından anahtar/değer çiftleri { }yazın. Örneğin, değişkene bir karma tablo atamak için $a şunu yazın:
$a = @{one=1; two=2; three=3}
Bir değişkene onaltılık değerler atamak için değerinin önüne ile geçin 0x.
PowerShell onaltılık değeri (0x10) ondalık değere dönüştürür (bu örnekte 16) ve bu değeri değişkene $a atar. Örneğin, değişkenine 0x10 değeri atamak için $a şunu yazın:
$a = 0x10
Bir değişkene üstel değer atamak için kök numarasını, harfini eve 10'un katını temsil eden bir sayı yazın. Örneğin, değişkene 1.000'in gücüne 3,1415 değeri atamak için $a şunu yazın:
$a = 3.1415e3
PowerShell kilobayt KB, megabayt ve gigabaytları MBda baytlara GB dönüştürebilir. Örneğin, değişkene 10 kilobaytlık bir değer atamak için $a şunu yazın:
$a = 10kb
Bileşik atama işleçlerini kullanma
Bileşik atama işleçleri, atamadan önceki değerler üzerinde sayısal işlemler gerçekleştirir.
Önemli
Bileşik atama işleçleri dinamik kapsam belirleme kullanmaz. Değişken her zaman geçerli kapsamdadır.
Aşağıdaki örnekte değişkeni $x genel kapsamda tanımlanmıştır. Ayraçlar yeni bir kapsam oluşturur. Küme ayraçlarının içindeki değişken $x , genel değişkenin bir kopyası değil yeni bir örnektir.
$x = 1 # Global scope
& { $x += 1; $x }
1
Normal atama işlecini kullandığınızda, üst kapsamdan değişkenin bir kopyasını alırsınız. Ancak üst kapsamda değiştirilmediğine dikkat edin $x .
$x = 1 # Global scope
& { $x = $x + 1; $x }
"Global `$x = $x"
2
Global $x = 1
Toplama işlecine göre atama
Ekleme işleci += tarafından atama, bir değişkenin değerini artırır veya belirtilen değeri mevcut değere ekler. Eylem, değişkenin sayısal veya dize türüne sahip olup olmadığına ve değişkenin tek bir değer (skaler) veya birden çok değer (koleksiyon) içermesine bağlıdır.
+= işleci iki işlemi birleştirir. İlk olarak ekler ve sonra atar.
Bu nedenle, aşağıdaki deyimler eşdeğerdir:
$a += 2
$a = ($a + 2)
Değişken tek bir sayısal değer içerdiğinde += , işleç var olan değeri işlecin sağ tarafındaki miktara göre artırır. Ardından işleç, sonuçta elde edilen değeri değişkenine atar. Aşağıdaki örnekte, bir değişkenin += değerini artırmak için işlecinin nasıl kullanılacağı gösterilmektedir:
$a = 4
$a += 2
$a
6
değişkeninin değeri bir dize olduğunda, işlecin sağ tarafındaki değer aşağıdaki gibi dizeye eklenir:
$a = "Windows"
$a += " PowerShell"
$a
Windows PowerShell
Değişkenin değeri bir dizi olduğunda işleç, += işlecin sağ tarafındaki değerleri diziye ekler. Dizi tür değiştirme tarafından açıkça yazılmadığı sürece, diziye aşağıdaki gibi herhangi bir değer türü ekleyebilirsiniz:
$a = 1,2,3
$a += 2
$a
1
2
3
2
ve
$a += "String"
$a
1
2
3
2
String
Değişkenin değeri karma tablo olduğunda işleç, += işlecin sağ tarafındaki değeri karma tablosuna ekler. Ancak, karma tablosuna ekleyebileceğiniz tek tür başka bir karma tablo olduğundan, diğer tüm atamalar başarısız olur.
Örneğin, aşağıdaki komut değişkene $a bir karma tablosu atar.
Ardından işlecini += kullanarak var olan karma tabloya başka bir karma tablo ekler ve mevcut karma tabloya etkili bir şekilde yeni bir anahtar/değer çifti ekler.
Çıktıda gösterildiği gibi bu komut başarılı olur:
$a = @{a = 1; b = 2; c = 3}
$a += @{mode = "write"}
$a
Name Value
---- -----
a 1
b 2
mode write
c 3
Aşağıdaki komut, değişkendeki karma tabloya "1" tamsayısını $a eklemeyi dener. Bu komut başarısız oluyor:
$a = @{a = 1; b = 2; c = 3}
$a += 1
InvalidOperation:
Line |
2 | $a += 1
| ~~~~~~~
| A hash table can only be added to another hash table.
Çıkarma işlecine göre atama
Çıkarma işlecine -= göre atama, bir değişkenin değerini işlecin sağ tarafında belirtilen değere göre ayırır. Bu işleç dize değişkenleriyle kullanılamaz ve bir öğeyi koleksiyondan kaldırmak için kullanılamaz.
-= işleci iki işlemi birleştirir. İlk olarak çıkarır ve sonra atar. Bu nedenle, aşağıdaki deyimler eşdeğerdir:
$a -= 2
$a = ($a - 2)
Aşağıdaki örnekte, bir değişkenin -= değerini azaltmak için işlecinin nasıl kullanılacağı gösterilmektedir:
$a = 8
$a -= 2
$a
6
Atama işlecini -= , sayısal bir dizinin üyesinin değerini azaltmak için de kullanabilirsiniz. Bunu yapmak için, değiştirmek istediğiniz dizi öğesinin dizinini belirtin. Aşağıdaki örnekte, bir dizinin üçüncü öğesinin (öğe 2) değeri 1 azaltılır:
$a = 1,2,3
$a[2] -= 1
$a
1
2
2
Bir değişkenin -= değerlerini silmek için işlecini kullanamazsınız. Bir değişkene atanan tüm değerleri silmek için, değişkene veya "" değerini $null atamak için Clear-Item veya Clear-Variable cmdlet'lerini kullanın.
$a = $null
Diziden belirli bir değeri silmek için, belirli bir öğeye değerini $null atamak için dizi gösterimini kullanın. Örneğin, aşağıdaki deyim bir diziden ikinci değeri (dizin konumu 1) siler:
$a = 1,2,3
$a
1
2
3
$a[1] = $null
$a
1
3
Bir değişkeni silmek için Remove-Variable cmdlet'ini kullanın. Bu yöntem, değişken belirli bir veri türüne açıkça yayınlandığında ve yazılmamış bir değişken istediğinizde kullanışlıdır. Aşağıdaki komut değişkeni siler $a :
Remove-Variable -Name a
Çarpma işlecine göre atama
Çarpma işlecine *= göre atama, sayısal değeri çarpar veya bir değişkenin dize değerinin belirtilen sayıda kopyasını ekler.
Bir değişken tek bir sayısal değer içerdiğinde, bu değer işlecin sağ tarafındaki değerle çarpılır. Örneğin, aşağıdaki örnekte bir değişkenin *= değerini çarpmak için işlecinin nasıl kullanılacağı gösterilmektedir:
$a = 3
$a *= 4
$a
12
Bu durumda işleç iki *= işlemi birleştirir. önce çarpar ve sonra atar. Bu nedenle, aşağıdaki deyimler eşdeğerdir:
$a *= 2
$a = ($a * 2)
Bir değişken bir dize değeri içerdiğinde, PowerShell belirtilen sayıda dizeyi aşağıdaki gibi değere ekler:
$a = "file"
$a *= 4
$a
filefilefilefile
Dizinin bir öğesini çarpmak için, çarpmak istediğiniz öğeyi tanımlamak için bir dizin kullanın. Örneğin, aşağıdaki komut dizideki ilk öğeyi (dizin konumu 0) 2 ile çarpar:
$a[0] *= 2
Bölme işlecine göre atama
Bölme işlecine /= göre atama, sayısal bir değeri işlecin sağ tarafında belirtilen değere böler. işleci dize değişkenleriyle kullanılamaz.
/= işleci iki işlemi birleştirir. İlk olarak bölünür ve sonra atar. Bu nedenle, aşağıdaki iki deyim eşdeğerdir:
$a /= 2
$a = ($a / 2)
Örneğin, aşağıdaki komut bir değişkenin /= değerini bölmek için işlecini kullanır:
$a = 8
$a /=2
$a
4
Dizinin bir öğesini bölmek için, değiştirmek istediğiniz öğeyi tanımlamak için bir dizin kullanın. Örneğin, aşağıdaki komut dizideki ikinci öğeyi (dizin konumu 1) 2'ye böler:
$a[1] /= 2
modulus işlecine göre atama
modulus işlecine %= göre atama, değişkenin değerini işlecin sağ tarafındaki değere böler. Daha sonra işleç, %= değişkenine kalanı (modül olarak bilinir) atar. Bu işleci yalnızca bir değişken tek bir sayısal değer içerdiğinde kullanabilirsiniz. Bir değişken dize değişkeni veya dizi içerdiğinde bu işleci kullanamazsınız.
%= işleci iki işlemi birleştirir. İlk olarak, kalanı böler ve belirler ve ardından kalanı değişkenine atar. Bu nedenle, aşağıdaki deyimler eşdeğerdir:
$a %= 2
$a = ($a % 2)
Aşağıdaki örnekte, bir bölüm modülünü %= kaydetmek için işlecinin nasıl kullanılacağı gösterilmektedir:
$a = 7
$a %= 4
$a
3
Artırma ve azaltma işleçleri
Increment işleci ++ bir değişkenin değerini 1 artırır. Basit bir deyimde increment işlecini kullandığınızda hiçbir değer döndürülmüyor. Sonucu görüntülemek için değişkenin değerini aşağıdaki gibi görüntüleyin:
$a = 7
++$a
$a
8
Bir değeri döndürülmeye zorlamak için değişkenini ve işlecini parantez içine alın:
$a = 7
(++$a)
8
Artım işleci bir değişkenden önce (ön ek) veya sonra (sonek) yerleştirilebilir. işlecin ön ek sürümü, deyiminde değeri kullanılmadan önce aşağıdaki gibi bir değişkeni artırır:
$a = 7
$c = ++$a
$a
8
$c
8
işlecin sonek sürümü, deyiminde değeri kullanıldıktan sonra bir değişkeni artırır. Aşağıdaki örnekte, $c değer değişikliklerden önce $a atandığından ve $a değişkenleri farklı değerlere $c sahiptir:
$a = 7
$c = $a++
$a
8
$c
7
Azaltma işleci -- bir değişkenin değerini 1 azaltır. Increment işlecinde olduğu gibi, işlecini basit bir deyimde kullandığınızda hiçbir değer döndürülmüyor. Aşağıdaki gibi bir değer döndürmek için parantez kullanın:
$a = 7
--$a
$a
6
(--$a)
5
İşlecin ön ek sürümü, deyiminde değeri kullanılmadan önce bir değişkeni aşağıdaki gibi azaltmayı sağlar:
$a = 7
$c = --$a
$a
6
$c
6
işlecinin sonek sürümü, deyiminde değeri kullanıldıktan sonra bir değişkenin azalmasını sağlar. Aşağıdaki örnekte, $d değer değişikliklerden önce $a atandığından ve $a değişkenleri farklı değerlere $d sahiptir:
$a = 7
$d = $a--
$a
6
$d
7
Null birleşim atama işleci
Null birleşim atama işleci ??= , sağ işleneninin değerini yalnızca sol işlenen null olarak değerlendirilirse sol işlenenine atar. ??= Sol işlenen null olmayan olarak değerlendirilirse işleç sağ işlenenini değerlendirmez.
$x = $null
$x ??= 100
$x
100
Daha fazla bilgi için bkz. Null birleşim işleci.
Microsoft .NET türleri
Varsayılan olarak, bir değişkende yalnızca bir değer olduğunda değişkenin veri türü değişkene atanan değer tarafından belirlenir. Örneğin, aşağıdaki komut System.Int32 türüne sahip bir değişken oluşturur:
$a = 6
Bir değişkenin .NET türünü bulmak için GetType yöntemini ve FullName özelliğini kullanın. Yöntem çağrısında bağımsız değişken olmasa bile GetType yöntemi adından sonra parantezleri eklediğinizden emin olun:
$a = 6
$a.GetType().FullName
System.Int32
Dize içeren bir değişken oluşturmak için değişkenine bir dize değeri atayın. Değerin bir dize olduğunu belirtmek için, aşağıdaki gibi tırnak içine alın:
$a = "6"
$a.GetType().FullName
System.String
Değişkene atanan ilk değer bir dizeyse, PowerShell tüm işlemleri dize işlemleri olarak değerlendirir ve dizelere yeni değerler atar. Bu, aşağıdaki örnekte oluşur:
$a = "file"
$a += 3
$a
file3
İlk değer bir tamsayıysa, PowerShell tüm işlemleri tamsayı işlemleri olarak değerlendirir ve yeni değerleri tamsayılara atar. Bu, aşağıdaki örnekte oluşur:
$a = 6
$a += "3"
$a
9
Tür adını değişken adından veya ilk atama değerinden önceki köşeli ayraçlara yerleştirerek yeni bir skaler değişkeni herhangi bir .NET türü olarak dönüştürebilirsiniz. Bir değişkeni yayınladığınızda, değişkende depolanabilecek veri türünü tanımlarsınız.
Örneğin, aşağıdaki komut değişkenini dize türü olarak yayınlar:
[string]$a = 27
$a += 3
$a
273
Aşağıdaki örnek, değişkenini değiştirmek yerine ilk değeri atar:
$a = [string]27
Mevcut bir değişkenin değeri yeni veri türüne dönüştürülemiyorsa, veri türünü yeniden yayınlayamazsınız.
$a = "string"
[int]$a
InvalidArgument: Cannot convert value "string" to type "System.Int32". Error:
"The input string 'string' was not in a correct format."
Veri türünü değiştirmek için değerini aşağıdaki gibi değiştirmeniz gerekir:
[int]$a = 3
Buna ek olarak, bir değişken adından önce bir veri türü kullandığınızda, türü başka bir veri türü belirterek açıkça geçersiz kılmadığınız sürece bu değişkenin türü kilitlenir. Mevcut türle uyumlu olmayan bir değer atamaya çalışırsanız ve türü açıkça geçersiz kılmazsanız, PowerShell aşağıdaki örnekte gösterildiği gibi bir hata görüntüler:
$a = 3
$a = "string"
[int]$a = 3
$a = "string"
MetadataError:
Line |
2 | $a = "string"
| ~~~~~~~~~~~~~
| Cannot convert value "string" to type "System.Int32". Error: "The input
string 'string' was not in a correct format."
[string]$a = "string"
PowerShell'de, bir dizide birden çok öğe içeren değişkenlerin veri türleri, tek bir öğe içeren değişkenlerin veri türlerinden farklı işlenir. Bir veri türü özellikle bir dizi değişkenine atanmadığı sürece, veri türü her zaman System.Object []şeklindedir. Bu veri türü dizilere özgüdür.
Bazen, başka bir tür belirterek varsayılan türü geçersiz kılabilirsiniz. Örneğin, aşağıdaki komut değişkenini bir string [] dizi türü olarak yayınlar:
[string []] $a = "one", "two", "three"
PowerShell değişkenleri herhangi bir .NET veri türü olabilir. Ayrıca, geçerli işlemde kullanılabilen tüm tam .NET veri türlerini atayabilirsiniz. Örneğin, aşağıdaki komut bir System.DateTime veri türünü belirtir:
[System.DateTime]$a = "5/31/2005"
değişkenine veri türüne System.DateTime uygun bir değer atanır. değişkeninin $a değeri aşağıdaki gibi olabilir:
Tuesday, May 31, 2005 12:00:00 AM
Birden çok değişken atama
PowerShell'de, tek bir komut kullanarak birden çok değişkene değer atayabilirsiniz. Atama değerinin ilk öğesi ilk değişkene, ikinci öğe ikinci değişkene, üçüncü öğe üçüncü değişkene atanır. Bu, birden çok atama olarak bilinir.
Örneğin, aşağıdaki komut değişkene 1 değerini, değişkene $a 2 değerini ve değişkene $b 3 $c değerini atar:
$a, $b, $c = 1, 2, 3
Atama değeri değişkenlerden daha fazla öğe içeriyorsa, kalan tüm değerler son değişkene atanır. Örneğin, aşağıdaki komut üç değişken ve beş değer içerir:
$a, $b, $c = 1, 2, 3, 4, 5
Bu nedenle, PowerShell değişkene 1 değerini ve değişkene $a 2 $b değerini atar. Değişkene 3, 4 ve 5 $c değerlerini atar.
Değişkendeki $c değerleri diğer üç değişkene atamak için aşağıdaki biçimi kullanın:
$d, $e, $f = $c
Bu komut değişkene 3 değerini, değişkene $d 4 değerini ve değişkene $e 5 $f değerini atar.
Atama değeri değişkenlerden daha az öğe içeriyorsa, kalan değişkenlere değeri $nullatanır. Örneğin, aşağıdaki komut üç değişken ve iki değer içerir:
$a, $b, $c = 1, 2
Bu nedenle, PowerShell değişkene 1 değerini ve değişkene $a 2 $b değerini atar. $c değişkenidir$null.
Değişkenleri zincirleyerek birden çok değişkene tek bir değer de atayabilirsiniz. Örneğin, aşağıdaki komut dört değişkenin tümüne "üç" değerini atar:
$a = $b = $c = $d = "three"
Değişkenle ilgili cmdlet'ler
Değişken değeri ayarlamak için atama işlemi kullanmanın yanı sıra , Set-Variable cmdlet'ini de kullanabilirsiniz. Örneğin, aşağıdaki komut değişkene 1, 2, 3 dizisini atamak için $a kullanırSet-Variable.
Set-Variable -Name a -Value 1, 2, 3