PowerShell Basics and Cmdlets

The Verb-Noun Revelation

After installing PowerShell, I stared at the blank terminal, wondering how to find the right command. Coming from Linux, I was used to memorizing cryptic commands like ls, grep, awk. PowerShell felt different - more... organized.

I needed to find running services on a Windows server. In my mind, the command could be anything: services, list-services, show-services, or some abbreviation I'd never guess. Then I discovered PowerShell's naming convention:

Get-Service

It clicked immediately. "Get" the "Service". Want to stop a service? Stop-Service. Start a process? Start-Process. The pattern was everywhere. Within 30 minutes, I could guess command names with surprising accuracy.

This predictable naming convention changed everything. I wasn't memorizing random commands anymore - I was learning a system.

Understanding Cmdlets

Cmdlet (pronounced "command-let") is the term for PowerShell commands. Unlike shell functions or executables, cmdlets are specialized .NET classes designed for automation tasks.

The Verb-Noun Convention

Every cmdlet follows the pattern: Verb-Noun

Common Verbs:

• Get - Retrieve data

• Set - Change data

• New - Create new items

• Remove - Delete items

• Start - Begin operations

• Stop - End operations

• Restart - Stop and start

• Test - Verify conditions

• Invoke - Execute or run

Examples:

Get-Process      # Retrieve process information
Set-Location     # Change current directory
New-Item         # Create a new file or folder
Remove-Item      # Delete a file or folder
Start-Service    # Start a Windows service
Stop-Service     # Stop a Windows service
Test-Path        # Check if a path exists
Invoke-Command   # Execute a command

Approved Verbs

PowerShell has a list of approved verbs to maintain consistency:

Get-Verb

This returns all approved verbs with descriptions. When writing your own functions, using approved verbs makes them discoverable and consistent with the PowerShell ecosystem.

Discovering Commands with Get-Command

The most important cmdlet for learning PowerShell is Get-Command - it helps you find other commands.

Finding All Available Commands

# Get all commands (this will be a long list)
Get-Command

# Count available commands
(Get-Command).Count

On my system with several modules installed, I have over 2,000 commands available. Don't panic - you'll only use a fraction of them regularly.

Searching by Pattern

# Find all commands with "Service" in the name
Get-Command *Service*

# Find all commands that start with "Get-"
Get-Command Get-*

# Find all commands ending with "-Item"
Get-Command *-Item

Filtering by Verb or Noun

# Find all commands using the "Get" verb
Get-Command -Verb Get

# Find all commands working with "Process" nouns
Get-Command -Noun Process

# Combine verb and noun
Get-Command -Verb Get -Noun Service

Filtering by Type

# Show only cmdlets
Get-Command -CommandType Cmdlet

# Show only functions
Get-Command -CommandType Function

# Show only aliases
Get-Command -CommandType Alias

Real-World Discovery Example

When I needed to manage Azure resources, I didn't know the specific commands. Here's how I discovered them:

# First, check if Azure module is installed
Get-Command -Module Az.*

# Find commands for virtual machines
Get-Command *VM*

# Find commands for storage
Get-Command *Storage*

# Find all commands in the Az.Compute module
Get-Command -Module Az.Compute

This discovery pattern works for any module or technology.

Mastering Get-Help

Get-Help is your built-in documentation system. I use it multiple times daily, even after years of PowerShell experience.

Basic Help Usage

# Get basic help
Get-Help Get-Process

# Get detailed help
Get-Help Get-Process -Detailed

# Get full technical help
Get-Help Get-Process -Full

# Get only examples
Get-Help Get-Process -Examples

# Open help in a separate window (Windows only)
Get-Help Get-Process -ShowWindow

# Get online version of help
Get-Help Get-Process -Online

Updating Help Content

Help files aren't installed by default (to keep PowerShell lightweight). Update them:

# Update all help files (requires admin/elevated prompt)
Update-Help

# Update help for specific module
Update-Help -Module Microsoft.PowerShell.Management

# If you get errors due to internet connectivity
Update-Help -ErrorAction SilentlyContinue

Searching Help Content

# Search for topics containing "process"
Get-Help *process*

# Search for topics about operators
Get-Help about_Operators

# List all "about" help topics
Get-Help about_*

Reading "About" Topics

PowerShell includes conceptual help topics:

Get-Help about_Arrays
Get-Help about_Hash_Tables
Get-Help about_If
Get-Help about_Comparison_Operators
Get-Help about_Regular_Expressions
Get-Help about_Execution_Policies

These are goldmines of information. When I was learning error handling, Get-Help about_Try_Catch_Finally taught me everything I needed.

Understanding Cmdlet Syntax

Parameters

Parameters modify how cmdlets work. They follow the cmdlet name with a -ParameterName format:

# Parameter with value
Get-Service -Name "wuauserv"

# Multiple parameters
Get-Process -Name "pwsh" -FileVersionInfo

# Switch parameters (true/false flags)
Get-ChildItem -Recurse
Get-Process -Module

Parameter Types

Positional Parameters:

# You can omit parameter names for positional parameters
Get-Service "wuauserv"  # Same as Get-Service -Name "wuauserv"

Named Parameters:

# Explicitly naming parameters (always works)
Get-Process -Name "pwsh"

Switch Parameters:

# Boolean flags (presence = true)
Get-ChildItem -Recurse
Get-ChildItem -Recurse:$false  # Explicitly set to false

Finding Parameter Information

# Get help showing parameter details
Get-Help Get-Process -Parameter Name

# See all parameters for a cmdlet
Get-Help Get-Process -Parameter *

Tab Completion

PowerShell's tab completion is incredibly helpful:

# Type and press Tab to complete
Get-Ser<Tab>         # Completes to Get-Service
Get-Service -N<Tab>  # Completes to Get-Service -Name

Press Tab multiple times to cycle through options.

Common Cmdlet Patterns

Working with Services

# Get all services
Get-Service

# Get specific service
Get-Service -Name "wuauserv"

# Get services matching pattern
Get-Service -Name "win*"

# Get service status
Get-Service -Name "wuauserv" | Select-Object Status, StartType

# Start a service (requires admin)
Start-Service -Name "wuauserv"

# Stop a service (requires admin)
Stop-Service -Name "wuauserv"

# Restart a service (requires admin)
Restart-Service -Name "wuauserv"

Working with Processes

# Get all processes
Get-Process

# Get specific process by name
Get-Process -Name "pwsh"

# Get specific process by ID
Get-Process -Id 1234

# Stop a process
Stop-Process -Name "notepad"
Stop-Process -Id 1234

# Start a process
Start-Process "notepad.exe"
Start-Process "https://github.com"  # Opens in default browser

Working with Files and Folders

# List items in current directory
Get-ChildItem

# List with hidden files
Get-ChildItem -Force

# List recursively
Get-ChildItem -Recurse

# Filter by extension
Get-ChildItem -Filter "*.txt"

# Create a directory
New-Item -Path "C:\temp\test" -ItemType Directory

# Create a file
New-Item -Path "C:\temp\test.txt" -ItemType File

# Delete an item
Remove-Item -Path "C:\temp\test.txt"

# Copy an item
Copy-Item -Path "source.txt" -Destination "dest.txt"

# Move an item
Move-Item -Path "old.txt" -Destination "new.txt"

Aliases: Shortcuts for Common Commands

PowerShell includes aliases for frequently-used commands:

# Common aliases
ls      # Alias for Get-ChildItem
dir     # Alias for Get-ChildItem
cd      # Alias for Set-Location
pwd     # Alias for Get-Location
cat     # Alias for Get-Content
cp      # Alias for Copy-Item
mv      # Alias for Move-Item
rm      # Alias for Remove-Item

Viewing and Creating Aliases

# Get all aliases
Get-Alias

# Find what command an alias represents
Get-Alias -Name ls

# Find aliases for a command
Get-Alias -Definition Get-ChildItem

# Create your own alias (current session only)
New-Alias -Name list -Value Get-ChildItem

# To make aliases permanent, add to your profile

Aliases in Scripts: A Warning

Don't use aliases in scripts. Use full cmdlet names for clarity:

# Bad - hard to read and maintain
ls | ? {$_.Length -gt 1MB} | % {$_.Name}

# Good - clear and explicit
Get-ChildItem | Where-Object {$_.Length -gt 1MB} | ForEach-Object {$_.Name}

Aliases are great for interactive use but reduce script readability.

The -WhatIf and -Confirm Parameters

Safety features that prevent accidental damage:

-WhatIf: Preview Without Executing

# See what would be deleted without actually deleting
Remove-Item C:\temp\*.txt -WhatIf

# See what would be stopped
Stop-Service -Name "wuauserv" -WhatIf

# Preview file copy
Copy-Item C:\source\* C:\destination\ -Recurse -WhatIf

I use -WhatIf constantly when testing scripts that modify systems.

-Confirm: Prompt Before Executing

# Prompt before each deletion
Remove-Item C:\temp\*.txt -Confirm

# Prompt before service stop
Stop-Service -Name "wuauserv" -Confirm

Real-World Application: Server Health Check

Here's a practical example using cmdlets we've learned:

# Check critical services
$criticalServices = @('wuauserv', 'W32Time', 'EventLog')
foreach ($service in $criticalServices) {
    $svc = Get-Service -Name $service
    if ($svc.Status -ne 'Running') {
        Write-Host "WARNING: $service is $($svc.Status)" -ForegroundColor Yellow
    } else {
        Write-Host "OK: $service is Running" -ForegroundColor Green
    }
}

# Check disk space
$drives = Get-PSDrive -PSProvider FileSystem
foreach ($drive in $drives) {
    $freePercent = ($drive.Free / $drive.Used) * 100
    if ($freePercent -lt 10) {
        Write-Host "WARNING: Drive $($drive.Name) is low on space" -ForegroundColor Red
    }
}

# Check high CPU processes
$highCPU = Get-Process | Where-Object {$_.CPU -gt 100} | Select-Object -First 5
if ($highCPU) {
    Write-Host "High CPU Processes:" -ForegroundColor Yellow
    $highCPU | Format-Table Name, CPU, WorkingSet
}

This script checks services, disk space, and CPU usage - a simple health check I run on servers.

Common Pitfalls

1. Not Using Tab Completion

Problem: Typing full cmdlet names and parameter names manually Solution: Press Tab to autocomplete - saves time and prevents typos

2. Ignoring Get-Help Examples

Problem: Struggling to understand cmdlet syntax Solution: Get-Help <cmdlet> -Examples shows practical usage patterns

3. Using Aliases in Scripts

Problem: Scripts like ls | ? {$_.Length -gt 1MB} are hard to read Solution: Use full cmdlet names in scripts for clarity

4. Not Using -WhatIf for Destructive Operations

Problem: Accidentally deleting files or stopping critical services Solution: Always test with -WhatIf first:

Remove-Item *.txt -WhatIf  # Preview first
Remove-Item *.txt          # Execute after verification

5. Forgetting About Update-Help

Problem: Getting minimal help output Solution: Run Update-Help to download complete documentation

Key Takeaways

• Verb-Noun naming makes commands predictable and discoverable

• Get-Command helps you find commands by pattern, verb, or noun

• Get-Help provides comprehensive documentation with examples

• Parameters modify cmdlet behavior - learn to use them effectively

• Tab completion saves time and prevents errors

• -WhatIf lets you preview changes safely

• Aliases are great interactively but avoid them in scripts

• Approved verbs maintain consistency across PowerShell

What You've Learned

✅ The Verb-Noun naming convention ✅ How to discover commands with Get-Command ✅ How to master Get-Help for self-sufficiency ✅ Understanding cmdlet parameters and syntax ✅ Common cmdlet patterns for services, processes, and files ✅ Using aliases (and when not to) ✅ Safety features like -WhatIf and -Confirm

Next Steps

Now that you can find and understand cmdlets, it's time to learn PowerShell's most powerful feature: the pipeline. In The PowerShell Pipeline, you'll discover:

• How the PowerShell pipeline differs from Unix/Linux pipes

• Working with objects instead of text

• Chaining cmdlets to build powerful one-liners

• Common pipeline patterns you'll use daily

The pipeline is what makes PowerShell truly powerful - it's where everything comes together.

---

Ready to master the pipeline? Continue to The PowerShell Pipeline →