about_Hash_Tables

Rövid leírás

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

Hosszú leírás

A kivonatolók, más néven szótárak vagy asszociatív tömbök olyan kompakt adatszerkezetek, amelyek egy vagy több kulcs-érték párot tárolnak. 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.

A PowerShellben minden kivonatoló egy [System.Collections.Hashtable] objektum. A PowerShellben használhatja az objektumok tulajdonságait és metódusait Hashtable .

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 kivonatolóktól, hogy a kulcsok mindig a lista sorrendjében jelennek meg. A kivonatoló kulcsainak sorrendje nem determinisztikus.

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

A kivonatolókat gyakran használják, mert hatékonyak az adatok megkereséséhez és beolvasásához. 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 sztringadatokat kivonatolóvá alakítja.

Szemantika

A kivonatoló 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.

Kivonatoló létrehozásához kövesse az alábbi irányelveket:

Kezdje a kivonatolót egy előjellel (@).
Csatolja a kivonatolót kapcsos zárójelekbe ({}).
Adjon meg egy vagy több kulcs-érték párot a kivonatoló tartalmához.
Használjon egyenlőségjelet (=) az egyes kulcsok értékétől való elválasztásához.
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.
A kivonatoló kezeléséhez mentse 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 kivonatolók. Bármelyik típus használható a kivonatolót vagy szótárt (iDictionary) használó paraméterek értékeként.

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

Mint látható, a kivonatoló kulcs-érték párjai nem a definiált sorrendben jelennek meg.

A rendezett szótár létrehozásának legegyszerűbb módja az attribútum használata [ordered] . 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 kivonatolókkal ellentétben a rendezett szótárak megtartják a kulcs-érték sorrendjét.

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

A [ordered] típusú gyorsító nem használható kivonatoló konvertálására vagy leadá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 egy kivonatolóra is leadhatja, 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 kivonatolók és a rendezett szótárak számos tulajdonsággal rendelkeznek. Vegye figyelembe az $hash előző példákban definiált változókat é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 Darabszám, a Kulcsok, az Értékek és az Elem.

Az objektum kulcs-érték párjainak számát jelző Count tulajdonság.
A Kulcsok tulajdonság a kivonatoló 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 kivonatoló vagy a szótár értékeinek 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 kivonatolók a paraméteres tulajdonság paramétereként a kulcsot használják, 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élda:
```
PS> $hash.1
one

PS> $dictionary.2
two
```
Tömbindex-jelölés – Az értékek az index jelölésével é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élda:
```
PS> $hash['three']
3

PS> $hash[2]
two
```
Ebben a példában a kulcsérték 2 nem index az értékek gyűjteményébe. 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élda:
```
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 tömbérték [1] egy index az értékek gyűjteményébe a Item(int index) paraméteres tulajdonság túlterhelésével. A tömbérték [[Object]1] nem index, hanem a túlterhelést használó Item(System.Object key) kulcsérték.

Feljegyzés

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 kivonatoló kulcsok gyűjteményét, használja ezt a szintaxist:

$hashtable.psbase.Keys

Ez a követelmény az interfészt megvalósító System.Collections.IDictionary egyéb típusokra is vonatkozik, például OrderedDictionary.

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

A kivonatolóban található kulcsok áthatolódásával többféleképpen is feldolgozhatja az értékeket. Az ebben a szakaszban szereplő példák mindegyike azonos kimenettel rendelkezik. Az itt definiált $hash változón iterálnak:

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

Feljegyzés

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

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 blokkot foreach 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 kulcsok iterálását használja ForEach-Object .

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

Ez a példa a metódussal GetEnumerator() küldi el az egyes kulcs-érték párokat a folyamaton ForEach-Objectkeresztül.

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

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

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

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

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

$hash = @{}

Kulcs-érték párokat a tömb jelölése használatával vehet fel. Az alábbi példa például egy Time kulcsot ad hozzá a kivonatolóhoz Now értékkel.

$hash["Time"] = "Now"

Kulcsokat és értékeket is hozzáadhat a kivonatolóhoz a Add() objektum System.Collections.Hashtable metódusával. A Add() metódus szintaxisa a következő:

Add(Key, Value)

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

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

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

$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 fájlból $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 kivonatolót megjelenítheti $p, és a kulcsnév tulajdonságaival 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 kivonatolóhoz a $p változóban. A kulcs egy szolgáltatásobjektum , 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 kivonatoló más párjaihoz.

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 kivonatoló kulcsai és értékei Hashtable objektumok is lehetnek. Az alábbi utasítás kulcs-érték párokat ad hozzá a kivonatolóhoz abban a $p változóban, amelyben a kulcs egy sztring, kivonat2, az érték pedig egy három kulcs-érték párból álló kivonatoló.

$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 kivonatoló elemei belsőleg rendezetlenek. A kulcs-érték párok minden megjelenítéskor eltérő sorrendben jelenhetnek meg.

Bár a kivonatoló nem rendezhető, a GetEnumerator() kivonatoló metódussal számba vehet kulcsokat és értékeket, majd a Sort-Object parancsmaggal rendezheti a számba vett értékeket a megjelenítéshez.

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ó: about_Object_Creation.

ConvertFrom-StringData

A ConvertFrom-StringData parancsmag egy kulcs-érték párból álló sztringet vagy here-sztringet konvertál kivonatoló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.

Az alábbi sztringek különösen akkor hasznosak, ha a kivonatoló értékei idézőjeleket tartalmaznak. Az itt szereplő sztringekről további információt a about_Quoting_Rules talál.

Az alábbi példa bemutatja, hogyan hozhat létre itt sztringet a felhasználói üzenetekből az előző példában, és hogyan konvertálhatja őket a ConvertFrom-StringData a sztringből kivonatolóvá.

Az alábbi parancs létrehozza a kulcs-érték párok egy here-sztringét, majd menti 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 az itt található sztringet kivonatolóvá.

ConvertFrom-StringData $string

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

Az itt szereplő sztringekről további információt a about_Quoting_Rules talál.

Lásd még

Visszacsatolás

Hasznos volt ez az oldal?

Last updated on 2025-09-24