about_Hash_Tables
Kort beskrivning
Beskriver hur du skapar, använder och sorterar hashtabeller i PowerShell.
Lång beskrivning
En hashtable, även kallad ordlista eller associativ matris, är en kompakt datastruktur som lagrar ett eller flera nyckel/värde-par. En hash-tabell kan till exempel innehålla en serie IP-adresser och datornamn, där IP-adresserna är nycklarna och datornamnen är värdena, eller tvärtom.
I PowerShell är varje hashtable ett Hashtable[System.Collections.Hashtable] objekt. Du kan använda egenskaperna och metoderna för Hashtable objekt i PowerShell.
Från och med PowerShell 3.0 kan du använda [ordered] attributet för att skapa ett [System.Collections.Specialized.OrderedDictionary] objekt i PowerShell.
Ordnade ordlistor skiljer sig från hashtables eftersom nycklarna alltid visas i den ordning som du listar dem. Ordningen på nycklar i en hashtable bestäms inte.
Nycklarna och värdet i hashtables är också .NET-objekt. De är oftast strängar eller heltal, men de kan ha vilken objekttyp som helst. Du kan också skapa kapslade hashtables, där värdet för en nyckel är en annan hashtable.
Hashtables används ofta eftersom de är effektiva för att hitta och hämta data. Du kan använda hashtables för att lagra listor och skapa beräknade egenskaper i PowerShell. Och PowerShell har en cmdlet, , ConvertFrom-StringDatasom konverterar strängar till en hashtable.
Syntax
Syntaxen för en hashtable är följande:
@{ <name> = <value>; [<name> = <value> ] ...}
Syntaxen för en ordnad ordlista är följande:
[ordered]@{ <name> = <value>; [<name> = <value> ] ...}
Typacceleratorn [ordered] introducerades i PowerShell 3.0.
Skapa hashtables
Följ dessa riktlinjer för att skapa en hashtable:
- Börja hashtabellen med ett vidtecken (
@). - Omslut hashtabellen i klammerparenteser (
{}). - Ange ett eller flera nyckel/värde-par för innehållet i hash-tabellen.
- Använd ett likhetstecken (
=) för att skilja varje nyckel från dess värde. - Använd ett semikolon (
;) eller en radbrytning för att separera nyckel/värde-paren. - Nycklar som innehåller blanksteg måste omges av citattecken. Värden måste vara giltiga PowerShell-uttryck. Strängar måste visas inom citattecken, även om de inte innehåller blanksteg.
- Om du vill hantera hashtabellen sparar du den i en variabel.
- När du tilldelar en ordnad hashtable till en variabel placerar
[ordered]du typen före symbolen@. Om du placerar den före variabelnamnet misslyckas kommandot.
Om du vill skapa en tom hashtabell i värdet för $hash skriver du:
$hash = @{}
Du kan också lägga till nycklar och värden i en hashtable när du skapar den. Följande instruktion skapar till exempel en hashtable med tre nycklar.
$hash = @{ Number = 1; Shape = "Square"; Color = "Blue"}
Skapa ordnade ordlistor
Du kan skapa en ordnad ordlista genom att lägga till ett objekt av typen OrderedDictionary , men det enklaste sättet att skapa en ordnad ordlista är att använda attributet [ordered] .
Attributet [ordered] introduceras i PowerShell 3.0.
Placera attributet omedelbart före "@"-symbolen.
$hash = [ordered]@{ Number = 1; Shape = "Square"; Color = "Blue"}
Du kan använda ordnade ordlistor på samma sätt som du använder hashtables. Antingen typ kan användas som värde för parametrar som tar en hashtable eller ordlista (iDictionary).
Du kan inte använda attributet [ordered] för att konvertera eller omvandla en hashtable. Om du placerar det ordnade attributet före variabelnamnet misslyckas kommandot med följande felmeddelande.
[ordered]$hash = @{}
ParserError:
Line |
1 | [ordered]$hash = @{}
| ~~~~~~~~~~~~~~
| The ordered attribute can be specified only on a hash literal node.
Om du vill korrigera uttrycket flyttar du attributet [ordnat].
$hash = [ordered]@{}
Du kan omvandla en ordnad ordlista till en hashtable, men du kan inte återställa det ordnade attributet, även om du rensar variabeln och anger nya värden. Om du vill återupprätta ordningen måste du ta bort och återskapa variabeln.
[hashtable]$hash = [ordered]@{
Number = 1; Shape = "Square"; Color = "Blue"}
$hash
Name Value
---- -----
Color Blue
Shape Square
Number 1
Visa hashtables
Om du vill visa en hashtabell som sparas i en variabel skriver du variabelnamnet. Som standard visas en hashtables som en tabell med en kolumn för nycklar och en för värden.
$hash
Name Value
---- -----
Shape Square
Color Blue
Number 1
hashtables har egenskaper för nycklar och värden . Använd punkt notation för att visa alla nycklar eller alla värden.
$hash.keys
Number
Shape
Color
$hash.values
1
Square
Blue
Varje nyckelnamn är också en egenskap för hashtable och dess värde är värdet för nyckelnamnegenskapen. Använd följande format för att visa egenskapsvärdena.
$hashtable.<key>
<value>
Till exempel:
$hash.Number
1
$hash.Color
Blue
hashtables har egenskapen Count som anger antalet nyckel/värde-par i hash-tabellen.
$hash.count
3
hashtable-tabeller är inte matriser, så du kan inte använda ett heltal som ett index i hashtabellen, men du kan använda ett nyckelnamn för att indexera till hashtabellen. Om nyckeln är ett strängvärde omger du nyckelnamnet inom citattecken.
Till exempel:
$hash["Number"]
1
Hantera kollisioner med egenskapsnamn
Om nyckelnamnet kolliderar med ett av egenskapsnamnen för HashTable-typen kan du använda den inbyggda psbase-medlemmen för att få åtkomst till dessa egenskaper. Om nyckelnamnet till exempel är keys och du vill returnera samlingen med HashTable-nycklar använder du den här syntaxen:
$hashtable.psbase.Keys
Detta gäller för andra typer som implementerar System.Collections.IDictionary gränssnittet, till exempel OrderedDictionary.
Iterera över nycklar och värden
Du kan iterera över nycklarna i en hashtable för att bearbeta värdena på flera sätt. Vart och ett av exemplen i det här avsnittet har identiska utdata. De itererar över variabeln $hash som definieras här:
$hash = [ordered]@{ Number = 1; Shape = "Square"; Color = "Blue"}
Kommentar
I de här exemplen definieras $hash som en ordnad ordlista för att säkerställa att utdata alltid är i samma ordning. De här exemplen fungerar likadant för normala hashtables, men utdataordningen är inte förutsägbar.
Varje exempel returnerar ett meddelande för varje nyckel och dess värde:
The value of 'Number' is: 1
The value of 'Shape' is: Square
The value of 'Color' is: Blue
I det här exemplet används ett foreach-block för att iterera över nycklarna.
foreach ($Key in $hash.Keys) {
"The value of '$Key' is: $($hash[$Key])"
}
Det här exemplet används ForEach-Object för att iterera över nycklarna.
$hash.Keys | ForEach-Object {
"The value of '$_' is: $($hash[$_])"
}
I det här exemplet används metoden GetEnumerator för att skicka varje nyckel/värde-par via pipelinen till ForEach-Object.
$hash.GetEnumerator() | ForEach-Object {
"The value of '$($_.Key)' is: $($_.Value)"
}
I det här exemplet används metoderna GetEnumerator och ForEach för att iterera över varje nyckel/värde-par.
$hash.GetEnumerator().ForEach({"The value of '$($_.Key)' is: $($_.Value)"})
Lägga till och ta bort nycklar och värden
Om du vill lägga till nycklar och värden i en hashtable använder du följande kommandoformat.
$hash["<key>"] = "<value>"
Om du till exempel vill lägga till en "Time"-nyckel med värdet "Nu" i hashtabellen använder du följande instruktionsformat.
$hash["Time"] = "Now"
Du kan också lägga till nycklar och värden i en hashtable med hjälp Add av objektets System.Collections.Hashtable metod. Metoden Add har följande syntax:
Add(Key, Value)
Om du till exempel vill lägga till en Time nyckel med värdet Now i hashtabellen använder du följande instruktionsformat.
$hash.Add("Time", "Now")
Och du kan lägga till nycklar och värden i en hashtable med hjälp av additionsoperatorn (+) för att lägga till en hashtable i en befintlig hashtable. Följande instruktion lägger till exempel till en Time nyckel med värdet Now för till hashtabellen i variabeln $hash .
$hash = $hash + @{Time="Now"}
Du kan också lägga till värden som lagras i variabler.
$t = "Today"
$now = (Get-Date)
$hash.Add($t, $now)
Du kan inte använda en subtraktionsoperator för att ta bort ett nyckel/värde-par från en hash-tabell, men du kan använda metoden Ta bort för Hashtable objektet. Metoden Ta bort tar nyckeln som dess värde.
Metoden Remove har följande syntax:
Remove(Key)
Om du till exempel vill ta bort Time=Now nyckel/värde-paret från hashtabellen i variabelns $hash värde skriver du:
$hash.Remove("Time")
Du kan använda alla egenskaper och metoder för Hashtable objekt i PowerShell, inklusive Contains, Clear, Cloneoch CopyTo. Mer information om Hashtable objekt finns i System.Collections.Hashtable.
Objekttyper i HashTables
Nycklar och värden i en hashtable kan ha valfri .NET-objekttyp, och en enda hashtable kan ha nycklar och värden av flera typer.
Följande instruktion skapar en hashtabell med processnamnsträngar och processobjektvärden och sparar den i variabeln $p .
$p = @{
"PowerShell" = (Get-Process PowerShell)
"Notepad" = (Get-Process notepad)
}
Du kan visa hashtabellen i $p och använda nyckelnamnsegenskaperna för att visa värdena.
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
Nycklarna i en hashtable kan vara valfri .NET-typ. Följande instruktion lägger till ett nyckel/värde-par i hashtabellen i variabeln $p . Nyckeln är ett tjänstobjekt som representerar WinRM-tjänsten och värdet är tjänstens aktuella status.
$p = $p + @{
(Get-Service WinRM) = ((Get-Service WinRM).Status)
}
Du kan visa och komma åt det nya nyckel/värde-paret med samma metoder som du använder för andra par i hashtabellen.
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
Nycklar och värden i en hashtable kan också vara Hashtable objekt. Följande instruktion lägger till nyckel/värde-par till hashtabellen $p i variabeln där nyckeln är en sträng, Hash2, och värdet är en hashtable med tre nyckel/värde-par.
$p = $p + @{
"Hash2"= @{a=1; b=2; c=3}
}
Du kan visa och komma åt de nya värdena med samma metoder.
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
Sortera nycklar och värden
Objekten i en hashtable är i sig osorterade. Nyckel/värde-paren kan visas i en annan ordning varje gång du visar dem.
Även om du inte kan sortera en hashtable kan du använda metoden GetEnumerator för hashtables för att räkna upp nycklar och värden och sedan använda cmdleten Sort-Object för att sortera uppräknade värden för visning.
Följande kommandon räknar till exempel upp nycklar och värden i hash-tabellen i variabeln $p och sorterar sedan nycklarna i alfabetisk ordning.
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
Följande kommando använder samma procedur för att sortera hash-värdena i fallande ordning.
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
Skapa objekt från hashtables
Från och med PowerShell 3.0 kan du skapa ett objekt från en hashtabell med egenskaper och egenskapsvärden.
Syntaxen ser ut så här:
[<class-name>]@{
<property-name>=<property-value>
<property-name>=<property-value>
}
Den här metoden fungerar endast för klasser som har en konstruktor som inte har några parametrar. Objektegenskaperna måste vara offentliga och kan ställas in.
Mer information finns i about_Object_Creation.
ConvertFrom-StringData
Cmdleten ConvertFrom-StringData konverterar en sträng eller en här-sträng med nyckel/värde-par till en hashtable. Du kan använda cmdleten ConvertFrom-StringData på ett säkert sätt i avsnittet Data i ett skript, och du kan använda den med cmdleten Import-LocalizedData för att visa användarmeddelanden i användargränssnittskulturen (UI) för den aktuella användaren.
Här-strängar är särskilt användbara när värdena i hashtabellen innehåller citattecken. Mer information om här-strängar finns i about_Quoting_Rules.
I följande exempel visas hur du skapar en här-sträng med användarmeddelandena i föregående exempel och hur du använder ConvertFrom-StringData för att konvertera dem från en sträng till en hashtable.
Följande kommando skapar en här-sträng av nyckel/värde-paren och sparar den sedan i variabeln $string .
$string = @"
Msg1 = Type "Windows".
Msg2 = She said, "Hello, World."
Msg3 = Enter an alias (or "nickname").
"@
Det här kommandot använder cmdleten ConvertFrom-StringData för att konvertera här-strängen till en hashtable.
ConvertFrom-StringData $string
Name Value
---- -----
Msg3 Enter an alias (or "nickname").
Msg2 She said, "Hello, World."
Msg1 Type "Windows".
Mer information om här-strängar finns i about_Quoting_Rules.
Se även
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för