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

Arsalan Malik is a passionate Software Engineer and the Founder of Makemychance.com. A proud CDAC-qualified developer, Arsalan specializes in full-stack web development, with expertise in technologies like Node.js, PHP, WordPress, React, and modern CSS frameworks.
He actively shares his knowledge and insights with the developer community on platforms like Dev.to and engages with professionals worldwide through LinkedIn.
Arsalan believes in building real-world projects that not only solve problems but also educate and empower users. His mission is to make technology simple, accessible, and impactful for everyone.