Een Beginner’s Gids voor het Gebruiken van PowerShell Hashtable – techsyncer

Bij het voor het eerst tegenkomen van hashtabellen, vraag je je misschien af wat ze zijn en hoe ze een cruciale rol spelen in je scripts of commando’s. Maak je geen zorgen! Deze tutorial behandelt alles om aan de slag te gaan met het gebruik van PowerShell hashtabellen.

Kortom, hashtabellen stellen je in staat om gegevens op te slaan en te manipuleren met behulp van sleutel-waardeparen, die snel en efficiënt kunnen worden benaderd. En in deze tutorial leer je de basisprincipes van hashtabellen en hoe je ze kunt gebruiken voor je PowerShell-scripts en -commando’s.

Lees verder en begin je vaardigheden uit te breiden met PowerShell hashtabellen!

Vereisten

Deze tutorial zal een praktische demonstratie zijn. Zorg ervoor dat je een systeem hebt met PowerShell v5+ geïnstalleerd en geconfigureerd om mee te doen. Deze tutorial gebruikt Windows 10 met PowerShell 7, maar andere versies van PowerShell en Windows zullen ook werken.

Het maken van een PowerShell-hashtable

Het ophalen van specifieke gegevens kan op een gegeven moment veranderen in “zoeken naar een speld in een hooiberg” situatie. Maar met hashtabellen kun je snel specifieke items zoeken in een uitgebreide gegevensverzameling.

In PowerShell zijn hashtabellen flexibele gegevensstructuren die op veel manieren worden gebruikt, zoals het opslaan van configuratiegegevens, het doorgeven van argumenten aan cmdlets en het opslaan van gegevens in een script.

Om te zien hoe een PowerShell-hashtable werkt, moet je er eerst een maken als volgt:

1. Open een PowerShell-sessie en voer de volgende opdracht uit, die geen uitvoer genereert maar een variabele genaamd name declareert om te verwijzen naar een lege hashtable.

Zoals hieronder te zien is, worden hashtables in PowerShell op een vergelijkbare manier gedefinieerd als arrays, met het symbool @.

$name = @{}

2. Voer vervolgens de onderstaande opdracht uit om het type van de variabele name te controleren (GetType()).

$name.GetType()

Het type van de variabele name is Hashtable, zoals hieronder weergegeven. Deze informatie bevestigt dat je hashtable succesvol is aangemaakt.

3. Na het controleren van je hashtable, voer de volgende code uit om te controleren of de hashtable leeg is of niet.

De onderstaande code bepaalt of de Count-eigenschap gelijk is aan (-eq) aan 0, en geeft een overeenkomstige boodschap weer.

# Vergelijk of de waarde van de Count-eigenschap gelijk is aan 0 (-eq)
if ($name.Count -eq 0) {
	# Als dat het geval is, print dan de onderstaande boodschap.
  Write-Output "The hashtable is empty."
} else {
	# Anders, print de onderstaande boodschap in plaats daarvan.
  Write-Output "The hashtable is not empty."
}

Onderstaand zie je dat de hashtable leeg is, aangezien je deze zojuist hebt aangemaakt, en er geen sleutel-waardeparen zijn gedefinieerd.

Checking if the hashtable is empty or not

Items toevoegen aan een PowerShell-hashtable

Je hebt zojuist een praktisch lege PowerShell-hashtable gemaakt, die alleen nuttig wordt als je items toevoegt. Hoe? Door sleutel-waardeparen aan de hashtable toe te voegen.

Vergelijkbaar met een array, maar in plaats van integers als indices te gebruiken, gebruikt een PowerShell-hashtable sleutels (die elk gegevenstype kunnen zijn) om de waarden te identificeren. Deze functie maakt snelle invoeging, ophaling en verwijdering van items uit de hashtable mogelijk, omdat de sleutel snel de overeenkomstige waarde lokaliseert.

Hieronder staat de syntaxis voor het toevoegen van een sleutel-waardepaar aan een PowerShell-hashtable, waarbij:

$hashtable – De naam van de hashtable.
$key – De naam van de sleutel, die hoofdletteronafhankelijk is. Bijvoorbeeld, “Voornaam” en “voornaam” zouden als dezelfde sleutel worden beschouwd in een hashtable
$value – De waarde die aan de sleutel moet worden gekoppeld.

$hashtable[$key] = $value

Voer de volgende code uit, die geen uitvoer naar de console genereert maar sleutel-waardeparen declareert en deze aan je hashtable ($naam) toevoegt.

In een hashtable stelt de sleutel je in staat om een hashfunctie uit te voeren, die de sleutel toewijst aan een specifieke locatie in de interne datastructuur van de hashtable.

? Hashtable-waarden kunnen elk type zijn, zoals getallen, strings, arrays, objecten en andere datatypes als waarden in een hashtable.

# Declareren van de sleutel Voornaam
$key = "FirstName"
# De waarde van de sleutel declareren
$value = "John"
# Het item toevoegen aan de hashtable
$name[$key] = $value

# Declareren van de sleutel Achternaam
$key = "LastName"
# De waarde van de sleutel declareren
$value = "Doe"
# Het item toevoegen aan de hashtable
$name[$key] = $value

Voer nu de onderstaande code opnieuw uit om te controleren of je hashtable leeg is.

if ($name.Count -eq 0) {
  Write-Output "The hashtable is empty."
} else {
  Write-Output "The hashtable is not empty."
}

Zoals hieronder getoond, ontvang je deze keer een bericht dat de hashtable niet leeg is.

Items ophalen uit een PowerShell-hashtable

Stel dat je er zeker van bent dat je hashtable niet leeg is. Hoe weet je welke items er in je hashtable bestaan? Gelukkig kun je ook items uit je hashtable ophalen.

Voer de onderstaande code uit om alle items uit je hashtable op te halen en uit te voeren (Write-Output) in sleutel-waardeparen, één per regel.`

# Itereert door alle sleutel-waardeparen in de hashtable
foreach ($key in $name.Keys) {
	$value = $name[$key]
  # Geeft alle sleutel-waardeparen in de hashtable uit, één per regel.
	Write-Output "${key}: ${value}"
}

Retrieving items from a PowerShell hashtable

Voer nu de onderstaande code uit om alle items in een hashtable op te halen en af te drukken (Write-Output) naar de console.

? Merk op dat je vaak de volgende code zult gebruiken tijdens deze tutorial. Je kunt het kopiëren en plakken van dezelfde code meerdere keren vermijden door een functie te maken, maar dat valt buiten de reikwijdte van deze tutorial.

# Ontvang een object dat kan worden gebruikt om over de elementen van een verzameling te itereren.
$enumerator = $name.GetEnumerator()
foreach ($element in $enumerator) {
	# Geeft een string terug die de sleutel en de waarde van elk element in de verzameling bevat.
	Write-Output "Key: $($element.Key), Value: $($element.Value)"
}

Deze keer zie je aanwijzingen welke de sleutels en waarden zijn tussen de vermelde items.

Retrieving items from a PowerShell hashtable, indicating which are the keys and value pairs

Hashtables maken met vooraf gedefinieerde waarden

Tot nu toe heb je alleen gekeken naar het maken van lege hashtables. Maar als je weet dat bepaalde waarden altijd nodig zullen zijn in je hashtable, kun je er een maken met vooraf gedefinieerde waarden.

Hashtables met vooraf gedefinieerde waarden kunnen je tijd besparen en je code efficiënter maken, omdat je de waarden niet later aan de hashtable hoeft toe te voegen.

? Merk op dat het maken van hashtables geen uitvoer oplevert. Maar geen zorgen. In deze tutorial controleer je elke hashtable na de creatie.

1. Voer de onderstaande opdracht uit om een hashtable ($hashtable1) te maken met drie sleutel-waardeparen.

$hashtable1 = @{
  "Key1" = "Value1"
  "Key2" = "Value2"
  "Key3" = "Value3"
}

2. Voer vervolgens de volgende code uit om te controleren of de nieuwe hashtable (hashtable1) bestaat.

# Krijg een object dat kan worden gebruikt om te itereren over de elementen van een verzameling.
$enumerator = $hashtable1.GetEnumerator()
foreach ($element in $enumerator) {
  # Geeft een string terug die de sleutel en de waarde van elk element in de verzameling bevat.
	Write-Output "Key: $($element.Key), Value: $($element.Value)"
}

Je zult zien dat de waarden voor elk sleutel-waardepaar zoals verwacht op het scherm worden afgedrukt. Deze uitvoer bevestigt dat de vooraf gedefinieerde waarden op de juiste plaatsen in de hashtable zijn opgeslagen.

Verifying that hashtable was created successfully with predefined values

3. Voer nu de onderstaande code uit om een hashtable ($hashtable2) met vooraf gedefinieerde waarden te maken met behulp van een lus (of een array).

$keys = "Key1", "Key2", "Key3"
$values = "Value1", "Value2", "Value3"
$hashtable2 = @{}
for ($i = 0; $i -lt $keys.Count; $i++) {
  $hashtable2[$keys[$i]] = $values[$i]
}

4. Voer tot slot de onderstaande code uit om te verifiëren dat de nieuwe hashtable (hashtable2) succesvol is aangemaakt.

# Krijg een object dat kan worden gebruikt om te itereren over de elementen van een verzameling.
$enumerator = $hashtable2.GetEnumerator()
foreach ($element in $enumerator) {
	# Geeft een string terug die de sleutel en de waarde van elk element in de verzameling bevat.
	Write-Output "Key: $($element.Key), Value: $($element.Value)"
}

De uitvoer hieronder bevestigt dat de lusmethode werkt bij het maken van een hashtable met vooraf gedefinieerde waarden. Maar omdat de items willekeurig worden vermeld, ga naar het volgende gedeelte voor een oplossing.

Verifying the new hashtable was created successfully

Het maken van een Geordende Lijst van Items in Hashtables

Standaard worden de items in een hashtable op geen enkele specifieke volgorde opgeslagen. Maar wat als je een geordende lijst nodig hebt? Je kunt ook een geordende lijst van items in je hashtables maken om gegevens in een specifieke volgorde te rangschikken.

Om een geordende lijst van items in je hashtable te maken, gebruik je het [ordered]-attribuut als volgt:

1. Voer de volgende code uit om een geordende lijst van items in een hashtable ($hashtable3) te maken.

$hashtable3 = [ordered]@{
"Key1" = "Value3"
"Key2" = "Value2"
"Key3" = "Value1"
}

2. Voer vervolgens de volgende code uit om te verifiëren dat de geordende lijst van hashtables succesvol is aangemaakt.

# Verkrijg een object dat kan worden gebruikt om te itereren over de elementen van een verzameling.
$enumerator = $hashtable3.GetEnumerator()
foreach ($element in $enumerator) {
	# Geeft een string terug die de sleutel en waarde van elk element in de verzameling bevat.
	Write-Output "Key: $($element.Key), Value: $($element.Value)"
}

Zoals hieronder weergegeven, blijven de vermelde items in de volgorde waarin u ze hebt gedefinieerd toen u de hashtable aanmaakte.

Enkele mogelijke voordelen van het gebruik van een geordende hashtable zijn onder andere:

Benefits	Description
Easier to read and debug	The elements are displayed in a predictable order, which can be especially useful if you work with many elements of a large hashtable.
Improved performance	An ordered hashtable can be more efficient when accessing elements frequently in a specific order.

Verifying that the ordered list of hashtables has been created

3. Als laatste, roep uw geordende hashtable ($hashtable3) aan om verder te bevestigen dat u nog steeds een geordende lijst van items krijgt.

$hashtable3

De onderstaande uitvoer bevestigt dat u nog steeds een geordende lijst van items krijgt, ongeacht hoe u uw hashtable benadert.

Verifying the list of items is still in an ordered format

Bestaande items bijwerken in hashtables

Gegevens veranderen voortdurend en als u bestaande hashtables heeft, is het bijwerken ervan een cruciale taak. Bijvoorbeeld, u gebruikt een hashtable om configuratiewaarden op te slaan. Als dat het geval is, moet u mogelijk de waarde van een sleutel bijwerken als de configuratie verandert.

Om een PowerShell hashtable bij te werken, zal de = toewijzingsoperator het trucje doen zoals volgt:

1. Voer de onderstaande opdracht uit, die geen uitvoer geeft, maar de waarde van de sleutel Key2 in $hashtable3 bijwerkt naar NewValue2.

$hashtable3["Key2"] = "NewValue2"

Volgende, voer de onderstaande opdracht uit om een nieuw sleutel-waardepaar (Key4 = NewValue4) toe te voegen aan de hashtable ($hashtable3).

Het toevoegen van een nieuw sleutel-waardepaar geeft geen uitvoer zoals bij het bijwerken van bestaande lijsten in hashtables, maar je zult de wijzigingen in de volgende stap verifiëren.

$hashtable3.Add("Key4", "NewValue4")

3. Voer de volgende code uit om te controleren of de waarden van de sleutels in je hashtable ($hashtable3) zijn bijgewerkt.

# Ontvang een object dat kan worden gebruikt om over de elementen van een collectie te itereren.
$enumerator = $hashtable3.GetEnumerator()
foreach ($element in $enumerator) {
	# Geeft een string uitvoer die de sleutel en waarde van elk element in de collectie bevat.
	Write-Output "Key: $($element.Key), Value: $($element.Value)"
}

Verifying the key values have been updated

? In PowerShell moet elke sleutel in een hashtable uniek zijn. Als je probeert een sleutel-waardepaar toe te voegen dat al in de hashtable staat, krijg je een foutmelding zoals hieronder. Om deze fout te vermijden, ga naar de volgende stap.

4. Voer nu de volgende code uit, die de Contains()-methode gebruikt om te controleren of de sleutel die je probeert toe te voegen al in de hashtable bestaat voordat je het sleutel-waardepaar toevoegt.

# Definieer de variabele om de nieuwe sleutel vast te houden
$newkey="Key5"
# Controleer of $newkey al in de hashtable bestaat.
if (-not $hashtable3.Contains($newkey)) {
	# Voeg zo nodig het nieuwe sleutel-waardepaar toe.
	$hashtable3.Add($newkey, "NewValue5")
	Write-Output "The new key '$newkey' has been added to the hashtable."
} else {
	# Als de sleutel bestaat, druk dan een bericht af.
	Write-Output "The key '$newkey' already exists."
}

Als de nieuwe sleutel niet bestaat, krijg je het onderstaande bericht waarin staat dat de nieuwe sleutel aan de hashtable is toegevoegd.

Checking if a key exists before adding it to the hashtable

Anderzijds, zoals hieronder getoond, krijg je een bericht als de sleutel die je probeert al bestaat.

5. Ten slotte, voer de onderstaande code opnieuw uit om alle items in je hashtable ($hashtable3) op te halen.

# Ontvang een object dat kan worden gebruikt om te itereren over de elementen van een collectie.
$enumerator = $hashtable3.GetEnumerator()
foreach ($element in $enumerator) {
	# Geeft een string terug die de sleutel en waarde van elk element in de collectie bevat.
	Write-Output "Key: $($element.Key), Value: $($element.Value)"
}

Hieronder zie je de nieuw toegevoegde sleutel (Key5) en andere items die je tot nu toe aan de hashtable hebt toegevoegd.

Checking all items listed in a hashtable

Items verwijderen uit een Hashtable

Te veel items in een hashtable, vooral onnodige, kunnen alleen maar tot verwarring leiden. Het verwijderen van items die niet langer relevant of nodig zijn uit je hashtable zal je helpen.

Stel dat je hashtable een lijst bevat van gebruikers en hun informatie. Als dat zo is, verwijder dan gebruikers uit je hashtable als ze niet langer actief zijn.

Voer de onderstaande code uit om een specifiek item (Key1) uit je hashtable ($hashtable3) te verwijderen.

$key = "Key5"
if ($hashtable3.Contains($key)) {
  $hashtable3.Remove($key)
  Write-Output "The key-value pair with the key '$key' was removed from the hashtable."
} else {
  Write-Output "The key-value pair with the key '$key' was not found in the hashtable."
}

Hieronder wordt de uitvoer afgedrukt met een bericht dat de sleutel is verwijderd. Maar als de sleutel niet bestaat, krijg je een bericht dat de sleutel niet is gevonden.

Voer nu de volgende code uit om alle items in je hashtable te controleren en te verifiëren of het item succesvol is verwijderd.

# Ontvang een object dat kan worden gebruikt om te itereren over de elementen van een collectie.
$enumerator = $hashtable3.GetEnumerator()
foreach ($element in $enumerator) {
	# Geeft een string terug die de sleutel en waarde van elk element in de collectie bevat.
	Write-Output "Key: $($element.Key), Value: $($element.Value)"
}

Onderstaand kunt u verifiëren dat het sleutel-waardepaar met de sleutel ‘Key5’ niet langer bestaat in uw hashtable.

Conclusie

Met een sleutel-waardepaarstructuur en snelle toegang is een PowerShell-hashtable goed geschikt voor het beheren van grote hoeveelheden gegevens in verschillende scenario’s. En in deze tutorial hebt u geleerd hoe u items aan hashtables kunt toevoegen, bijwerken en verwijderen. Dit geeft u de vaardigheden om hashtables effectief te gebruiken in uw scripts.

Waarom brengt u uw recent verworven vaardigheden niet naar een hoger niveau? Overweeg hashtables op te nemen in uw scripts voor meer geavanceerde taken, zoals gegevensmanipulatie en transformatie. Of experimenteer met het combineren van hashtables met andere gegevens structuren in PowerShell, zoals arrays en objecten, om complexere problemen op te lossen?