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 nesnelerin özelliklerini ve yöntemlerini Hashtable kullanabilirsiniz.

PowerShell 3.0'da başlayarak, PowerShell'de nesne [ordered] oluşturmak için tür hızlandırıcısını [System.Collections.Specialized.OrderedDictionary] kullanabilirsiniz.

Sıralı sözlükler, anahtarların her zaman listelediğiniz sırada 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'i yapılandırılmış dize verilerini bir hashtable'a 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> ] ...}

Tür hızlandırıcısı [ordered] 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 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.

Karma tablo 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 tablodaki anahtar-değer çiftleri tanımlandıkları sırayla sunulmaz.

Sıralı sözlük oluşturmanın en kolay yolu özniteliğini [ordered] kullanmaktır. Özniteliği simgenin @ 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.

Karma tablo ve sıralı sözlükleri dönüştürme

Karma tablo dönüştürmek veya dönüştürmek 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ğini taşıyın.

$orderedHash = [ordered]@{}

Bir düzenli sözlüğü, bir karma tabloya dönüştürebilirsiniz, ancak üyelerin sırasını garantileyemezsiniz.

[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. $hash Önceki örneklerde tanımlanan 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, Values ve Item'tır.

Nesnedeki 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
```
Item ö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 nesnesinin Item parametreli özelliğine yapılan bir çağrıya dönüştürür.

Karma tablolarla dizin gösterimi kullandığınızda köşeli ayraçların 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 anahtar değeri 2 , değer koleksiyonundaki bir dizin değildir. Anahtar-değer çiftindeki anahtarın değeridir. Değerlerin koleksiyonuna dizin ekleyerek 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
```
Bu örnekte dizi değeri [1] , parametreli özellik aşırı yüklemesini kullanarak değerlerin koleksiyonundaki Item(int index) bir dizindir. Dizi değeri [[Object]1] bir dizin değil, aşırı yükleme kullanan Item(System.Object key) 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, gibi System.Collections.IDictionaryarabirimini uygulayan OrderedDictionary 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 değişken üzerinde $hash yinelenir:

$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 bir foreach blok kullanılır.

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

Bu örnek, anahtarları yinelemek için kullanır ForEach-Object .

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

Bu örnekte, işlem hattı aracılığıyla her anahtar-değer çiftini adresine göndermek için GetEnumerator()yöntemi kullanılırForEach-Object.

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

Bu örnek, her anahtar-değer çifti GetEnumerator() üzerinde yineleme yapmak için ve ForEach() yöntemlerini kullanı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ına eklersiniz. Ancak, istediğiniz zaman bir karma tabloya anahtar-değer çiftleri ekleyebilir ve kaldırabilirsiniz. Aşağıdaki örnek boş bir karma tablo 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, anahtar-değer çiftini Time 'den $hashkaldı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)
}

Karma tabloyu $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

Bir karma tabloda anahtarlar ve değerler de Hashtable nesneler olabilir. Aşağıdaki ifade, anahtarı dize olarak "Hash2" olan ve değeri üç anahtar-değer çifti içeren bir karma tablo şeklinde $p değişkenine 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 şu şekildedir:

[<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 anahtar-değer çiftlerinden oluşan bir here-string’i, bir karma tabloya dönüştürür. Cmdlet'ini ConvertFrom-StringData bir betiğin Veri bölümünde güvenli bir şekilde kullanabilir ve geçerli kullanıcının kullanıcı arabirimi (UI) kültüründe kullanıcı iletilerini görüntülemek için cmdlet'iyle Import-LocalizedData birlikte kullanabilirsiniz.

Karma tabloda değerler tırnak işaretleri içerdiğinde, here-string ifadeler ö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 değişkenine $string 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 bakınız

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-01-23