about_Assignment_Operators

  • Makale

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.

Sözdizimi

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, bir değer dizisi veya bir komut, ifade veya deyim olabilir.

Artım ve azaltma işleçleri birli işleçlerdir. Her birinin ön ek ve sonek sürümleri vardır.

  • <assignable-expression><operator>
  • <operator><assignable-expression>

Atanabilir ifadenin değeri 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 PowerShell değerini değişkenine $MyShell 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ğerini 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. 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 bir önceliğe sahip olduğundan, bir komut işlem hattının sonucunu bir değişkene atamak için parantez 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 bir 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 sıfırdan $a küçükse değişkenine $b 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 virgülle aşağıdaki gibi 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 ayraç { }içine alınmış anahtar/değer çiftlerinin ; ardından bir at işareti @ 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 (bu örnekte 16) dönüştürür ve bu değeri değişkene $a atar. Örneğin, değişkene 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, megabayt KBve 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şken $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

Ekleme işlecine göre atama

Ekleme işlecine += göre atama bir değişkenin değerini artırır veya belirtilen değeri var olan 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ç mevcut değeri işlecin sağ tarafındaki tutara göre artırır. Ardından işleç, sonuçta elde edilen değeri değişkene 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 dizeye aşağıdaki gibi 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 açıkça türleme tarafından 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 tabloya ekler. Ancak, karma tabloya 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 tablo 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

Ayrıca, atama işlecini kullanarak -= sayısal bir dizinin üyesinin değerini azaltabilirsiniz. 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 atamak $null için Clear-Item veya Clear-Variable cmdlet'lerini kullanın.""

$a = $null

Diziden belirli bir değeri silmek için dizi gösterimini kullanarak belirli öğeye değerini $null atayı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 bir 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. İlk olarak, ç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. Ardından işleç, %= değişkenine geri 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ış 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şkeni ve işleci aşağıdaki gibi 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 ve $c$a değişkenleri farklı değerlere sahiptir çünkü değer değişikliklerden önce $a atanmıştır$c:

$a = 7
$c = $a++
$a

8

$c

7

Azaltma işleci -- bir değişkenin değerini 1 azaltır. Artım işlecinde olduğu gibi, basit bir deyimde işlecini kullandığınızda hiçbir değer döndürülmüyor. Aşağıdaki gibi bir değer döndürmek için parantezleri kullanın:

$a = 7
--$a
$a

6

(--$a)

5

İşlecin ön ek sürümü, deyiminde değeri kullanılmadan önce değişkeni aşağıdaki gibi azaldırıyor:

$a = 7
$c = --$a
$a

6

$c

6

işlecinin sonek sürümü, deyiminde değeri kullanıldıktan sonra bir değişkeni geri dönüştürür. Aşağıdaki örnekte ve $d$a değişkenleri farklı değerlere sahiptir çünkü değer değişikliklerden önce $a atanmıştır$d:

$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 soldaki 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şkenin yalnızca bir değeri olduğunda değişkenin veri türünü değişkene atanan değer belirler. Ö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 Onun FullName özelliğini kullanın. Yöntem çağrısının bağımsız değişkeni 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şkene 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 gönderir. 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 dönüştürür. 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 oluşturabilirsiniz. Bir değişken 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 yayınlar:

$a = [string]27

Değeri yeni veri türüne dönüştürülemiyorsa mevcut değişkenin 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

Ayrıca, bir değişken adından önce bir veri türü girdiğinizde, 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ü bir dizi değişkenine özel olarak atanmadığı sürece, veri türü her zaman System.Object []olur. 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şkeni 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ü belirtir:

[System.DateTime]$a = "5/31/2005"

Değişkene 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ş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

Ayrıca bkz.