atama_Operatörleri_hakkında

Makale
2025-01-20

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 ayrıca aşağıdaki bileşik atama işleçlerine sahiptir: +=, -=, *=, %=, ++, --, ??=. 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şkenler halinde 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 $MyShell değişkenine 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 $a değişkenini oluşturur ve $aiçin 6 değerini atar. İkinci atama ifadesi, $a'a 12 değ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. Değişken bir nesne koleksiyonu içerdiğinde, değişkenin System.Object veri türü vardır. 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, 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 $a değişkenine 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 örnek, $a değeri sıfırdan küçükse $b değişkenine sıfır atar. $b'nin değeri sıfırdan küçük değilse, $a'ın değeri $b'e atanır.

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 çiftleri { } işaretine bir yazın. Örneğin, $a değişkenine bir karma tablo atamak için şunu yazın:

$a = @{one=1; two=2; three=3}

Bir değişkene onaltılık değerler atamak için değerin öncesine 0xekleyin. PowerShell onaltılık değeri (0x10) ondalık değere (bu örnekte 16) dönüştürür ve bu değeri $a değişkenine atar. Örneğin, $a değişkenine 0x10 değeri atamak için şunu yazın:

$a = 0x10

Bir değişkene üstel değer atamak için kök numarasını, eharfini ve 10'un katını temsil eden bir sayı yazın. Örneğin, 3,1415 değerini 1.000'in gücüne $a değişkenine atamak için şunu yazın:

$a = 3.1415e3

PowerShell ayrıca kilobaytları KB, megabayt MBve gigabayt GB baytlara da dönüştürebilir. Örneğin, $a değişkenine 10 kilobaytlık bir değer atamak için ş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 $x değişkeni genel kapsamda tanımlanmıştır. Ayraçlar yeni bir kapsam oluşturur. Küme ayraçlarının içinde $x değişkeni, genel değişkenin bir kopyası değil yeni bir örnektir.

$x = 1 # Global scope
& { $x += 1; $x }

Normal atama işlecini kullandığınızda, üst kapsamdan değişkenin bir kopyasını alırsınız. Üst kapsamdaki $x'ın değiştirilmediğine dikkat edin.

$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 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 ilave eder 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şleci 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ş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

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şkeninin değeri bir dizi olduğunda, += işleci işlecinin 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

$a += "String"
$a

1
2
3
2
String

Değişkenin değeri karma tablo olduğunda, += işleci, 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 $a değişkenine 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, $a değişkenindeki karma tabloya "1" tamsayısını 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 atama operatörü -=, bir değişkenin değerini, işlecin sağ tarafında belirtilen değer kadar azaltı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. Önce çıkarır, sonra atanar. 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

Sayısal bir dizinin üyesinin değerini azaltmak için -= atama işlecini 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 Clear-Item veya Clear-Variable cmdlet'lerini kullanarak değişkeni $null veya "" olarak ayarlayın.

$a = $null

Diziden belirli bir değeri silmek için dizi gösterimini kullanarak belirli bir öğeye $null değeri 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 $a değişkenini siler:

Remove-Variable -Name a

Çarpma işlecine göre atama

Çarpma işlecine göre atama *= bir 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

Bu durumda, *= işleci iki işlemi birleştirir. İlk olarak çarpar ve sonra atama yapar. 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 atama operatörü /=, sayısal bir değeri operatörün sağ tarafında belirtilmiş olan değere böler. işleci dize değişkenleriyle kullanılamaz.

/= işleci iki işlemi birleştirir. Önce böler, 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

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

mod 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şleci 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 örnek, bir bölüm modülünü korumak için %= operatörünün nasıl kullanılacağını göstermektedir.

$a = 7
$a %= 4
$a

Artış ve azaltma işleçleri

artım 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

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)

Arttırma operatörü bir değişkenin önüne (ön ek) veya arkasına (sonek) yerleştirilebilir. işlecin ön ek sürümü, aşağıdaki gibi bir değişkenin değeri ifadesinde kullanılmadan önce onu artırır:

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

$c

İşlecin sonek sürümü, bir deyimdeki değeri kullanıldıktan sonra bir değişkenin değerini arttırır. Aşağıdaki örnekte, $c ve $a değişkenleri farklı değerlere sahiptir çünkü değer $c değişmeden önce $a atanır:

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

$c

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

(--$a)

Operatörün ön ek versiyonu, değişkenin değeri kullanılmadan önce onu aşağıdaki gibi azaltır:

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

$c

Operatörün sonek sürümü, deyimde değeri kullanıldıktan sonra bir değişkeni azaltır. Aşağıdaki örnekte, $d ve $a değişkenleri farklı değerlere sahiptir çünkü değer $d değişmeden önce $a atanır:

$a = 7
$d = $a--
$a

$d

Null hesaplı birleştirici 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. ??= işleci, soldaki operand null olmayan olarak değerlendirildiğinde sağdaki operandı değerlendirmez.

$x = $null
$x ??= 100
$x

Daha fazla bilgi için bkz, Null birleştirici operatör.

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 FullName özelliğini kullanın. GetType yöntem adından sonra, yöntem çağrısında bağımsız değişken olmasa bile 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

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şkenini herhangi bir .NET türü olarak dönüştürebilirsiniz. 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

Aşağıdaki örnek, değişkeni dönüştürmek yerine ilk değeri dönüştürür.

$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 []. 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 mevcut olan tam nitelikli herhangi bir .NET veri türünü atayabilirsiniz. Örneğin, aşağıdaki komut bir System.DateTime veri türünü belirtir:

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

değişkenine System.DateTime veri türüne uygun bir değer atanır. $a değişkeninin 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 atamaolarak bilinir.

Örneğin, aşağıdaki komut 1 değerini $a değişkenine, 2 değerini $b değişkenine ve 3 değerini $c değişkenine 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, 1 değerini $a değişkenine, 2 değerini de $b değişkenine atar. 3, 4 ve 5 değerlerini $c değişkenine atar. $c değişkenindeki değerleri diğer üç değişkene atamak için aşağıdaki biçimi kullanın:

$d, $e, $f = $c

Bu komut 3 değerini $d değişkenine, 4 değerini $e değişkenine ve 5 değerini $f değişkenine atar.

Atama değeri değişkenlerden daha az öğe içeriyorsa, kalan değişkenlere $nulldeğeri atanır. Örneğin, aşağıdaki komut üç değişken ve iki değer içerir:

$a, $b, $c = 1, 2

Bu nedenle PowerShell, 1 değerini $a değişkenine, 2 değerini de $b değişkenine atar. $c değişkeni $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 Set-Variable kullanarak $a değişkenine 1, 2, 3 dizisini atar.

Set-Variable -Name a -Value 1, 2, 3

Aracılığıyla paylaş