Hashtable in PowerShell

Getting your Trinity Audio player ready...

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

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.

Join us on dev community