Introduction to PowerShell

PowerShell is far more than a replacement for the old Windows Command Prompt. It is a complete automation platform — a shell, a scripting language, and a configuration management framework all rolled into one.

What is PowerShell?

PowerShell is a task-based command-line shell and scripting language built on the .NET framework. Unlike traditional shells that pass strings around, PowerShell works with objects — structured data with properties and methods.

This architectural choice fundamentally changes how you work with command output. In traditional Unix shells, every command outputs text, which you must parse with tools like awk, sed, or cut. These tools are powerful but brittle — if the output format changes (different column widths, reordered fields), your scripts break.

PowerShell eliminates this entire category of problems. Commands return structured .NET objects with named properties and typed data. You access properties by name, filter by exact values, and compose pipelines without string manipulation.

The Key Difference: Objects vs Text

In a traditional shell, everything is text. This creates constant parsing challenges:

# Bash: text-based pipeline
# ps aux | grep nginx | awk '{print $2}'
# You're parsing strings, hoping columns don't shift
 

This approach has problems:

• Fragile: If column positions change, your script breaks
• Type-unsafe: Everything is a string; you manually convert to numbers
• Verbose: Extracting data requires complex regex or field splitting
• Error-prone: Whitespace, special characters, and quoting are constant issues

In PowerShell, commands return objects with properties:

# PowerShell: object-based pipeline
Get-Process -Name nginx | Select-Object -Property Id
# You directly access the .Id property — no parsing needed
 

Why this matters:

• Robust: Property names never change; your code is resilient
• Type-safe: CPU is a decimal, memory is an integer, dates are DateTime objects
• Discoverable: Use Get-Member to see all available properties and methods
• Composable: Filter and transform objects without text manipulation

This single concept — everything is an object — makes PowerShell fundamentally more powerful and less error-prone than text-based shells. You spend less time parsing output and more time solving problems.

A Brief History

Windows PowerShell vs PowerShell 7

Understanding the two "editions" is essential:

Why Learn PowerShell?

1. Automation at Scale

PowerShell was built for automation. Everything you can click in Windows, you can script in PowerShell — and do it across thousands of machines.

Why this matters:

• Repeatability: Script once, run anywhere, anytime
• Consistency: Eliminate human error from repetitive tasks
• Speed: Automate operations that take hours manually
• Auditing: Scripts provide a clear record of what changed

# Create 100 Active Directory users from a CSV
Import-Csv users.csv | ForEach-Object {
    New-ADUser -Name $_.Name -Department $_.Dept -Enabled $true
}
 

This replaces hours of GUI clicking with a 3-line script that's auditable, repeatable, and version-controlled.

2. Consistent Command Structure

Every PowerShell command follows a Verb-Noun naming convention, making commands predictable and discoverable:

Get-Process       # Get running processes
Stop-Process      # Stop a process
Get-Service       # Get services
Start-Service     # Start a service
Get-ChildItem     # Get files and folders
Copy-Item         # Copy files
 

This consistency has major advantages:

• Guessable: Need to restart a service? Try Restart-Service (it exists!)
• Discoverable: Get-Command -Verb Get shows all retrieval commands
• Self-documenting: Command names clearly state their purpose
• Approved verbs: PowerShell enforces a standard set of verbs (Get, Set, New, Remove, Start, Stop, etc.)

Once you learn the pattern, you can guess command names and often be right. Compare this to Unix commands like ls, cat, grep — abbreviated names you must memorize.

3. Self-Documenting

PowerShell has the best built-in help system of any shell. Every cmdlet includes documentation, examples, and parameter descriptions:

Get-Help Get-Process -Full        # Complete documentation
Get-Help Get-Process -Examples    # Just show examples
Get-Command -Verb Get             # Find all "Get" commands
Get-Command -Noun *User*          # Find commands about users
 

Why this matters:

• No internet required: Full documentation offline
• Examples included: Most cmdlets have 5-10 real-world examples
• Parameter help: -Full shows detailed parameter descriptions
• Discoverable: Find commands by verb, noun, or keyword
• Update-Help: Download latest docs with one command

Unlike Unix man pages, PowerShell help is written for humans and includes practical examples you can copy and adapt immediately.

4. Cross-Platform

With PowerShell 7+, your scripts run on Windows, macOS, and Linux:

# This works on all three platforms
Get-Process | Sort-Object CPU -Descending | Select-Object -First 5
 

5. Integration with Everything

PowerShell connects to:

• Azure (Az module)
• AWS (AWS.Tools module)
• Microsoft 365 (Exchange Online, SharePoint, Teams)
• Active Directory (RSAT module)
• SQL Server (SqlServer module)
• REST APIs (Invoke-RestMethod)
• WMI/CIM (for hardware and OS info)

Your First PowerShell Commands

Open a PowerShell terminal and try these:

# What version am I running?
$PSVersionTable
 
# What's today's date?
Get-Date
 
# What's my computer name?
$env:COMPUTERNAME    # Windows
hostname             # Cross-platform
 

Exploring Objects

This is the most important thing to understand early. Every command returns objects:

# Get the current date
$today = Get-Date
 
# See what properties and methods it has
$today | Get-Member
 
# Access specific properties
$today.DayOfWeek
$today.Year
$today.Month
 
# Call methods
$today.AddDays(30)
$today.ToString("yyyy-MM-dd")
 

# Get a process and explore its properties
$proc = Get-Process -Name "explorer" | Select-Object -First 1
 
$proc.Id
$proc.CPU
$proc.WorkingSet64 / 1MB    # Memory in MB
 

The PowerShell Console

Keyboard Shortcuts

PSReadLine

PowerShell comes with PSReadLine, which gives you a rich editing experience:

# Search history (press Ctrl+R then type)
# Matching commands appear as you type
 
# Predictive IntelliSense (PowerShell 7.2+)
Set-PSReadLineOption -PredictionSource History
Set-PSReadLineOption -PredictionViewStyle ListView
 
# List view shows multiple suggestions you can scroll through
 

Understanding Aliases

PowerShell has built-in aliases for many commands, including aliases that look like Unix commands:

# See all aliases
Get-Alias
 
# Some common ones
Get-Alias ls      # → Get-ChildItem
Get-Alias cd      # → Set-Location
Get-Alias cat     # → Get-Content
Get-Alias rm      # → Remove-Item
Get-Alias echo    # → Write-Output
Get-Alias cls     # → Clear-Host
Get-Alias pwd     # → Get-Location
 

Execution Policies

PowerShell has a safety feature called execution policies that control which scripts can run:

# Check current policy
Get-ExecutionPolicy
 
# Common policies:
# Restricted    — No scripts can run (Windows default)
# RemoteSigned  — Local scripts run; downloaded must be signed
# AllSigned     — All scripts must be signed
# Unrestricted  — All scripts run (with warnings for downloaded)
# Bypass        — Nothing blocked, no warnings
 
# Set for current user (recommended)
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
 

The PowerShell Profile

Your profile is a script that runs every time PowerShell starts — like .bashrc for Bash:

# Check if your profile exists
Test-Path $PROFILE
 
# See the path to your profile
$PROFILE
 
# There are actually multiple profiles
$PROFILE | Format-List -Force
# AllUsersAllHosts
# AllUsersCurrentHost
# CurrentUserAllHosts
# CurrentUserCurrentHost    ← This is $PROFILE
 

Create a starter profile:

# Create the profile file if it doesn't exist
if (!(Test-Path $PROFILE)) {
    New-Item -ItemType File -Path $PROFILE -Force
}
 
# Open it in your editor
code $PROFILE
# or: notepad $PROFILE
 

A starter profile:

# PowerShell Profile
 
# Aliases
Set-Alias -Name g -Value git
Set-Alias -Name open -Value Invoke-Item
 
# Quick navigation
function home { Set-Location ~ }
function proj { Set-Location ~/Projects }
 
# Custom prompt
function prompt {
    $path = (Get-Location).Path.Replace($HOME, '~')
    Write-Host "PS " -NoNewline -ForegroundColor Cyan
    Write-Host "$path" -NoNewline -ForegroundColor Yellow
    return "> "
}
 
# PSReadLine settings
Set-PSReadLineOption -PredictionSource History
Set-PSReadLineOption -EditMode Emacs
 
Write-Host "Profile loaded!" -ForegroundColor Green
 

# 1. Version
$PSVersionTable
# PSVersion      7.4.x
# PSEdition      Core
# OS             Microsoft Windows ...
 
# 2. DateTime members
Get-Date | Get-Member
# There are roughly 20+ properties (Year, Month, Day, Hour, etc.)
# and 20+ methods (AddDays, AddHours, ToString, etc.)
 
# 3. Process properties
Get-Process | Select-Object -First 3
# Handles  NPM(K)  PM(K)  WS(K)  CPU(s)  Id  ProcessName
# You see structured columns — each is a property of the object
 
# 4. Alias count
Get-Alias | Measure-Object
# Count: typically 140-180 aliases depending on modules loaded
 

$today = Get-Date
 
# 1. Day of the year
$today.DayOfYear
# Example output: 166
 
# 2. 100 days from now
$today.AddDays(100)
# Example output: Wednesday, September 23, 2025 ...
 
# 3. Is this a leap year?
[DateTime]::IsLeapYear($today.Year)
# Output: False (2025 is not a leap year)