about_Hash_Tables
Description courte
Décrit comment créer, utiliser et trier des tables de hachage dans PowerShell.
Description longue
Une table de hachage, également appelée dictionnaire ou tableau associatif, est une structure de données compacte qui stocke une ou plusieurs paires clé-valeur. Par exemple, une table de hachage peut contenir une série d’adresses IP et de noms d’ordinateurs, où les adresses IP sont les clés et les noms d’ordinateurs sont les valeurs, ou inversement.
Dans PowerShell, chaque table de hachage est un objet [System.Collections.Hashtable]. Vous pouvez utiliser les propriétés et méthodes d’objets Hashtable dans PowerShell.
À compter de PowerShell 3.0, vous pouvez utiliser l’accélérateur [ordered] de type pour créer un [System.Collections.Specialized.OrderedDictionary] objet dans PowerShell.
Les dictionnaires ordonnés diffèrent des tables de hachage dans lesquelles les clés apparaissent toujours dans l’ordre dans lequel vous les répertoriez. L’ordre des clés dans une table de hachage n’est pas déterministe.
Les clés et la valeur dans les tables de hachage sont également des objets .NET. Elles sont souvent des chaînes ou des entiers, mais elles peuvent avoir n’importe quel type d’objet. Vous pouvez également créer des tables de hachage imbriquées, dans lesquelles la valeur d’une clé est une autre table de hachage.
Les tables de hachage sont fréquemment utilisées, car elles sont efficaces pour rechercher et récupérer des données. Vous pouvez utiliser des tables de hachage pour stocker des listes et créer des propriétés calculées dans PowerShell. Et l’applet de commande ConvertFrom-StringData convertit les données de chaîne structurées en table de hachage.
Syntaxe
La syntaxe d’une table de hachage est la suivante:
@{ <name> = <value>; [<name> = <value> ] ...}
La syntaxe d’un dictionnaire ordonné est la suivante :
[ordered]@{ <name> = <value>; [<name> = <value> ] ...}
L’accélérateur de [ordered] type a été introduit dans PowerShell 3.0.
Pour créer une table de hachage, suivez ces directives:
- Commencez la table de hachage avec un signe arobase (
@). - Mettez la table de hachage entre accolades (
{}). - Saisissez une ou plusieurs paires clé-valeur pour le contenu de la table de hachage.
- Utilisez un signe égal (
=) pour séparer chaque clé de sa valeur. - Utilisez un point-virgule (
;) ou un saut de ligne pour séparer les paires clé-valeur. - Les clés qui contiennent des espaces doivent être placées entre guillemets. Les valeurs doivent être des expressions PowerShell valides. Les chaînes doivent apparaître entre guillemets, même si elles n’incluent pas d’espaces.
- Pour gérer la table de hachage, enregistrez-la dans une variable.
- Lors de l’affectation d’une table de hachage ordonnée à une variable, placez le type
[ordered]avant le symbole@. Si vous la placez avant le nom de la variable, la commande échoue.
Vous pouvez utiliser des dictionnaires ordonnés de la même façon que vous utilisez des tables de hachage. Vous pouvez utiliser l'un ou l'autre type comme valeur pour les paramètres qui acceptent des objets de type table de hachage ou dictionnaire (iDictionary).
Création de tables de hachage et de dictionnaires ordonnés
Considérez les exemples de tables de hachage et de dictionnaires ordonnés suivants :
$hash = @{
1 = 'one'
2 = 'two'
'three' = 3
}
$hash
Name Value
---- -----
three 3
2 two
1 one
Comme vous pouvez le voir, les paires clé-valeur dans une table de hachage ne sont pas présentées dans l’ordre dans lequel elles ont été définies.
Le moyen le plus simple de créer un dictionnaire ordonné consiste à utiliser l’attribut [ordered] . Placez l’attribut immédiatement avant le @ symbole.
$dictionary = [ordered]@{
1 = 'one'
2 = 'two'
'three' = 3
}
$dictionary
Name Value
---- -----
1 one
2 two
three 3
Contrairement aux tables de hachage, les dictionnaires ordonnés conservent l’ordre de la clé-valeur.
Conversion de tables de hachage et de dictionnaires ordonnés
Vous ne pouvez pas utiliser l’accélérateur de type [ordered] pour convertir ou caster une table de hachage.
Si vous placez l’attribut ordonné avant le nom de la variable, la commande échoue avec le message d’erreur suivant.
[ordered]$orderedhash = @{}
ParserError:
Line |
1 | [ordered]$orderedhash = @{}
| ~~~~~~~~~~~~~~
| The ordered attribute can be specified only on a hash literal node.
Pour corriger l’expression, déplacez l’attribut [ordonné].
$orderedhash = [ordered]@{}
Vous pouvez caster un dictionnaire ordonné en une table de hachage, mais vous ne pouvez pas garantir l’ordre des membres.
[hashtable]$newhash = [ordered]@{
Number = 1
Shape = "Square"
Color = "Blue"
}
$newhash
Name Value
---- -----
Color Blue
Shape Square
Number 1
Hashtable et propriétés de dictionnaire
Les tables de hachage et les dictionnaires ordonnés partagent plusieurs propriétés. Considérez les $hash variables et $dictionary les variables définies dans les exemples précédents.
$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;}
Les propriétés les plus utilisées sont Count, Keys, Values et Item.
Propriété Count qui indique le nombre de paires clé-valeur dans l’objet.
La propriété Keys est une collection des noms des clés dans la table de hachage ou le dictionnaire.
PS> $hash.Keys three 2 1 PS> $dictionary.Keys 1 2 threeLa propriété Values est une collection des valeurs dans la table de hachage ou le dictionnaire.
PS> $hash.Values 3 two one PS> $dictionary.Values one two 3La propriété Item est une propriété paramétrable qui retourne la valeur de l’élément que vous spécifiez. Les tables de hachage utilisent la clé comme paramètre pour la propriété paramétrable, tandis que les dictionnaires utilisent l’index par défaut. Cette différence affecte la façon dont vous accédez aux valeurs de chaque type.
Accès aux valeurs
Il existe deux façons courantes d’accéder aux valeurs d’une table de hachage ou d’un dictionnaire : notation membre ou notation d’index de tableau.
Notation de membre : les valeurs sont accessibles à l’aide du nom de clé en tant que propriété membre de l’objet. Par exemple :
PS> $hash.1 one PS> $dictionary.2 twoNotation d’index de tableau : les valeurs sont accessibles à l’aide de la notation d’index. PowerShell convertit cette notation en un appel à la propriété paramétrable Item de l’objet.
Lorsque vous utilisez la notation d’index avec des tables de hachage, la valeur à l’intérieur des crochets est le nom de clé. Si la clé est une valeur de chaîne, placez le nom de la clé entre guillemets. Par exemple :
PS> $hash['three'] 3 PS> $hash[2] twoDans cet exemple, la valeur
2de clé n’est pas un index dans la collection de valeurs. Il s’agit de la valeur de la clé dans la paire clé-valeur. Vous pouvez le prouver en indexant la collection de valeurs.PS> ([array]$hash.Values)[2] oneLorsque vous utilisez la notation d’index avec des dictionnaires, la valeur à l’intérieur des crochets est interprétée en fonction de son type. Si la valeur est un entier, elle est traitée comme un index dans la collection de valeurs. Si la valeur n’est pas un entier, elle est traitée comme le nom de clé. Par exemple :
PS> $dictionary[1] two PS> ([array]$dictionary.Values)[1] two PS> $dictionary[[object]1] one PS> $dictionary['three'] 3Dans cet exemple, la valeur
[1]du tableau est un index dans la collection de valeurs à l’aide de laItem(int index)surcharge de propriété paramétrable. La valeur[[object]1]de tableau n’est pas un index, mais une valeur clé à l’aide de laItem(System.Object key)surcharge.Remarque
Ce comportement peut être déroutant lorsque la valeur de clé est un entier. Si possible, vous devez éviter d’utiliser des valeurs de clé entière dans les dictionnaires.
Gestion des collisions de noms de propriété
Si le nom de la clé entre en collision avec l’un des noms de propriétés du type HashTable, vous pouvez utiliser le psbaseintrinsic member pour accéder à ces propriétés. Par exemple, si le nom de clé est keys et que vous souhaitez retourner la collection des clés HashTable, utilisez cette syntaxe :
$hashtable.psbase.Keys
Cette exigence s’applique aux autres types qui implémentent l’interface System.Collections.IDictionary , comme OrderedDictionary.
Itération sur les clés et les valeurs
Vous pouvez itérer sur les clés d’une table de hachage pour traiter les valeurs de plusieurs façons. Chacun des exemples de cette section a une sortie identique. Ils itèrent sur la $hash variable définie ici :
$hash = [ordered]@{Number = 1; Shape = "Square"; Color = "Blue"}
Remarque
Dans ces exemples, $hash est défini en tant que dictionnaire ordonné pour garantir que la sortie est toujours dans le même ordre. Ces exemples fonctionnent de la même façon pour les tables de hachage standard, mais l’ordre de la sortie n’est pas prévisible.
Chaque exemple retourne un message pour chaque clé et sa valeur :
The value of 'Number' is: 1
The value of 'Shape' is: Square
The value of 'Color' is: Blue
Cet exemple utilise un foreach bloc pour itérer sur les clés.
foreach ($Key in $hash.Keys) {
"The value of '$Key' is: $($hash[$Key])"
}
Cet exemple utilise ForEach-Object pour itérer sur les clés.
$hash.Keys | ForEach-Object {
"The value of '$_' is: $($hash[$_])"
}
Cet exemple utilise la GetEnumerator() méthode pour envoyer chaque paire clé-valeur via le pipeline à ForEach-Object.
$hash.GetEnumerator() | ForEach-Object {
"The value of '$($_.Key)' is: $($_.Value)"
}
Cet exemple utilise les méthodes et GetEnumerator() les ForEach() méthodes pour itérer sur chaque paire clé-valeur.
$hash.GetEnumerator().ForEach({"The value of '$($_.Key)' is: $($_.Value)"})
Ajout et suppression de clés et de valeurs
En règle générale, lorsque vous créez une table de hachage, vous incluez les paires clé-valeur dans la définition. Toutefois, vous pouvez ajouter et supprimer des paires clé-valeur d’une table de hachage à tout moment. L’exemple suivant crée une table de hachage vide.
$hash = @{}
Vous pouvez ajouter des paires clé-valeur à l’aide de la notation de tableau. Par exemple, l’exemple suivant ajoute une clé Time avec une valeur de Now à la table de hachage.
$hash["Time"] = "Now"
Vous pouvez également ajouter des clés et des valeurs à une table de hachage à l’aide de la méthode Add() de l’objet System.Collections.Hashtable. La Add() méthode a la syntaxe suivante :
Add(Key, Value)
Par exemple, pour ajouter une clé Time avec une valeur de Now à la table de hachage, utilisez le format d’instruction suivant.
$hash.Add("Time", "Now")
Vous pouvez également ajouter des clés et des valeurs à une table de hachage à l’aide de l’opérateur d’ajout (+) pour ajouter une table de hachage à une table de hachage existante. Par exemple, l’instruction suivante ajoute une clé Time avec une valeur de Now à la table de hachage dans la variable $hash.
$hash = $hash + @{Time="Now"}
Vous pouvez également ajouter des valeurs stockées dans des variables.
$t = "Today"
$now = (Get-Date)
$hash.Add($t, $now)
Vous ne pouvez pas utiliser d’opérateur de soustraction pour supprimer une paire clé-valeur d’une table de hachage, mais vous pouvez utiliser la méthode Remove() de l’objet de table de hachage. La Remove méthode a la syntaxe suivante :
$object.Remove(<key>)
L’exemple suivant supprime la Time paire clé-valeur de $hash.
$hash.Remove("Time")
Types d’objets dans HashTables
Les clés et les valeurs d’une table de hachage peuvent avoir n’importe quel type d’objet .NET, et une seule table de hachage peut avoir des clés et des valeurs de plusieurs types.
L’instruction suivante crée une table de hachage de chaînes de nom de processus et des valeurs d’objet de processus et l’enregistre dans la variable $p.
$p = @{
"PowerShell" = (Get-Process PowerShell)
"Notepad" = (Get-Process notepad)
}
Vous pouvez afficher la table de hachage dans $p et utiliser les propriétés de nom de clé pour afficher les valeurs.
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
Les clés d’une table de hachage peuvent être n’importe quel type .NET. L’instruction suivante ajoute une paire clé-valeur à la table de hachage dans la variable $p. La clé est un objet service qui représente le service WinRM et la valeur correspond à l’état actuel du service.
$p = $p + @{
(Get-Service WinRM) = ((Get-Service WinRM).Status)
}
Vous pouvez afficher et accéder à la nouvelle paire clé-valeur à l’aide des mêmes méthodes que celles que vous utilisez pour d’autres paires dans la table de hachage.
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
Les clés et les valeurs d'une table de hachage peuvent également être des objets Hashtable. L’instruction suivante ajoute une paire clé-valeur à la table de hachage dans la variable $p dans laquelle la clé est une chaîne, hash2 et la valeur est une table de hachage avec trois paires clé-valeur.
$p = $p + @{
"Hash2"= @{a=1; b=2; c=3}
}
Vous pouvez afficher et accéder aux nouvelles valeurs à l’aide des mêmes méthodes.
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
Tri des clés et des valeurs
Les éléments dans une table de hachage ne sont intrinsèquement pas ordonnés. Les paires clé-valeur peuvent apparaître dans un ordre différent chaque fois que vous les affichez.
Bien que vous ne puissiez pas trier une table de hachage, vous pouvez utiliser la méthode GetEnumerator() de hachage pour énumérer les clés et les valeurs, puis utiliser l’applet de commande Sort-Object pour trier les valeurs énumérées à afficher.
Par exemple, les commandes suivantes énumèrent les clés et les valeurs de la table de hachage dans la $p variable, puis trient les clés par ordre alphabétique.
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
La commande suivante utilise la même procédure pour trier les valeurs de hachage dans l’ordre décroissant.
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
Création d’objets à partir de tables de hachage
À compter de PowerShell 3.0, vous pouvez créer un objet à partir d’une table de hachage de propriétés et de valeurs de propriété.
La syntaxe est la suivante :
[<class-name>]@{
<property-name>=<property-value>
<property-name>=<property-value>
}
Cette méthode fonctionne uniquement pour les classes qui ont un constructeur qui n’a aucun paramètre. Les propriétés de l’objet doivent être publiques et définies.
Pour plus d’informations, consultez about_Object_Creation.
ConvertFrom-StringData
Le cmdlet ConvertFrom-StringData convertit une chaîne ou une here-string de paires clé-valeur en une table de hachage. Vous pouvez utiliser l’applet ConvertFrom-StringData de commande en toute sécurité dans la section Données d’un script, et vous pouvez l’utiliser avec l’applet Import-LocalizedData de commande pour afficher les messages utilisateur dans la culture de l’interface utilisateur (UI) de l’utilisateur actuel.
Les here-strings sont particulièrement utiles lorsque les valeurs dans la table de hachage incluent des guillemets. Pour plus d’informations sur les chaînes ici, consultez about_Quoting_Rules.
L’exemple suivant montre comment créer un here-string des messages utilisateur dans l’exemple précédent et comment utiliser ConvertFrom-StringData pour les convertir d’une chaîne en un hashtable.
La commande suivante crée une chaîne ici des paires clé-valeur, puis l’enregistre dans la $string variable.
$string = @"
Msg1 = Type "Windows".
Msg2 = She said, "Hello, World."
Msg3 = Enter an alias (or "nickname").
"@
Cette commande utilise l’applet de commande ConvertFrom-StringData pour convertir la chaîne ici en table de hachage.
ConvertFrom-StringData $string
Name Value
---- -----
Msg3 Enter an alias (or "nickname").
Msg2 She said, "Hello, World."
Msg1 Type "Windows".
Pour plus d’informations sur les chaînes ici, consultez about_Quoting_Rules.
