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.

Holmes B. Mastering PowerShell Scripting. Packt Publishing; 2019.
Jones D, Hicks J. Learn PowerShell in a Month of Lunches. Manning Publications; 2016.

Microsoft. About Hash Tables. Microsoft Docs; 2021.

PowerShell Parsing HTML: Simplifying Web Data Extraction

How to Change Zabbix URL: Guide