Variables and Data Types

The Script That Finally Made Sense

Early in my PowerShell journey, I wrote scripts that looked like this:

Get-Service -Name "wuauserv" | Stop-Service
Get-Service -Name "wuauserv" | Start-Service
Get-Service -Name "wuauserv" | Select-Object Status

I was calling Get-Service three times for the same service. A colleague glanced at my screen and said, "You know you can store that in a variable, right?"

$service = Get-Service -Name "wuauserv"
$service | Stop-Service
$service | Start-Service
$service.Status

That simple change saved processing time and made the code readable. More importantly, it taught me that variables aren't just storage - they're essential for writing maintainable scripts.

Understanding Variables

Variables store data for later use. In PowerShell, variables start with $ and can hold any type of data.

Creating Variables

# Simple assignment
$name = "PowerShell"
$number = 42
$date = Get-Date
$processes = Get-Process

# Variables can be reassigned
$count = 1
$count = 100
$count = "Now I'm a string"  # PowerShell is dynamically typed

Variable Names

# Valid variable names
$server
$Server1
$server_name
$ServerName  # Recommended: PascalCase for readability

# Invalid variable names (will cause errors)
$1server     # Can't start with number
$server-name # Hyphens not allowed

# For special characters, use braces
${server-name} = "SERVER01"
${my variable} = "value"

Naming Best Practices

From experience, good variable names make maintenance easier:

# Bad - unclear
$s = Get-Service
$x = 100
$temp = Get-Process

# Good - descriptive
$criticalServices = Get-Service -Name "wuauserv", "W32Time"
$maxRetries = 100
$runningProcesses = Get-Process | Where-Object {$_.CPU -gt 10}

PowerShell Data Types

PowerShell is dynamically typed but supports explicit type declaration.

Common Data Types

# String
$text = "Hello, PowerShell"
$text.GetType()  # System.String

# Integer
$count = 42
$count.GetType()  # System.Int32

# Double (decimal)
$price = 99.99
$price.GetType()  # System.Double

# Boolean
$isActive = $true
$isDisabled = $false

# DateTime
$now = Get-Date
$now.GetType()  # System.DateTime

# Array
$servers = @("SERVER01", "SERVER02", "SERVER03")
$servers.GetType()  # System.Object[]

# Hashtable
$config = @{
    Server = "SERVER01"
    Port = 8080
    Enabled = $true
}
$config.GetType()  # System.Collections.Hashtable

Type Checking

# Check type
$number = 42
$number.GetType().Name  # Int32

# Check if variable is specific type
$number -is [int]      # True
$number -is [string]   # False

# Type comparison
$text = "123"
$text -is [string]     # True
$text -is [int]        # False

Explicit Type Declaration

# Declare variable type
[string]$name = "PowerShell"
[int]$count = 42
[datetime]$birthday = "1990-01-15"
[bool]$isActive = $true

# Type enforcement prevents wrong assignments
[int]$number = "123"    # Works - PowerShell converts string to int
[int]$number = "abc"    # Error - can't convert to int

Type Conversion

# Implicit conversion
$result = "100" + "200"  # "100200" (string concatenation)
$result = 100 + 200      # 300 (numeric addition)

# Explicit conversion (casting)
[int]"123"               # 123
[string]123              # "123"
[datetime]"2024-01-15"   # DateTime object

# Convert cmdlets
"123" | ConvertTo-Json   # JSON string
Get-Process | ConvertTo-Csv  # CSV format

Working with Strings

Strings are ubiquitous in scripting.

String Creation

# Single quotes - literal strings
$single = 'Server: $env:COMPUTERNAME'  # Literal: Server: $env:COMPUTERNAME

# Double quotes - variable expansion
$double = "Server: $env:COMPUTERNAME"  # Expands: Server: DESKTOP-ABC123

# Here-strings for multi-line
$message = @"
This is line 1
This is line 2
Variables expand: $env:USERNAME
"@

# Literal here-string
$literal = @'
Everything is literal: $env:USERNAME
No variable expansion
'@

String Operations

# Concatenation
$first = "Power"
$second = "Shell"
$combined = $first + $second  # PowerShell
$combined = "$first$second"   # PowerShell (using expansion)

# String formatting
$name = "John"
$age = 30
$message = "$name is $age years old"
$message = "{0} is {1} years old" -f $name, $age  # Format operator

# String methods
$text = "PowerShell"
$text.ToUpper()              # POWERSHELL
$text.ToLower()              # powershell
$text.Length                 # 10
$text.Substring(0, 5)        # Power
$text.Replace("Shell", "Core")  # PowerCore
$text.Contains("Shell")      # True
$text.StartsWith("Power")    # True
$text.EndsWith("Shell")      # True
$text.Split("e")             # Pow rSh ll

String Comparison

# Case-insensitive (default)
"PowerShell" -eq "powershell"  # True

# Case-sensitive
"PowerShell" -ceq "powershell"  # False
"PowerShell" -ceq "PowerShell"  # True

# Pattern matching
"PowerShell" -like "*Shell"     # True
"PowerShell" -like "Power*"     # True
"PowerShell" -match "^Power.*"  # True (regex)

Arrays

Arrays store multiple values in a single variable.

Creating Arrays

# Array literal
$servers = @("SERVER01", "SERVER02", "SERVER03")

# Implicit array
$numbers = 1, 2, 3, 4, 5

# Empty array
$empty = @()

# Range operator
$range = 1..10  # Array of 1 through 10

# Array from command output
$processes = Get-Process

Accessing Array Elements

$servers = @("SERVER01", "SERVER02", "SERVER03")

# Index access (0-based)
$servers[0]      # SERVER01
$servers[1]      # SERVER02
$servers[-1]     # Last element: SERVER03
$servers[-2]     # Second to last: SERVER02

# Multiple elements
$servers[0,2]    # SERVER01, SERVER03
$servers[0..2]   # First three elements

Array Operations

# Count
$servers.Count   # 3
$servers.Length  # 3

# Add elements (creates new array)
$servers = $servers + "SERVER04"
$servers += "SERVER05"

# Remove elements (filter)
$servers = $servers | Where-Object {$_ -ne "SERVER02"}

# Check if element exists
$servers -contains "SERVER01"  # True
"SERVER01" -in $servers        # True

# Join array into string
$servers -join ", "  # SERVER01, SERVER02, SERVER03

Iterating Arrays

# ForEach loop
foreach ($server in $servers) {
    Write-Host "Processing $server"
}

# ForEach-Object (pipeline)
$servers | ForEach-Object {
    Write-Host "Processing $_"
}

# For loop
for ($i = 0; $i -lt $servers.Count; $i++) {
    Write-Host "Processing $($servers[$i])"
}

Array Type

# Strongly-typed array
[string[]]$names = @("Alice", "Bob", "Charlie")
$names += "David"        # Works
$names += 123            # Converts to string "123"

[int[]]$numbers = @(1, 2, 3)
$numbers += 4            # Works
$numbers += "five"       # Error - can't convert

Hashtables

Hashtables store key-value pairs (like dictionaries in Python).

Creating Hashtables

# Basic hashtable
$server = @{
    Name = "SERVER01"
    IP = "192.168.1.100"
    OS = "Windows Server 2022"
    Status = "Online"
}

# Empty hashtable
$config = @{}

# Ordered hashtable (maintains insertion order)
$ordered = [ordered]@{
    First = 1
    Second = 2
    Third = 3
}

Accessing Hashtable Values

# Dot notation
$server.Name     # SERVER01
$server.IP       # 192.168.1.100

# Bracket notation
$server["Name"]  # SERVER01
$server["IP"]    # 192.168.1.100

# Get all keys
$server.Keys

# Get all values
$server.Values

Modifying Hashtables

# Add new key-value
$server.Location = "Data Center 1"
$server["Owner"] = "IT Team"

# Modify existing value
$server.Status = "Maintenance"

# Remove key-value
$server.Remove("Location")

# Check if key exists
$server.ContainsKey("Name")  # True
$server.ContainsKey("Age")   # False

Iterating Hashtables

# Iterate over keys
foreach ($key in $server.Keys) {
    Write-Host "$key = $($server[$key])"
}

# Iterate with GetEnumerator
$server.GetEnumerator() | ForEach-Object {
    Write-Host "$($_.Key) = $($_.Value)"
}

Real-World Hashtable Use

Configuration management:

$appConfig = @{
    Database = @{
        Server = "DB01"
        Port = 1433
        Name = "ProductionDB"
    }
    API = @{
        BaseUrl = "https://api.example.com"
        Timeout = 30
        ApiKey = "***encrypted***"
    }
    Features = @{
        EnableLogging = $true
        EnableCache = $true
        MaxRetries = 3
    }
}

# Access nested values
$appConfig.Database.Server
$appConfig.API.BaseUrl
$appConfig.Features.EnableLogging

Automatic Variables

PowerShell provides built-in variables:

# Current object in pipeline
$_  # or $PSItem

# Boolean values
$true
$false

# Null value
$null

# Home directory
$HOME

# Current user
$env:USERNAME

# Computer name
$env:COMPUTERNAME

# PowerShell version
$PSVersionTable

# Last exit code
$LASTEXITCODE

# Error information
$Error       # Array of errors
$Error[0]    # Most recent error

# Command history
$history

Variable Scope

Variables have different scopes determining where they're accessible.

Scope Levels

# Global scope - available everywhere
$global:ServerName = "SERVER01"

# Script scope - available within script file
$script:ConfigPath = "C:\Config"

# Local scope - current scope only (default)
$LocalVariable = "value"

# Function scope example
function Test-Scope {
    $localVar = "I'm local to this function"
    $script:scriptVar = "I'm accessible in the entire script"
    $global:globalVar = "I'm accessible everywhere"
}

Scope Inheritance

$parentVar = "I'm in parent scope"

function Test-Child {
    # Can read parent scope
    Write-Host $parentVar  # Works
    
    # Modifying creates new local variable
    $parentVar = "Changed"
    Write-Host $parentVar  # Shows "Changed"
}

Test-Child
Write-Host $parentVar  # Still shows "I'm in parent scope"

Real-World Examples

Configuration Management

# Central configuration
$config = @{
    Environment = "Production"
    Servers = @("WEB01", "WEB02", "WEB03")
    Database = @{
        Server = "SQLPROD01"
        Port = 1433
    }
    Settings = @{
        MaxRetries = 3
        Timeout = 30
        EnableLogging = $true
    }
}

# Use configuration
foreach ($server in $config.Servers) {
    Write-Host "Deploying to $server..."
    # Deployment logic
}

if ($config.Settings.EnableLogging) {
    Write-Host "Logging enabled"
}

Data Collection and Reporting

$report = @{
    GeneratedDate = Get-Date
    GeneratedBy = $env:USERNAME
    Servers = @()
}

$servers = @("SERVER01", "SERVER02", "SERVER03")

foreach ($server in $servers) {
    $serverInfo = @{
        Name = $server
        Pingable = Test-Connection -ComputerName $server -Count 1 -Quiet
        CPUs = 0
        MemoryGB = 0
    }
    
    if ($serverInfo.Pingable) {
        $serverInfo.CPUs = (Get-WmiObject -ComputerName $server -Class Win32_Processor).Count
        $serverInfo.MemoryGB = [math]::Round((Get-WmiObject -ComputerName $server -Class Win32_ComputerSystem).TotalPhysicalMemory / 1GB, 2)
    }
    
    $report.Servers += $serverInfo
}

$report | ConvertTo-Json -Depth 3 | Out-File "ServerReport.json"

Common Pitfalls

1. Uninitialized Variables

Problem: Using variables before assigning values Solution: Always initialize variables

# Bad
$total = $count + 10  # $count is $null, result is 10

# Good
$count = 0
$total = $count + 10  # Clear intent

2. Variable Scope Confusion

Problem: Expecting variable changes to persist Solution: Understand scope levels

function Set-Value {
    $myVar = "Changed"  # Local to function
}

$myVar = "Original"
Set-Value
$myVar  # Still "Original" - use $script: or $global: if needed

3. Array Mutation Confusion

Problem: Thinking += modifies array Solution: Remember += creates new array

# Each += creates a new array
$array = @()
$array += 1  # Creates new array
$array += 2  # Creates another new array

4. Hashtable Key Case Sensitivity

Problem: Hashtable keys are case-insensitive by default Solution: Be aware of this behavior

$hash = @{Name = "Value"}
$hash.name  # Works
$hash.NAME  # Also works - same key

Key Takeaways

• Variables store data for reuse and clarity

• Use descriptive names for maintainability

• PowerShell is dynamically typed but supports explicit types

• Strings have single/double quote difference

• Arrays store multiple values with 0-based indexing

• Hashtables store key-value pairs

• Scope matters - understand global, script, and local scopes

• Automatic variables provide system information

• Type conversion happens implicitly or explicitly

What You've Learned

✅ Creating and using variables ✅ PowerShell data types and type conversion ✅ String manipulation and formatting ✅ Arrays: creation, access, and operations ✅ Hashtables: key-value storage and access ✅ Variable scope and lifetime ✅ Automatic variables for system information

Next Steps

Now that you can store and manipulate data, let's learn how to work with the file system. In Working with Files and Folders, you'll discover:

• Navigating the file system

• Reading and writing files

• File and folder operations

• Working with different file formats (CSV, JSON, XML)

• Path handling and manipulation

File operations are fundamental to automation - let's master them.

---

Ready to work with files? Continue to Working with Files and Folders →