Arrays
Arrays in PowerShell are collections of items stored in a single variable. They are indexed starting from 0 and can hold multiple data types. For instance, you can create an array using the @() syntax, add elements dynamically, and iterate through them using loops. Arrays are commonly used to store lists of related data, such as file paths or server names. Here is an example:
# Creating an array
$array = @("apple", "banana", "cherry")
# Accessing elements
$firstItem = $array[0] # "apple"
# Adding an element
$array += "date"
# Iterating through the array
foreach ($item in $array) {
Write-Output $item
}Hash Tables
Hash tables, also called dictionaries, are collections of key-value pairs. They are ideal for associating related data, such as configuration settings or user details. For example:
# Creating a hash table
$hashTable = @{ "Name" = "John"; "Age" = 30; "City" = "New York" }
# Accessing values
$name = $hashTable["Name"]
# Adding a new key-value pair
$hashTable["Country"] = "USA"
# Iterating through the hash table
foreach ($key in $hashTable.Keys) {
Write-Output "${key}: $($hashTable[$key])"
}Lists
Lists in PowerShell, implemented through .NET’s System.Collections.Generic.List, are dynamic collections that can grow or shrink as needed. Unlike arrays, lists do not require resizing when adding or removing items. For example:
# Creating a generic list of strings$list = [System.Collections.Generic.List[string]]::new()
# Adding items to the list
$list.Add("apple")
$list.Add("banana")
$list.Add("cherry")
# Displaying the items in the list
Write-Output "Initial list contents:"
$list.ForEach({ Write-Output $_ })
# Removing an item
$list.Remove("apple")
Write-Output "`nList contents after removing 'apple':"
$list.ForEach({ Write-Output $_ })
# Checking if the list contains a specific item
$itemToCheck = "banana"
if ($list.Contains($itemToCheck)) {
Write-Output "`nThe list contains '$itemToCheck'."
} else {
Write-Output "`nThe list does not contain '$itemToCheck'."
}
# Iterating through the list with an index
Write-Output "`nIterating through the list with index:"
for ($i = 0; $i -lt $list.Count; $i++) {
Write-Output "Index $i`: $($list[$i])"
}
# Clearing the list
$list.Clear()
Write-Output "`nList contents after clearing:"
$list.ForEach({ Write-Output $_ })Lists are particularly useful when working with collections of elements that require frequent modifications.
Queues and Stacks
For scenarios involving task scheduling or managing navigation history, specialized data structures like queues and stacks are helpful. Queues follow the First-In-First-Out (FIFO) principle, while stacks follow the Last-In-First-Out (LIFO) principle. Here’s an example:
# Queue example
# Create a new queue
$queue = [System.Collections.Queue]::new()
# Enqueue items into the queue
$queue.Enqueue("Task1")
$queue.Enqueue("Task2")
$queue.Enqueue("Task3")
# Display current items in the queue
Write-Output "Items in the queue:"
$queue | ForEach-Object { Write-Output $_ }
# Dequeue the first item (FIFO - First In, First Out)
$firstTask = $queue.Dequeue()
Write-Output "`nDequeued item: $firstTask"
# Display the remaining items in the queue
Write-Output "`nItems in the queue after dequeueing:"
$queue | ForEach-Object { Write-Output $_ }# Stack example
# Create a new stack
$stack = [System.Collections.Stack]::new()
# Push items onto the stack
$stack.Push("Page1")
$stack.Push("Page2")
$stack.Push("Page3")
# Display current items in the stack
Write-Output "Items in the stack:"
$stack | ForEach-Object { Write-Output $_ }
# Pop the last item (LIFO - Last In, First Out)
$lastPage = $stack.Pop()
Write-Output "`nPopped item: $lastPage"
# Display the remaining items in the stack
Write-Output "`nItems in the stack after popping:"
$stack | ForEach-Object { Write-Output $_ }Custom Objects
Custom objects in PowerShell allow you to create complex data structures with multiple properties. These objects are highly flexible and are often used to represent structured data such as records or API responses. For example:
# Creating a custom object
$object = [PSCustomObject]@{
Name = "Alice"
Age = 28
Role = "Developer"
}
# Accessing properties
Write-Output $object.NameDataTables
DataTables, part of the .NET framework, are useful for handling tabular data and querying structured, relational information. They are particularly beneficial when working with data that resembles a database table. For instance:
# Creating a DataTable
$dataTable = New-Object System.Data.DataTable
$dataTable.Columns.Add("Name")
$dataTable.Columns.Add("Age", [System.Int32])
# Adding rows
$row = $dataTable.NewRow()
$row.Name = "Bob"
$row.Age = 35
$dataTable.Rows.Add($row)
# Displaying rows
$dataTable | ForEach-Object { Write-Output "$($_.Name) - $($_.Age)" }PowerShell offers a rich set of data structures suitable for a wide range of tasks, from simple data storage to complex data manipulation. Understanding these structures and their appropriate use cases will help you write more efficient and maintainable scripts. Experiment with these data structures to find the best fit for your automation needs!
More PowerShell posts found here.