about_Hash_Tables

Kısa açıklama

PowerShell'de karma tablo oluşturma, kullanma ve sıralamayı açıklar.

Uzun açıklama

Sözlük veya ilişkilendirilebilir dizi olarak da bilinen karma tablo, bir veya daha fazla anahtar-değer çiftini depolayan kompakt bir veri yapısıdır. Örneğin, bir karma tablo bir dizi IP adresi ve bilgisayar adı içerebilir; burada IP adresleri anahtarlardır ve bilgisayar adları değerlerdir (veya tam tersi).

PowerShell'de her karma tablo bir [System.Collections.Hashtable] nesnesidir. PowerShell'de Hashtable nesnelerinin özelliklerini ve yöntemlerini kullanabilirsiniz.

PowerShell 3.0'da başlayarak [ordered] tür hızlandırıcısını kullanarak PowerShell'de [System.Collections.Specialized.OrderedDictionary] nesnesi oluşturabilirsiniz.

Sıralı sözlükler, anahtarların her zaman sizin belirlediğiniz sıraya göre görünmesi bakımından karma tablolardan farklıdır. Karma tablodaki anahtarların sırası belirleyici değildir.

Karma tablolardaki anahtarlar ve değer de .NET nesneleridir. Bunlar genellikle dizeler veya tamsayılardır, ancak herhangi bir nesne türüne sahip olabilirler. Ayrıca, bir anahtarın değerinin başka bir karma tablo olduğu iç içe hashtable'lar da oluşturabilirsiniz.

Hashtable'lar, verileri bulmak ve almak için verimli olduklarından sıklıkla kullanılır. Karma tablolarını kullanarak listeleri depolayabilir ve PowerShell'de hesaplanmış özellikler oluşturabilirsiniz. ConvertFrom-StringData cmdlet, yapılandırılmış dize verilerini bir karma tabloya dönüştürür.

Sözdizimi

Karma tablo söz dizimi aşağıdaki gibidir:

@{ <name> = <value>; [<name> = <value> ] ...}

Sıralı sözlüğün söz dizimi aşağıdaki gibidir:

[ordered]@{ <name> = <value>; [<name> = <value> ] ...}

[ordered] tür hızlandırıcısı PowerShell 3.0'da kullanıma sunulmuştur.

Karma tablo oluşturmak için şu yönergeleri izleyin:

Karma tabloya at işaretiyle (@) başlayın.
Hashtable'ı ayraç içine alın ({}).
Karma tablo içeriği için bir veya daha fazla anahtar-değer çifti girin.
Her bir anahtarı değerinden ayırmak için eşittir işareti (=) kullanın.
Anahtar-değer çiftlerini ayırmak için noktalı virgül (;) veya satır sonu kullanın.
Boşluk içeren anahtarlar tırnak içine alınmalıdır. Değerler geçerli PowerShell ifadeleri olmalıdır. Dizeler boşluk içermese bile tırnak içinde görünmelidir.
Hashtable'ı yönetmek için bir değişkene kaydedin.
Bir değişkene sıralı karma tablo atarken, [ordered] türünü @ simgesinin önüne yerleştirin. Değişken adından önce yerleştirirseniz, komut başarısız olur.

Sıralı sözlükleri karma tablolarla aynı şekilde kullanabilirsiniz. Her iki tür de karma tablo veya sözlük (iDictionary) tür nesnelerini alan parametrelerin değeri olarak kullanılabilir.

Hashtable ve sıralı sözlük oluşturma

Aşağıdaki karma tablo ve sıralı sözlük örneklerini göz önünde bulundurun:

$hash = @{
    1       = 'one'
    2       = 'two'
    'three' = 3
}
$hash

Name                           Value
----                           -----
three                          3
2                              two
1                              one

Gördüğünüz gibi, bir karma tabloda anahtar-değer çiftleri tanımlandıkları sırayla sunulmaz.

Sıralı sözlük oluşturmanın en kolay yolu [ordered] özniteliğini kullanmaktır. özniteliğini @ simgesinin hemen önüne yerleştirin.

$dictionary = [ordered]@{
    1       = 'one'
    2       = 'two'
    'three' = 3
}
$dictionary

Name                           Value
----                           -----
1                              one
2                              two
three                          3

Karma tablolardan farklı olarak, sıralı sözlükler anahtar-değerin sırasını korur.

Hash tablosunu ve düzenlenmiş sözlükleri dönüştürme

Hash tablosunu dönüştürmek veya atamak için [ordered] türü hızlandırıcısını kullanamazsınız. Sıralı özniteliği değişken adından önce yerleştirirseniz, komut aşağıdaki hata iletisiyle başarısız olur.

[ordered]$orderedHash = @{}
ParserError:
Line |
   1 |  [ordered]$orderedHash = @{}
     |  ~~~~~~~~~~~~~~
     | The ordered attribute can be specified only on a hash literal node.

İfadeyi düzeltmek için [ordered] özniteliğinin yerini değiştirin.

$orderedHash = [ordered]@{}

Sıralı bir sözlüğü bir karma tabloya dönüştürebilirsiniz, ancak üyelerin sırasını garanti edemezsiniz.

[hashtable]$newHash = [ordered]@{
    Number = 1
    Shape = "Square"
    Color = "Blue"
}
$newHash

Name                           Value
----                           -----
Color                          Blue
Shape                          Square
Number                         1

Hashtable ve sözlük özellikleri

Karma tablo ve sıralı sözlükler çeşitli özellikleri paylaşır. Önceki örneklerde tanımlanan $hash ve $dictionary değişkenlerini göz önünde bulundurun.

$hash | Get-Member -MemberType Properties, ParameterizedProperty

   TypeName: System.Collections.Hashtable

Name           MemberType            Definition
----           ----------            ----------
Item           ParameterizedProperty System.Object Item(System.Object key) {get;set;}
Count          Property              int Count {get;}
IsFixedSize    Property              bool IsFixedSize {get;}
IsReadOnly     Property              bool IsReadOnly {get;}
IsSynchronized Property              bool IsSynchronized {get;}
Keys           Property              System.Collections.ICollection Keys {get;}
SyncRoot       Property              System.Object SyncRoot {get;}
Values         Property              System.Collections.ICollection Values {get;}

$dictionary | Get-Member -MemberType Properties, ParameterizedProperty

   TypeName: System.Collections.Specialized.OrderedDictionary

Name           MemberType            Definition
----           ----------            ----------
Item           ParameterizedProperty System.Object Item(int index) {get;set;},
                                     System.Object Item(System.Object key) {get;set;}
Count          Property              int Count {get;}
IsFixedSize    Property              bool IsFixedSize {get;}
IsReadOnly     Property              bool IsReadOnly {get;}
IsSynchronized Property              bool IsSynchronized {get;}
Keys           Property              System.Collections.ICollection Keys {get;}
SyncRoot       Property              System.Object SyncRoot {get;}
Values         Property              System.Collections.ICollection Values {get;}

En çok kullanılan özellikler Count, Keys, Valuesve Item'dır.

nesnesindeki anahtar-değer çiftlerinin sayısını gösteren Count özelliği.
Anahtarları özelliği, karma tablo veya sözlükteki anahtar adlarının bir koleksiyonudur.
```
PS> $hash.Keys
three
2
1

PS> $dictionary.Keys
1
2
three
```
Değerler özelliği, karma tablo veya sözlükteki değerlerin bir koleksiyonudur.
```
PS> $hash.Values
3
two
one

PS> $dictionary.Values
one
two
3
```
Öğe özelliği, belirttiğiniz öğenin değerini döndüren parametreli bir özelliktir. Hashtable'lar parametreli özelliğin parametresi olarak anahtarını kullanırken sözlükler varsayılan olarak dizini kullanır. Bu fark, her türün değerlerine erişme yönteminizi etkiler.

Değerlere erişme

Karma tablo veya sözlükteki değerlere erişmenin iki yaygın yolu vardır: üye gösterimi veya dizi dizini gösterimi.

Üye gösterimi - Anahtar adı nesnenin üye özelliği olarak kullanılarak değerlere erişilebilir. Örneğin:
```
PS> $hash.1
one

PS> $dictionary.2
two
```
Dizi dizini gösterimi - Değerlere dizin gösterimi kullanılarak erişilebilir. PowerShell, bu gösterimi nesnenin Item isimli parametreli özelliğine bir çağrıya dönüştürür.

Hash tablolarıyla dizin gösterimi kullandığınızda, köşeli ayraç içindeki değer anahtar adıdır. Anahtar bir dize değeriyse, anahtar adını tırnak içine alın. Örneğin:
```
PS> $hash['three']
3

PS> $hash[2]
two
```
Bu örnekte 2 anahtar değeri, değer koleksiyonundaki bir dizin değildir. Anahtar-değer çiftindeki anahtarın değeridir. Değerler koleksiyonuna erişerek bunu kanıtlayabilirsiniz.
```
PS> ([array]$hash.Values)[2]
one
```
Sözlüklerle dizin gösterimi kullandığınızda köşeli ayraçların içindeki değer türüne göre yorumlanır. Değer bir tamsayıysa, değerler koleksiyonuna dizin olarak değerlendirilir. Değer bir tamsayı değilse anahtar adı olarak değerlendirilir. Örneğin:
```
PS> $dictionary[1]
two
PS> ([array]$dictionary.Values)[1]
two
PS> $dictionary[[Object]1]
one
PS> $dictionary['three']
3
```
Örnekte, [1] parametreli özellik aşırı yüklemesini kullanan değerler koleksiyonunda Item(int index) bir dizi değeridir. dizi değeri [[Object]1] bir dizin değil, Item(System.Object key) aşırı yüklemesini kullanan bir anahtar değeridir.

Not

Anahtar değeri bir tamsayı olduğunda bu davranış kafa karıştırıcı olabilir. Mümkün olduğunda, sözlüklerde tamsayı anahtar değerlerini kullanmaktan kaçınmanız gerekir.

Özellik adı çakışmalarını işleme

Anahtar adı, HashTable türünün özellik adlarından biriyle çakışırsa, bu özelliklere erişmek için psbaseiç üye kullanabilirsiniz. Örneğin, anahtar adı keys ve HashTable anahtarlarının koleksiyonunu döndürmek istiyorsanız şu söz dizimini kullanın:

$hashtable.psbase.Keys

Bu gereksinim, System.Collections.IDictionarygibi OrderedDictionary arabirimini uygulayan diğer türler için geçerlidir.

Anahtarlar ve değerler üzerinde yineleme

Değerleri çeşitli yollarla işlemek için karma tablodaki anahtarları yineleyebilirsiniz. Bu bölümdeki örneklerin her biri aynı çıktıya sahiptir. Burada tanımlanan $hash değişkeni üzerinde döngü yapılır.

$hash = [ordered]@{Number = 1; Shape = "Square"; Color = "Blue"}

Not

Bu örneklerde $hash, çıkışın her zaman aynı sırada olduğundan emin olmak için sıralı bir sözlük olarak tanımlanır. Bu örnekler standart karma tablolarda aynı şekilde çalışır, ancak çıktının sırası tahmin edilebilir değildir.

Her örnek, her anahtar ve değeri için bir ileti döndürür:

The value of 'Number' is: 1
The value of 'Shape' is: Square
The value of 'Color' is: Blue

Bu örnekte anahtarlar üzerinde yineleme yapmak için foreach bloğu kullanılır.

foreach ($Key in $hash.Keys) {
    "The value of '$Key' is: $($hash[$Key])"
}

Bu örnekte anahtarlar üzerinde yineleme yapmak için ForEach-Object kullanılır.

$hash.Keys | ForEach-Object {
    "The value of '$_' is: $($hash[$_])"
}

Bu örnekte, her anahtar-değer çiftini işlem hattı üzerinden GetEnumerator()göndermek için ForEach-Object yöntemi kullanılır.

$hash.GetEnumerator() | ForEach-Object {
    "The value of '$($_.Key)' is: $($_.Value)"
}

Bu örnekte, her anahtar-değer çifti üzerinde yineleme yapmak için GetEnumerator() ve ForEach() yöntemleri kullanılır.

$hash.GetEnumerator().ForEach({"The value of '$($_.Key)' is: $($_.Value)"})

Anahtar ve değer ekleme ve kaldırma

Genellikle, bir karma tablo oluşturduğunuzda, anahtar-değer çiftlerini tanımında belirlersiniz. Ancak, istediğiniz zaman bir karma tabloya anahtar-değer çiftleri ekleyebilir ve kaldırabilirsiniz. Aşağıdaki örnek boş bir karma tablo (hashtable) oluşturur.

$hash = @{}

Dizi gösterimini kullanarak anahtar-değer çiftleri ekleyebilirsiniz. Örneğin, aşağıdaki örnek karma tabloya Time değerine sahip bir Now anahtarı ekler.

$hash["Time"] = "Now"

Ayrıca, Add() nesnesinin System.Collections.Hashtable yöntemini kullanarak karma tabloya anahtar ve değer ekleyebilirsiniz. Add() yöntemi aşağıdaki söz dizimine sahiptir:

Add(Key, Value)

Örneğin, karma tabloya Time değerine sahip bir Now anahtarı eklemek için aşağıdaki deyim biçimini kullanın.

$hash.Add("Time", "Now")

Ayrıca, var olan bir karma tabloya karma tablo eklemek için ekleme işlecini (+) kullanarak karma tabloya anahtar ve değer ekleyebilirsiniz. Örneğin, aşağıdaki deyim Time değişkenindeki karma tabloya Now değerine sahip bir $hash anahtarı ekler.

$hash = $hash + @{Time="Now"}

Değişkenlerde depolanan değerleri de ekleyebilirsiniz.

$t = "Today"
$now = (Get-Date)

$hash.Add($t, $now)

Karma tablodaki anahtar-değer çiftini kaldırmak için çıkarma işleci kullanamazsınız, ancak karma tablo nesnesinin Remove() yöntemini kullanabilirsiniz. Remove yöntemi aşağıdaki söz dizimine sahiptir:

$object.Remove(<key>)

Aşağıdaki örnek, Time'den $hash anahtar-değer çiftini kaldırır.

$hash.Remove("Time")

Karma tablolardaki nesne türleri

Karma tablodaki anahtarlar ve değerler herhangi bir .NET nesne türüne sahip olabilir ve tek bir karma tablo birden çok türde anahtara ve değere sahip olabilir.

Aşağıdaki deyim, işlem adı dizeleri ve işlem nesnesi değerlerini içeren bir karma tablo oluşturur ve bunu $p değişkenine kaydeder.

$p = @{
    "PowerShell" = (Get-Process powershell)
    "Notepad" = (Get-Process notepad)
}

Hashtable'ı $p'da görüntüleyebilir ve değerleri görüntülemek için anahtar adı özelliklerini kullanabilirsiniz.

PS> $p

Name                           Value
----                           -----
PowerShell                     System.Diagnostics.Process (PowerShell)
Notepad                        System.Diagnostics.Process (notepad)

PS> $p.PowerShell

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
    441      24    54196      54012   571     5.10   1788 PowerShell

PS> $p.Keys | ForEach-Object {$p.$_.Handles}
441
251

Karma tablodaki anahtarlar herhangi bir .NET türünde olabilir. Aşağıdaki deyim, $p değişkenindeki karma tabloya bir anahtar-değer çifti ekler. Anahtar, WinRM hizmetini temsil eden bir Service nesnesidir ve değer hizmetin geçerli durumudur.

$p = $p + @{
    (Get-Service WinRM) = ((Get-Service WinRM).Status)
}

Karma tablodaki diğer çiftler için kullandığınız yöntemleri kullanarak yeni anahtar-değer çiftini görüntüleyebilir ve bu çiftlere erişebilirsiniz.

PS> $p

Name                           Value
----                           -----
PowerShell                     System.Diagnostics.Process (PowerShell)
Notepad                        System.Diagnostics.Process (notepad)
System.ServiceProcess.Servi... Running

PS> $p.Keys
PowerShell
Notepad

Status   Name               DisplayName
------   ----               -----------
Running  winrm              Windows Remote Management (WS-Manag...

PS> $p.Keys | ForEach-Object {$_.Name}
WinRM

Karma tablodaki anahtarlar ve değerler de Hashtable nesneleri olabilir. Aşağıdaki ifade, anahtarın "Hash2" adlı bir dize olduğu ve değerin üç anahtar-değer çifti içeren bir karma tablo olduğu $p değişkenindeki karma tabloya anahtar-değer çifti ekler.

$p = $p + @{
    "Hash2"= @{a=1; b=2; c=3}
}

Aynı yöntemleri kullanarak yeni değerleri görüntüleyebilir ve bu değerlere erişebilirsiniz.

PS> $p

Name                           Value
----                           -----
PowerShell                     System.Diagnostics.Process (pwsh)
Hash2                          {[a, 1], [b, 2], [c, 3]}
Notepad                        System.Diagnostics.Process (Notepad)
WinRM                          Running

PS> $p.Hash2

Name                           Value
----                           -----
a                              1
b                              2
c                              3

PS> $p.Hash2.b
2

Anahtarları ve değerleri sıralama

Karma tablodaki öğeler sıralı olarak sıralanmamıştır. Anahtar-değer çiftleri her görüntülendiğinde farklı bir sırada görünebilir.

Karma tabloyu sıralayamazsınız ancak anahtarları ve değerleri listelemek için GetEnumerator() yöntemini kullanabilir ve ardından Sort-Object cmdlet'ini kullanarak görüntülenecek numaralandırılmış değerleri sıralayabilirsiniz.

Örneğin, aşağıdaki komutlar $p değişkenindeki karma tablodaki anahtarları ve değerleri numaralandırır ve ardından anahtarları alfabetik düzende sıralar.

PS> $p.GetEnumerator() | Sort-Object -Property Key

Name                           Value
----                           -----
Hash2                          {[a, 1], [b, 2], [c, 3]}
Notepad                        System.Diagnostics.Process (Notepad)
PowerShell                     System.Diagnostics.Process (pwsh)
WinRM                          Running

Aşağıdaki komut, karma değerleri azalan düzende sıralamak için aynı yordamı kullanır.

PS> $p.GetEnumerator() | Sort-Object -Property Value -Descending

Name                           Value
----                           -----
PowerShell                     System.Diagnostics.Process (pwsh)
Notepad                        System.Diagnostics.Process (Notepad)
Hash2                          {[a, 1], [b, 2], [c, 3]}
WinRM                          Running

Karma tablolardan nesne oluşturma

PowerShell 3.0'dan başlayarak, özellikler ve özellik değerlerinin karma tablosundan bir nesne oluşturabilirsiniz.

Söz dizimi aşağıdaki gibidir:

[<class-name>]@{
  <property-name>=<property-value>
  <property-name>=<property-value>
}

Bu yöntem yalnızca parametresi olmayan bir oluşturucuya sahip sınıflar için çalışır. Nesne özellikleri ortak ve ayarlanabilir olmalıdır.

Daha fazla bilgi için bkz. about_Object_Creation.

ConvertFrom-StringData

ConvertFrom-StringData cmdlet'i, bir dizeyi veya bir here-string anahtar-değer çiftini karma tabloya dönüştürür. ConvertFrom-StringData cmdlet'ini bir betiğin Veri bölümünde güvenle kullanabilir ve kullanıcı iletilerini, geçerli kullanıcının kullanıcı arabirimi (UI) kültüründe göstermek için Import-LocalizedData cmdlet'iyle birlikte kullanabilirsiniz.

Karma tablodaki değerler tırnak işaretleri içerdiğinde, here-stringler özellikle yararlıdır. Here-strings hakkında daha fazla bilgi için bkz. about_Quoting_Rules.

Aşağıdaki örnekte, önceki örnekte kullanıcı iletilerinin here-string'in nasıl oluşturulacağı ve ConvertFrom-StringData kullanarak bunları bir dizeden karma tabloya dönüştürme adımları gösterilmektedir.

Aşağıdaki komut, anahtar-değer çiftlerinin bir here-string'ini oluşturur ve $string değişkenine kaydeder.

$string = @"
Msg1 = Type "Windows".
Msg2 = She said, "Hello, World."
Msg3 = Enter an alias (or "nickname").
"@

Bu komut, ConvertFrom-StringData cmdlet'ini kullanarak here-string'i bir karma tabloya dönüştürür.

ConvertFrom-StringData $string

Name                           Value
----                           -----
Msg3                           Enter an alias (or "nickname").
Msg2                           She said, "Hello, World."
Msg1                           Type "Windows".

Here-strings hakkında daha fazla bilgi için bkz. about_Quoting_Rules.

Ayrıca bkz.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-01-24