Tables de hachage et de l'ordre des clés

Est-il un moyen de maintenir la commande de clés dans une table de hachage comme ils ont été ajoutés? Comme un push/pop mécanisme.

Exemple:

$hashtable = @{}

$hashtable.Add("Switzerland", "Bern")
$hashtable.Add("Spain", "Madrid")
$hashtable.Add("Italy", "Rome")
$hashtable.Add("Germany", "Berlin")
$hashtable

Je veux garder l'ordre dans lequel j'ai ajouté les éléments de la table de hachage.

InformationsquelleAutor Phil | 2013-02-15
  1. 45

    Il n'y a pas de solution intégrée dans PowerShell V1 /V2. Vous souhaitez utiliser les .NET
    System.Les Collections.Spécialisés.OrderedDictionary:

    $order = New-Object System.Collections.Specialized.OrderedDictionary
$order.Add("Switzerland", "Bern")
$order.Add("Spain", "Madrid")
$order.Add("Italy", "Rome")
$order.Add("Germany", "Berlin")


PS> $order

Name                           Value
----                           -----
Switzerland                    Bern
Spain                          Madrid
Italy                          Rome
Germany                        Berlin

    Dans PowerShell V3 vous pouvez lancer à [ordonné]:

    PS> [ordered]@{"Switzerland"="Bern"; "Spain"="Madrid"; "Italy"="Rome"; "Germany"="Berlin"}

Name                           Value
----                           -----
Switzerland                    Bern
Spain                          Madrid
Italy                          Rome
Germany                        Berlin
    • Merci pour les réponses! Je savais que le PS v3 [ordonné] mais je dois utiliser PS 2.0
    InformationsquelleAutor Loïc MICHEL
  2. 9

    Vous pouvez utiliser un ordre dictionnaire de la place:

    Comme ceci:

    $list = New-Object System.Collections.Specialized.OrderedDictionary
$list.Add("Switzerland", "Bern")
$list.Add("Spain", "Madrid")
$list.Add("Italy", "Rome")
$list.Add("Germany", "Berlin")
$list
    InformationsquelleAutor Frode F.
  3. 4

    Vous pouvez donner un séquentielle clés que vous ajoutez des éléments:

    $hashtable = @{}
$hashtable[$hashtable.count] = @("Switzerland", "Bern")
$hashtable[$hashtable.count] = @("Spain", "Madrid")
$hashtable[$hashtable.count] = @("Italy", "Rome")
$hashtable[$hashtable.count] = @("Germany", "Berlin")
$hashtable

    Ensuite, vous pouvez obtenir les éléments triés par la clé:

    echo "`nHashtable keeping the order as they were added"
foreach($item in $hashtable.getEnumerator() | Sort Key)
{
    $item
}
    InformationsquelleAutor Juan Antonio Tubío
  4. 1

    Pour la compatibilité avec les anciens PowerShell versions, vous pouvez envisager cette applet de commande:

    Function Order-Keys {
    param(
        [Parameter(Mandatory = $true, ValueFromPipeline = $true)][HashTable]$HashTable,
        [Parameter(Mandatory = $false, Position = 1)][ScriptBlock]$Function,
        [Switch]$Descending
    )
    $Keys = $HashTable.Keys | ForEach {$_} # Copy HashTable + KeyCollection
    For ($i = 0; $i -lt $Keys.Count - 1; $i++) {
        For ($j = $i + 1; $j -lt $Keys.Count; $j++) {
            $a = $Keys[$i]
            $b = $Keys[$j]
            If ($Function -is "ScriptBlock") {
                $a = $HashTable[$a] | ForEach $Function
                $b = $HashTable[$b] | ForEach $Function
            }
            If ($Descending) {
                $Swap = $a -lt $b
            }
            Else
            {
                $Swap = $a -gt $b
            }
            If ($Swap) {
                $Keys[$i], $Keys[$j] = $Keys[$j], $Keys[$i]
            }
        }
    }
    Return $Keys
}

    Cette applet de commande retourne une liste de clés commandé par la définition de la fonction:

    Trier par nom:

    $HashTable | Order-Keys | ForEach {Write-Host $_ $HashTable[$_]}
Germany Berlin
Italy Rome
Spain Madrid
Switzerland Bern

    Trier par valeur:

    $HashTable | Order-Keys {$_} | ForEach {Write-Host $_ $HashTable[$_]}
Germany Berlin
Switzerland Bern
Spain Madrid
Italy Rome

    Vous avez aussi la possibilité d'imbriquer les tables de hachage:

    $HashTable = @{
    Switzerland = @{Order = 1; Capital = "Berne"}
    Germany     = @{Order = 2; Capital = "Berlin"}
    Spain       = @{Order = 3; Capital = "Madrid"}
    Italy       = @{Order = 4; Capital = "Rome"}
}

    E. g. trier par (hachés) afin de la propriété et de revenir sur la touche (pays):

    $HashTable | Order-Keys {$_.Order} | ForEach {$_}

    Ou de tri (ordre décroissant) par la prédéfinis capital:

    $HashTable | Order-Keys {$_.Capital} -Descending | ForEach {$_}
    • Mais la question était de garder l'ordre dans lequel le hachage a été ajoutée, pas de tri par des clés ou de tri par des valeurs. Comment est-ce répondre à la question?
    InformationsquelleAutor iRon
  5. 1

    Le PowerShell 1 consiste à ajouter une table de hachage membre conserve la commande ajouter. Il n'est pas nécessaire pour utiliser le Système.Les Collections.Spécialisés.OrderedDictionary:

    $Hash = New-Object PSObject                                       
$Hash | Add-Member -MemberType NoteProperty -Name key1 -Value val1
$Hash | Add-Member -MemberType NoteProperty -Name key2 -Value val2
$Hash | Add-Member -MemberType NoteProperty -Name key3 -Value val3
    • Mais ce n'est pas une table de hachage, c'est un PSCustomObject. Pas la même chose, même si vous le nom de la variable "$Hash". 😉 Un OrderedDictionary fonctionne comme une table de hachage pour tous les buts pratiques que j'ai essayé.
    InformationsquelleAutor Axel Limousin
  6. 0
    function global:sortDictionaryByKey([hashtable]$dictionary)
{
    return $dictionary.GetEnumerator() | sort -Property name;
}
    • Bienvenue à Débordement de Pile. Alors que ce code peut répondre à la question, en fournissant plus de contexte sur le pourquoi et/ou comment ce code répond à la question améliore sa valeur à long terme.Comment Répondre. Merci!
    • Mais la question était de garder l'ordre dans lequel le hachage a été ajoutée, pas de tri par touches. Comment est-ce répondre à la question?
    InformationsquelleAutor user2174447
  7. 0

    Ici est une simple routine qui fonctionne pour moi.

    function sortedKeys([hashtable]$ht) {
  $out = @()
  foreach($k in $ht.keys) {
    $out += $k
  }
  [Array]::sort($out)
  return ,$out
}

    et l'appel à l'utiliser

    forEach($k in (& sortedKeys $ht)) {
  ...
}
    • Mais la question était de garder l'ordre dans lequel le hachage a été ajoutée, pas de tri par touches. Comment est-ce répondre à la question?
    • Pierre, vous avez raison. J'étais confus et de la pensée Commandé dictionnaire a été comme un Java TreeMap pas une LinkedHashMap. Merci pour la clarification.
    InformationsquelleAutor Steve Pritchard