Hashtable in PowerShell

Hashtable in PowerShell

Understanding how to create and manage hashtables in PowerShell can streamline your scripting tasks. Whether dealing with simple key-value pairs or more complex data structures, these techniques enhance efficiency and effectiveness. Hashtables provide a powerful way to store and retrieve data, making them an essential tool in any PowerShell scripter’s arsenal.

Creating Hashtables

Creating an empty hashtable in PowerShell uses the @{} syntax:

$emptyHash = @{}

To populate it with key-value pairs at the start:


$hash = @{
FirstName = "John";
Age = 30;
City = "New York"
}

Keys can be strings or integers. If a key has spaces, enclose it in quotes:


$hash = @{
"First Name" = "Jane";
Age = 28
}

Ordered hashtables keep the order of insertion. Use the [ordered] attribute before @{}:


$orderedHash = [ordered]@{
LastName = "Smith";
FirstName = "Anna";
Department = "IT"
}

To create an empty ordered hashtable:

$orderedEmptyHash = [ordered]@{}

Adding keys and values post-creation:


$hash["NewKey"] = "NewValue"
# or
$hash.Add("AnotherKey", "AnotherValue")

For ordered hashtables, the syntax is the same:

$orderedHash["Department"] = "HR"

To display your hashtable, type the variable name:

$hash

To display all keys or values:


$hash.keys
$hash.values

Access individual elements by their key:

$hash["Age"]

Adding and Modifying Entries

To add new items or modify existing entries:


# Adding new entries through direct assignment
$hash["State"] = "California"

# Update existing key
$hash[“Age”] = 32

# Add using .Add() method
$hash.Add(“Country”, “USA”)

# Update using .Set_Item() method
$hash.Set_Item(“City”, “San Francisco”)

Note: Using .Add() on an existing key will throw an error.

To remove entries:

$hash.Remove("City")

These operations apply to both ordered and unordered hashtables.

Accessing and Iterating Over Hashtables

Access specific values using keys:

$hash["Age"]

Iterate over keys and values:

  • Using ForEach loop:

    foreach ($key in $hash.keys) {
    $keyValueMessage = "Key = $key, Value = $($hash[$key])"
    Write-Output $keyValueMessage
    }
  • Using ForEach-Object cmdlet:

    $hash.keys | ForEach-Object {
    $keyValueMessage = "Key = $_, Value = $($hash[$_])"
    Write-Output $keyValueMessage
    }
  • Using GetEnumerator() method:

    $hash.GetEnumerator() | ForEach-Object {
    $keyValueMessage = "Key = $($_.Key), Value = $($_.Value)"
    Write-Output $keyValueMessage
    }

These methods apply to both ordered and unordered hashtables.

Advanced Hashtable Operations

Nested hashtables:


$nestedHash = @{
Person = @{
Name = "Alice"
Age = 31
Address = @{
Street = "123 Main St"
City = "Queens"
ZIP = 11411
}
}
}

# Accessing nested values
$nestedHash[“Person”][“Address”][“City”] # Output: Queens

Combining hashtables:


$hash1 = @{ FirstName = "John"; LastName = "Doe" }
$hash2 = @{ Age = 45; City = "Seattle" }
$combinedHash = $hash1 + $hash2

Splatting:


$params = @{
Path = "C:Data"
Filter = "*.txt"
Recurse = $true
}
Get-ChildItem @params

Handling property name collisions:


$hashWithCollision = @{ Keys = "Value1" }
$hashWithCollision.psbase.Keys # Retrieves the collection of keys

Making deep copies:


# Shallow copy
$shallowCopy = $hash1.Clone()

# Deep copy with recursion
function Get-DeepClone {
param($InputObject)
if ($InputObject -is [hashtable]) {
$clone = @{}
foreach ($key in $InputObject.Keys) {
$clone[$key] = Get-DeepClone $InputObject[$key]
}
return $clone
} else {
return $InputObject
}
}
$deepCopy = Get-DeepClone $nestedHash

Ordered dictionaries:


$orderedHash = [ordered]@{
First = 1
Second = 2
Third = 3
}

Persisting Hashtables

Saving hashtables to CSV:


$hash = @{
Name = "Alice"
Age = 30
City = "New York"
}
$hash | ForEach-Object { [pscustomobject]$_ } | Export-Csv -Path "C:pathtofile.csv" -NoTypeInformation

Re-importing from CSV:


$importedHash = @{}
Import-Csv -Path "C:pathtofile.csv" | ForEach-Object {
$importedHash[$_.Name] = $_.Age
}

Saving to JSON:


$hash | ConvertTo-Json | Set-Content -Path "C:pathtofile.json"

Re-importing from JSON:


$jsonString = Get-Content -Path "C:pathtofile.json" -Raw
$importedHash = $jsonString | ConvertFrom-Json

Using XML for complex data:


# Export
$hash | Export-CliXml -Path "C:pathtofile.xml"

# Import
$importedHash = Import-CliXml -Path “C:pathtofile.xml”

By mastering these techniques, you can efficiently manage complex data structures in PowerShell, enhancing your scripting capabilities and productivity.

  1. Holmes B. Mastering PowerShell Scripting. Packt Publishing; 2019.
  2. Jones D, Hicks J. Learn PowerShell in a Month of Lunches. Manning Publications; 2016.
  3. Microsoft. About Hash Tables. Microsoft Docs; 2021.

PowerShell Parsing HTML: Simplifying Web Data Extraction

How to Change Zabbix URL: Guide