about_Hash_Tables
Description courte
Décrit comment créer, utiliser et trier des tables de hachage dans PowerShell.
Description longue
Un hashtabletableau associatif ou dictionnaire 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, chacun hashtable est un [System.Collections.Hashtable] objet. 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 un hashtable 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 hashtable.
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 ConvertFrom-StringData de commande convertit les données de chaîne structurées en un hashtable.
Syntaxe
La syntaxe d’un hashtable 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 un hashtable, suivez ces instructions :
- Commencez par hashtable un signe (
@). - Placez les hashtable accolades (
{}). - Entrez une ou plusieurs paires clé-valeur pour le contenu du hashtable.
- 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 le , enregistrez-le hashtabledans une variable.
- Lors de l’affectation d’une variable ordonnée hashtable , placez le
[ordered]type 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 des paramètres qui prennent des hashtable objets de type dictionnaire (iDictionaryou dictionnaire).
Création de tables de hachage et de dictionnaires ordonnés
Tenez compte des exemples de dictionnaires suivants hashtable et ordonnés :
$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 un hashtable 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 [ordered] type pour convertir ou convertir un hashtable.
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 convertir un dictionnaire ordonné en un hashtable, 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 de clés dans le ou le hashtable dictionnaire.
PS> $hash.Keys three 2 1 PS> $dictionary.Keys 1 2 threeLa propriété Values est une collection des valeurs dans le ou le hashtable 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’un ou d’un hashtable 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] 2Dans 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 clé entre en collision avec l’un des noms de propriété du HashTable type, vous pouvez utiliser le membre intrinsèque psbase pour accéder à ces propriétés. Par exemple, si le nom de clé est keys et que vous souhaitez retourner la collection des HashTable clés, 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 hashtable manière à 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 ForEach() les GetEnumerator() 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 hashtable paire clé-valeur dans la définition. Toutefois, vous pouvez ajouter et supprimer des paires clé-valeur à tout hashtable moment. L’exemple suivant crée un fichier vide hashtable.
$hash = @{}
Vous pouvez ajouter des paires clé-valeur à l’aide de la notation de tableau. Par exemple, l’exemple suivant ajoute une Time clé avec une valeur de Now .hashtable
$hash["Time"] = "Now"
Vous pouvez également ajouter des clés et des valeurs à une hashtable utilisation de la Add() méthode de l’objet System.Collections.Hashtable . La Add() méthode a la syntaxe suivante :
Add(Key, Value)
Par exemple, pour ajouter une Time clé avec une valeur à Now l’instruction hashtable, utilisez le format d’instruction suivant.
$hash.Add("Time", "Now")
Vous pouvez également ajouter des clés et des valeurs à l’aide hashtable de l’opérateur d’ajout (+) pour ajouter un hashtable à un élément existant hashtable. Par exemple, l’instruction suivante ajoute une Time clé avec une valeur de Now la hashtable $hash variable.
$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 Remove() méthode de l’objet hashtable . 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’un hashtable objet .NET peuvent avoir n’importe quel type d’objet .NET, et un seul hashtable peut avoir des clés et des valeurs de plusieurs types.
L’instruction suivante crée une hashtable chaîne de nom de processus et des valeurs d’objet de processus et l’enregistre dans la $p variable.
$p = @{
"PowerShell" = (Get-Process PowerShell)
"Notepad" = (Get-Process notepad)
}
Vous pouvez afficher les hashtable propriétés de $p nom de clé et les utiliser 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’un hashtable fichier peuvent être n’importe quel type .NET. L’instruction suivante ajoute une paire clé-valeur à la hashtable $p variable. 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 le hashtable.
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’un hashtable objet peuvent également être Hashtable des objets. L’instruction suivante ajoute une paire clé-valeur à la hashtable $p variable dans laquelle la clé est une chaîne, hash2 et la valeur est une hashtable paire clé-valeur 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 d’un objet hashtable sont intrinsèquement non 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 un hashtable, vous pouvez utiliser la GetEnumerator() méthode de hachage pour énumérer les clés et les valeurs, puis utiliser l’applet Sort-Object de commande pour trier les valeurs énumérées pour l’affichage.
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 hashtable valeur de propriétés et de propriétés.
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
L’applet ConvertFrom-StringData de commande convertit une chaîne ou une chaîne ici de paires clé-valeur en un hashtable. 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 chaînes ici sont particulièrement utiles lorsque les valeurs des hashtable guillemets include sont particulièrement utiles. Pour plus d’informations sur les chaînes ici, consultez about_Quoting_Rules.
L’exemple suivant montre comment créer une chaîne ici des messages utilisateur dans l’exemple précédent et comment les utiliser ConvertFrom-StringData pour les convertir d’une chaîne en une 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 ConvertFrom-StringData de commande pour convertir la chaîne ici en un hashtable.
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.
