Variables, Data Types, and Operators

Declare and use variables correctly, understand how PowerShell handles data types implicitly and explicitly, work with strings, arrays, and hashtables, and apply comparison and logical operators in conditions and filters.

🧒 Simple Explanation (ELI5)

A variable is a named box that holds a value. PowerShell variables start with $: $name = "Alice". The box can hold text, numbers, lists, or complex objects. Operators are the comparison words: equal, greater than, less than. They let you ask questions like "is this server's disk usage above 80%?" inside conditions and filters.

🔧 Why Do We Need It?

• Reusability: store a server list in $servers and reference it throughout the script instead of repeating the list.
• Type safety: declaring a variable as [int] prevents silent errors when strings sneak in during automation runs.
• Data structures: arrays and hashtables let you build lookup tables, server inventories, and configuration maps that drive automation logic.
• Dynamic string building: string interpolation and here-strings let you build email bodies, log entries, and commands dynamically.

⚙️ Technical Explanation

PowerShell variables are declared with the $ sigil. Types are inferred by default but can be enforced with a cast: [int]$port = 8080. Common types: [string], [int], [bool], [datetime], [array], [hashtable], [PSCustomObject].

PowerShell strings support two quote styles: double quotes allow variable expansion ("Hello $name") and escape sequences (`n = newline, `t = tab). Single quotes treat everything literally ('Hello $name' outputs the literal text $name).

Comparison operators use letter-based syntax (not symbols, except for some assignments): -eq, -ne, -gt, -lt, -ge, -le. For case-sensitive versions, prefix with c: -ceq, -cne. String matching: -like (wildcards *), -match (regex). Logical operators: -and, -or, -not, !.

📊 Visual Representation

⌨️ Commands / Syntax

# Declare variables
$serverName = "web01"
[int]$port = 8080
[bool]$isProduction = $true

# String interpolation (double quotes expand variables)
Write-Host "Connecting to $serverName on port $port"

# String methods
$serverName.ToUpper()
$serverName.StartsWith("web")
$serverName.Replace("web", "db")

# Here-string for multi-line text
$body = @"
Server: $serverName
Port: $port
Environment: Production
"@

# Arrays
$servers = @("web01", "web02", "web03")
$servers.Count          # 3
$servers[0]             # "web01"
$servers += "web04"     # append

# Hashtables
$config = @{
    Environment = "prod"
    Region      = "uksouth"
    MinReplicas = 2
}
$config["Region"]       # "uksouth"
$config.Environment     # "prod"

# Comparison operators
$port -eq 8080          # True
$serverName -like "web*"  # True
$serverName -match "^\w+\d+$"  # True (regex)
5 -gt 3                 # True

# Logical operators
($port -eq 8080) -and $isProduction   # True
($port -eq 9090) -or ($port -eq 8080) # True
-not $isProduction                     # False

# Get variable type
$port.GetType().Name   # Int32

💼 Example (Real-world Use Case)

A deployment script uses a hashtable to map environment names to Azure resource groups, avoiding repeated if/elseif blocks: the caller passes -Environment prod and the script resolves $resourceGroup = $envMap[$Environment] in one line. This pattern scales to dozens of environments and prevents typos in hardcoded resource group names.

🧪 Hands-on

1. Create a string variable for a server name and interpolate it: $srv = "web01"; Write-Host "Server: $srv".
2. Build an array of three server names and get the count: $list = @("a","b","c"); $list.Count.
3. Create a hashtable mapping two environment names to resource groups and retrieve one entry.
4. Test the -like operator: "web01" -like "web*" should return True.
5. Use Get-Date and store it in a variable: $now = Get-Date; $now.ToString("yyyy-MM-dd").

🐛 Debugging Scenario

Problem: your script does a comparison $count -gt 10 but it is always $false even when $count should be 15.

• Cause: $count is a string, not an integer. String comparison of "15" -gt "10" compares alphabetically—but mixing types in comparisons can give unexpected results.
• Diagnose: run $count.GetType().Name to check: if it returns String, that is the cause.
• Fix: either declare the variable as [int]$count at assignment, or cast it at comparison: [int]$count -gt 10.
• Root cause: values read from CSV files, environment variables, or API responses are strings by default. Always cast to the expected type before arithmetic or magnitude comparisons.

🎯 Interview Questions

🌐 Real-world Usage

Azure deployment scripts use hashtables to map environment names to subscription IDs, resource groups, and locations. CI/CD pipeline scripts use typed variables to ensure port numbers, replica counts, and timeout values are integers before they are passed to commands. Array variables hold server lists that drive parallel Invoke-Command loops across fleets.

📝 Summary

Variables in PowerShell use the $ sigil and are dynamically typed by default. Enforce types with casts. Double quotes expand variables; single quotes are literal. Arrays hold ordered lists; hashtables hold key-value pairs. Comparison operators use alphabetic names (-eq, -gt, -like, -match). Type bugs from external data sources are the most common variable-related failure—always validate types when data comes from CSV, API, or environment variables.