hash_táblákról

Rövid leírás

Ismerteti, hogyan hozhat létre, használhat és rendezhet hashtáblákat a PowerShellben.

Hosszú leírás

A hash tábla, más néven szótár vagy asszociatív tömb, egy kompakt adatszerkezet, amely egy vagy több kulcs-érték párt tárol. A kivonatolók például IP-címeket és számítógépneveket tartalmazhatnak, ahol az IP-címek a kulcsok, a számítógépnevek pedig az értékek, vagy fordítva.

PowerShellben minden hasítótábla egy [System.Collections.Hashtable] objektum. A PowerShellben használhatja Hashtable objektumok tulajdonságait és módszereit.

A PowerShell 3.0-tól kezdve a [ordered] típusgyorsítóval létrehozhat egy [System.Collections.Specialized.OrderedDictionary] objektumot a PowerShellben.

A rendezett szótárak abban különböznek a hash-tábláktól, hogy a kulcsok mindig abban a sorrendben jelennek meg, ahogy megadod őket. A hasítótábla kulcsainak sorrendje nem determinisztikus.

A hash táblák kulcsai és értékei szintén .NET-objektumok. Ezek leggyakrabban sztringek vagy egész számok, de bármilyen objektumtípussal rendelkezhetnek. Beágyazott hashtáblákat is létrehozhat, amelyekben egy kulcs értéke egy másik hashtábla.

A hashtáblákat gyakran használják, mert hatékonyak az adatok megkereséséhez és lekéréséhez. A kivonatolókkal listákat tárolhat, és számított tulajdonságokat hozhat létre a PowerShellben. A ConvertFrom-StringData parancsmag pedig a strukturált szöveges adatokat hash-táblává alakítja.

Szemantika

A hash tábla szintaxisa a következő:

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

A rendezett szótár szintaxisa a következő:

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

A [ordered] típusgyorsítót a PowerShell 3.0-ban vezettük be.

Hasítótábla létrehozásához kövesse az alábbi irányelveket:

Kezdje a hashtáblát egy kettőskereszttel (@).
Helyezze a szótártáblát kapcsos zárójelek közé ({}).
Adjon meg egy vagy több kulcs-érték párot a kivonatoló tartalmához.
Használjon egyenlőségjelet (=) az egyes kulcsok és értékeik elválasztására.
A kulcs-érték párok elválasztásához használjon pontosvesszőt (;) vagy sortörést.
A szóközöket tartalmazó kulcsokat idézőjelek közé kell foglalni. Az értékeknek érvényes PowerShell-kifejezéseknek kell lenniük. A sztringeknek idézőjelekben kell megjelenniük, még akkor is, ha nem tartalmaznak szóközöket.
Hash tábla kezeléséhez mentse el egy változóba.
Ha rendezett kivonatolót rendel egy változóhoz, helyezze a [ordered] típust a @ szimbólum elé. Ha a változó neve elé helyezi, a parancs sikertelen lesz.

A rendezett szótárak ugyanúgy használhatók, mint a hashtáblák. Bármelyik típus használható olyan paraméterek értékeként, amelyek hash táblázat vagy szótár típusú objektumokat vesznek fel (iDictionary).

Kivonatolók és rendezett szótárak létrehozása

Tekintse meg az alábbi kivonatoló és rendezett szótár példákat:

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

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

Ahogy látható, a hash tábla kulcs-érték párjai nem a meghatározott sorrendben jelennek meg.

A rendezett szótár létrehozásának legegyszerűbb módja a [ordered] attribútum használata. Helyezze az attribútumot közvetlenül a @ szimbólum elé.

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

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

A hash táblákkal ellentétben a rendezett szótárak megtartják a kulcs-érték sorrendjét.

Hash táblák és rendezett szótárak konvertálása

Nem használhatja a [ordered] típusú gyorsítót egy hash tábla konvertálására vagy alakítására. Ha a rendezett attribútumot a változó neve elé helyezi, a parancs a következő hibaüzenettel meghiúsul.

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

A kifejezés javításához helyezze át a [rendezett] attribútumot.

$orderedHash = [ordered]@{}

A rendezett szótárat átalakíthatja egy hasítótáblává, de nem garantálhatja a tagok sorrendjét.

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

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

Hashtable és szótártulajdonságok

A hash táblák és a rendezett szótárak számos közös tulajdonsággal rendelkeznek. Vegye figyelembe az előző példákban definiált $hash és $dictionary változókat.

$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;}

A leggyakrabban használt tulajdonságok a következők: Darabszám, Kulcsok, Értékekés Elem.

A Darabszám tulajdonság, amely jelzi az objektumban lévő kulcs-érték párok számát.
A Kulcsok tulajdonság a hashtábla vagy a szótár kulcsneveinek gyűjteménye.
```
PS> $hash.Keys
three
2
1

PS> $dictionary.Keys
1
2
three
```
Az Értékek tulajdonság a hash tábla vagy a szótár értékei gyűjteménye.
```
PS> $hash.Values
3
two
one

PS> $dictionary.Values
one
two
3
```
Az Elem tulajdonság egy paraméteres tulajdonság, amely a megadott elem értékét adja vissza. A hashtáblák a paraméteres tulajdonságok kulcsaként használják a kulcsot, míg a szótárak alapértelmezés szerint az indexet használják. Ez a különbség befolyásolja az egyes típusok értékeinek elérését.

Értékek elérése

A kivonatolóban vagy a szótárban lévő értékek kétféleképpen érhetők el: tagjegyzet vagy tömbindex jelölése.

tag jelölése – Az értékek az objektum tagtulajdonságaként használt kulcsnév használatával érhetők el. Például:
```
PS> $hash.1
one

PS> $dictionary.2
two
```
Tömbindex-jelölés – Az értékek indexjelezéssel érhetők el. A PowerShell ezt a jelölést az objektum Elem paraméteres tulajdonságának hívásává alakítja.

Ha kivonatolókkal használja az index jelölését, a zárójelek között lévő érték a kulcs neve. Ha a kulcs sztringérték, a kulcs nevét idézőjelek közé kell fűzni. Például:
```
PS> $hash['three']
3

PS> $hash[2]
two
```
Ebben a példában a 2 kulcsérték nem index az értékek gyűjteményében. Ez a kulcs értéke a kulcs-érték párban. Ezt az értékgyűjteménybe való indexeléssel bizonyíthatja.
```
PS> ([array]$hash.Values)[2]
one
```
Ha szótárakkal együtt használja az index jelölését, a zárójelek értékeit a rendszer annak típusa alapján értelmezi. Ha az érték egész szám, akkor az indexként lesz kezelve az értékek gyűjteményében. Ha az érték nem egész szám, akkor a kulcsnévként lesz kezelve. Például:
```
PS> $dictionary[1]
two
PS> ([array]$dictionary.Values)[1]
two
PS> $dictionary[[Object]1]
one
PS> $dictionary['three']
3
```
Ebben a példában a [1] tömbérték indexként szolgál az értékek gyűjteményében, a Item(int index) paraméterezett tulajdonság-túlterhelést használva. A tömbérték [[Object]1] nem index, hanem kulcsérték a Item(System.Object key) túlterhelést használva.

Jegyzet

Ez a viselkedés zavaró lehet, ha a kulcsérték egész szám. Ha lehetséges, ne használjon egész szám kulcsértékeket a szótárakban.

Tulajdonságnév-ütközések kezelése

Ha a kulcsnév ütközik a Kivonattábla típus egyik tulajdonságnevével, a psbasebelső tag használhatja a tulajdonságok eléréséhez. Ha például a kulcs neve keys, és vissza szeretné adni a hasítótábla kulcsainak gyűjteményét, használja ezt a szintaxist:

$hashtable.psbase.Keys

Ez a követelmény a System.Collections.IDictionary felületet implementáló egyéb típusokra is vonatkozik, például OrderedDictionary.

Kulcsok és értékek iterálása

A hashtábla kulcsain végigiterálva az értékek többféle feldolgozására van lehetőség. Az ebben a szakaszban szereplő példák mindegyike azonos kimenettel rendelkezik. Iterálnak az itt definiált $hash változón:

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

Jegyzet

Ezekben a példákban a $hash rendezett szótárként van definiálva, hogy a kimenet mindig ugyanabban a sorrendben legyen. Ezek a példák ugyanúgy működnek a standard hashtáblák esetében, de a kimenet sorrendje nem előre jelezhető.

Minden példa egy üzenetet ad vissza minden kulcshoz és értékéhez:

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

Ez a példa egy foreach blokkot használ a kulcsok iterálásához.

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

Ez a példa a ForEach-Object-t használja a kulcsok iterálására.

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

Ez a példa a GetEnumerator() metódussal továbbítja az egyes kulcs-érték párokat a folyamaton keresztül a ForEach-Object-hez.

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

Ez a példa a GetEnumerator() és ForEach() metódusokat használja az egyes kulcs-érték párok iterálásához.

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

Kulcsok és értékek hozzáadása és eltávolítása

Hash-tábla létrehozásakor általában belefoglalja a kulcs-érték párokat a definícióba. A kulcs-érték párokat azonban bármikor hozzáadhatja és eltávolíthatja a hashtáblából. Az alábbi példa egy üres hashtáblát hoz létre.

$hash = @{}

Kulcs-érték párokat tömbös jelöléssel vehet fel. Az alábbi példa egy Time kulcsot ad hozzá a hash-táblához Now értékkel.

$hash["Time"] = "Now"

Kulcsokat és értékeket is hozzáadhat egy hash-táblához a Add() objektum System.Collections.Hashtable metódusát használva. A Add() metódus szintaxisa a következő:

Add(Key, Value)

Ha például egy Time kulcsot szeretne hozzáadni a hash táblához Now értékkel, használja az alábbi utasítási formátumot.

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

Emellett kulcsokat és értékeket is hozzáadhat egy kivonattáblához az összeadás operátorral (+), így hozzáadva egy kivonattáblát egy meglévőhöz. Az alábbi utasítás például egy Time kulcsot ad hozzá a Now változóban lévő hash táblához $hash értékkel.

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

Változókban tárolt értékeket is hozzáadhat.

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

$hash.Add($t, $now)

A kivonatoló operátorral nem távolíthat el kulcs-érték párokat a kivonatolóból, de használhatja a kivonatolható objektum Remove() metódusát. A Remove metódus szintaxisa a következő:

$object.Remove(<key>)

Az alábbi példa eltávolítja a Time kulcs-érték párot a $hash.

$hash.Remove("Time")

Objektumtípusok a kivonatolókban

A kivonatolóban lévő kulcsok és értékek bármilyen .NET-objektumtípussal rendelkezhetnek, és egyetlen kivonatoló több típusú kulcsokkal és értékekkel rendelkezhet.

Az alábbi utasítás létrehoz egy kivonatot a folyamatnév-sztringekről és a folyamatobjektum-értékekről, és menti azt a $p változóba.

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

A hash táblát megjelenítheti a $p-ban, és a kulcsnevek tulajdonságait használva megjelenítheti az értékeket.

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

A kivonatoló kulcsai bármilyen .NET típusúak lehetnek. Az alábbi utasítás egy kulcs-érték párot ad hozzá a hash-táblához a $p változóban lévő. A kulcs egy Szolgáltatás objektum, amely a WinRM szolgáltatást jelöli, az érték pedig a szolgáltatás aktuális állapota.

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

Az új kulcs-érték pár ugyanazokkal a módszerekkel jeleníthető meg és érhető el, mint a hash tábla többi párja.

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

A hashtábla kulcsai és értékei Hashtable objektumok is lehetnek. Az alábbi utasítás egy kulcs-érték párt ad hozzá a $p változóban található hash táblához, amelyben a kulcs egy szöveg, "Hash2", és az érték egy hash tábla, amely három kulcs-érték párt tartalmaz.

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

Az új értékeket ugyanazokkal a metódusokkal jelenítheti meg és érheti el.

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

Kulcsok és értékek rendezése

A hashtábla elemei rendezetlenek. A kulcs-érték párok minden megjelenítéskor eltérő sorrendben jelenhetnek meg.

Bár a hashtábla nem rendezhető, a hashtáblák GetEnumerator() metódusával felsorolhatja a kulcsokat és az értékeket, majd a Sort-Object parancsmaggal rendezheti a felsorolt értékeket megjelenítés céljából.

Az alábbi parancsok például számba adják a $p változó kivonatolójában lévő kulcsokat és értékeket, majd betűrendbe rendezik a kulcsokat.

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

Az alábbi parancs ugyanezt az eljárást használja a kivonatértékek csökkenő sorrendbe rendezéséhez.

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

Objektumok létrehozása kivonatolókból

A PowerShell 3.0-tól kezdve létrehozhat egy objektumot tulajdonságok és tulajdonságértékek kivonatából.

A szintaxis a következő:

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

Ez a módszer csak olyan osztályok esetében működik, amelyek konstruktora nem rendelkezik paraméterekkel. Az objektum tulajdonságainak nyilvánosnak és beállíthatónak kell lenniük.

További információért lásd a következőt: about_Object_Creation.

ConvertFrom-StringData

A ConvertFrom-StringData parancsmag egy kulcs-érték párokat tartalmazó sztringet vagy here-sztringet konvertál hash-táblává. A ConvertFrom-StringData parancsmagot biztonságosan használhatja egy szkript Adat szakaszában, és a Import-LocalizedData parancsmaggal is megjelenítheti a felhasználói üzeneteket az aktuális felhasználó felhasználói felületi (felhasználói felületi) kultúrájában.

A Here-stringek különösen akkor hasznosak, ha a hash tábla értékei idézőjeleket tartalmaznak. További információ a here-stringekről: lásd about_Quoting_Rules.

Az alábbi példa bemutatja, hogyan hozhat létre szövegblokkot a felhasználói üzenetekből az előző példában, és hogyan használhatja a ConvertFrom-StringData-t, hogy ezeket a sztringeket hashtáblává alakítsa át.

Az alábbi parancs létrehozza a kulcs-érték párok egy here-sztringét, majd menti azt a $string változóba.

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

Ez a parancs a ConvertFrom-StringData parancsmaggal konvertálja a szövegsort hash-táblázattá.

ConvertFrom-StringData $string

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

További információ a here-stringekről: lásd about_Quoting_Rules.

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-09-29