PowerShell Delete Files: Complete Guide to Remove-Item [2024]

!PowerShell Delete Files Guide

The Remove-Item cmdlet is PowerShell’s primary tool for deleting files and folders. Understanding how to safely and efficiently delete files is crucial for automation, cleanup tasks, and system maintenance.

Whether you’re cleaning old log files, removing temporary data, or performing bulk deletions, this comprehensive guide covers everything from basic file deletion to advanced filtering techniques with safety best practices.

What is Remove-Item?
Why Use PowerShell for File Deletion?
Basic File Deletion
Delete All Files in Folder
Delete Files Recursively
Delete by Extension
Delete Old Files
Delete by Size
Delete by Pattern
Files Only (Keep Folders)
Delete Empty Folders
Delete Hidden Files
Delete Read-Only Files
Safe Deletion with -WhatIf
Confirm Before Deleting
Performance Optimization
Real-World Use Cases
Common Mistakes
Best Practices
FAQs

What is Remove-Item? {#what-is-remove-item}

Remove-Item is a PowerShell cmdlet that deletes files, folders, registry keys, and other provider items. It’s the PowerShell equivalent of the del or rm commands.

Key Characteristics:

Deletes files and directories
Works with any PowerShell provider (FileSystem, Registry, etc.)
Supports wildcards and filtering
Can force deletion of read-only items
Supports confirmation and preview modes

# Basic syntax
Remove-Item -Path "C:\Temp\file.txt"

# Common aliases
del "C:\Temp\file.txt"   # Alias: del
rm "C:\Temp\file.txt"    # Alias: rm
ri "C:\Temp\file.txt"    # Alias: ri

Important Parameters:

Parameter	Purpose	Example
`-Path`	File/folder to delete	`"C:\Temp\*"`
`-Filter`	Pattern to match	`"*.log"`
`-Force`	Delete hidden/read-only	Required for special files
`-Recurse`	Delete subdirectories	For folder trees
`-WhatIf`	Preview (don’t delete)	Safety check
`-Confirm`	Prompt before delete	Interactive confirmation

For more file operations, see our Complete PowerShell Guide.

Why Use PowerShell for File Deletion? {#why-use-powershell}

PowerShell provides advantages over manual deletion or CMD:

1. Conditional Deletion Delete only files matching specific criteria:

# Delete files older than 30 days
Get-ChildItem -Path "C:\Logs" -Filter "*.log" |
    Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-30) } |
    Remove-Item

2. Bulk Operations Process thousands of files efficiently:

# Delete all .tmp files recursively
Get-ChildItem -Path "C:\" -Filter "*.tmp" -Recurse -Force |
    Remove-Item -Force

3. Safety Features Preview before deletion:

# Preview what would be deleted
Remove-Item -Path "C:\Temp\*" -WhatIf

4. Automation Schedule cleanup tasks:

# Automated log cleanup script
$logPath = "C:\Logs"
$daysToKeep = 30
Get-ChildItem $logPath -Recurse -Filter "*.log" |
    Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-$daysToKeep) } |
    Remove-Item -Force

5. Error Handling Robust error management:

try {
    Remove-Item -Path "C:\Temp\file.txt" -ErrorAction Stop
    Write-Host "File deleted successfully"
} catch {
    Write-Warning "Failed to delete: $_"
}

Basic File Deletion {#basic-deletion}

Delete Single File

# Delete specific file
Remove-Item -Path "C:\Temp\test.txt"

# With confirmation
Remove-Item -Path "C:\Temp\test.txt" -Confirm

# Force delete (no confirmation)
Remove-Item -Path "C:\Temp\test.txt" -Force

Delete Multiple Specific Files

# Delete multiple named files
Remove-Item -Path "C:\Temp\file1.txt", "C:\Temp\file2.txt", "C:\Temp\file3.txt"

# Using array
$files = @(
    "C:\Temp\file1.txt"
    "C:\Temp\file2.txt"
    "C:\Temp\file3.txt"
)
$files | ForEach-Object { Remove-Item -Path $_ -Force }

Delete All Files in Folder {#delete-all-files}

Remove all files from a directory:

Method 1: Using Wildcard

# Delete all files in folder
$folderPath = "C:\Temp\Logs"
Remove-Item -Path "$folderPath\*" -Force

# Verify deletion
Get-ChildItem -Path $folderPath

Output:

(Empty - all files deleted)

Method 2: Using Get-ChildItem

# More control with Get-ChildItem
Get-ChildItem -Path "C:\Temp" -File | Remove-Item -Force

# Count files before deletion
$files = Get-ChildItem -Path "C:\Temp" -File
Write-Host "Deleting $($files.Count) files..."
$files | Remove-Item -Force

Keep Folder Structure

# Delete files but keep subfolder structure
Get-ChildItem -Path "C:\Temp" -File -Recurse | Remove-Item -Force

# Verify folders remain
Get-ChildItem -Path "C:\Temp" -Directory -Recurse

Delete Files Recursively {#delete-recursive}

Delete files in all subdirectories:

Delete All Contents Recursively

# Delete everything (files and folders) recursively
$folderPath = "C:\Temp\OldData"
Remove-Item -Path "$folderPath\*" -Recurse -Force

# Or delete entire folder
Remove-Item -Path $folderPath -Recurse -Force

Files Only (Keep Directory Structure)

# Delete only files recursively, keep folders
Get-ChildItem -Path "C:\Projects" -File -Recurse | Remove-Item -Force

# Verify folder structure intact
Get-ChildItem -Path "C:\Projects" -Directory -Recurse

Delete by Extension {#by-extension}

Remove files with specific extensions:

Single Extension

# Delete all .log files
Get-ChildItem -Path "C:\Logs" -Filter "*.log" -Recurse |
    Remove-Item -Force

# Count before deletion
$logFiles = Get-ChildItem -Path "C:\Logs" -Filter "*.log" -Recurse
Write-Host "Found $($logFiles.Count) log files"
$logFiles | Remove-Item -Force

Multiple Extensions

# Delete .tmp, .bak, and .old files
$extensions = @('*.tmp', '*.bak', '*.old')

foreach ($ext in $extensions) {
    Get-ChildItem -Path "C:\Temp" -Filter $ext -Recurse |
        Remove-Item -Force
}

# Or using Include parameter
Get-ChildItem -Path "C:\Temp" -Include $extensions -Recurse |
    Remove-Item -Force

Exclude Certain Extensions

# Delete all files except .txt and .doc
Get-ChildItem -Path "C:\Data" -File -Recurse |
    Where-Object { $_.Extension -notin @('.txt', '.doc') } |
    Remove-Item -Force

Delete Old Files {#by-age}

Remove files based on age:

By LastWriteTime

# Delete files older than 30 days
$daysOld = 30
$cutoffDate = (Get-Date).AddDays(-$daysOld)

Get-ChildItem -Path "C:\Logs" -Recurse -File |
    Where-Object { $_.LastWriteTime -lt $cutoffDate } |
    Remove-Item -Force

Write-Host "Deleted files older than $daysOld days"

By CreationTime

# Delete files created more than 90 days ago
$cutoff = (Get-Date).AddDays(-90)

Get-ChildItem -Path "C:\Archive" -Recurse -File |
    Where-Object { $_.CreationTime -lt $cutoff } |
    Remove-Item -Force

By LastAccessTime

# Delete files not accessed in 6 months
$cutoff = (Get-Date).AddMonths(-6)

Get-ChildItem -Path "C:\SharedFiles" -Recurse -File |
    Where-Object { $_.LastAccessTime -lt $cutoff } |
    Remove-Item -Force

Specific Date Range

# Delete files from specific date range
$startDate = Get-Date "2023-01-01"
$endDate = Get-Date "2023-12-31"

Get-ChildItem -Path "C:\Data" -Recurse -File |
    Where-Object {
        $_.LastWriteTime -ge $startDate -and
        $_.LastWriteTime -le $endDate
    } |
    Remove-Item -Force

Delete by Size {#by-size}

Remove files based on file size:

Large Files

# Delete files larger than 100MB
Get-ChildItem -Path "C:\Downloads" -Recurse -File |
    Where-Object { $_.Length -gt 100MB } |
    Remove-Item -Force

# Report before deletion
$largeFiles = Get-ChildItem -Path "C:\Downloads" -Recurse -File |
    Where-Object { $_.Length -gt 100MB }

$totalSize = ($largeFiles | Measure-Object -Property Length -Sum).Sum / 1GB
Write-Host "Deleting $($largeFiles.Count) files totaling $([math]::Round($totalSize, 2))GB"

$largeFiles | Remove-Item -Force

Small Files

# Delete files smaller than 1KB (likely empty or corrupt)
Get-ChildItem -Path "C:\Temp" -Recurse -File |
    Where-Object { $_.Length -lt 1KB } |
    Remove-Item -Force

Size Range

# Delete files between 10MB and 50MB
Get-ChildItem -Path "C:\Data" -Recurse -File |
    Where-Object {
        $_.Length -ge 10MB -and
        $_.Length -le 50MB
    } |
    Remove-Item -Force

Empty Files (0 bytes)

# Delete empty files
Get-ChildItem -Path "C:\Temp" -Recurse -File |
    Where-Object { $_.Length -eq 0 } |
    Remove-Item -Force

Delete by Pattern {#by-pattern}

Use wildcards and regex for pattern matching:

Wildcard Patterns

# Delete files starting with "temp"
Get-ChildItem -Path "C:\Temp" -Filter "temp*" -Recurse |
    Remove-Item -Force

# Delete files ending with specific pattern
Get-ChildItem -Path "C:\Logs" -Filter "*_backup_*" -Recurse |
    Remove-Item -Force

# Delete files matching pattern
Get-ChildItem -Path "C:\Data" -Filter "report_202?_*.txt" -Recurse |
    Remove-Item -Force

Regex Patterns

# Delete files with date pattern in name
Get-ChildItem -Path "C:\Logs" -Recurse -File |
    Where-Object { $_.Name -match "\d{4}-\d{2}-\d{2}" } |
    Remove-Item -Force

# Delete numbered files
Get-ChildItem -Path "C:\Temp" -Recurse -File |
    Where-Object { $_.Name -match "^file\d+\.txt$" } |
    Remove-Item -Force

Files Only (Keep Folders) {#files-only}

Delete only files, preserve directory structure:

# Delete files recursively, keep all folders
Get-ChildItem -Path "C:\Projects" -File -Recurse | Remove-Item -Force

# Verify folders remain
$folders = Get-ChildItem -Path "C:\Projects" -Directory -Recurse
Write-Host "$($folders.Count) folders preserved"

# Delete specific file types, keep folders
Get-ChildItem -Path "C:\Data" -Include "*.tmp", "*.log" -File -Recurse |
    Remove-Item -Force

Delete Empty Folders {#empty-folders}

Remove directories with no files:

# Delete empty folders (recursive)
Get-ChildItem -Path "C:\Data" -Directory -Recurse |
    Where-Object { (Get-ChildItem -Path $_.FullName).Count -eq 0 } |
    Remove-Item -Force

# More robust - multiple passes for nested empty folders
do {
    $emptyFolders = Get-ChildItem -Path "C:\Data" -Directory -Recurse |
        Where-Object { (Get-ChildItem -Path $_.FullName).Count -eq 0 }

    $emptyFolders | Remove-Item -Force
    Write-Host "Removed $($emptyFolders.Count) empty folders"

} while ($emptyFolders.Count -gt 0)

Delete Hidden Files {#hidden-files}

Remove hidden or system files:

# Delete hidden files
Get-ChildItem -Path "C:\Temp" -Hidden -Recurse -File |
    Remove-Item -Force

# Delete system files (use with caution!)
Get-ChildItem -Path "C:\Temp" -System -Recurse -File |
    Remove-Item -Force

# Delete all files including hidden/system
Get-ChildItem -Path "C:\Temp" -Force -Recurse -File |
    Remove-Item -Force

Delete Read-Only Files {#readonly-files}

Remove files with read-only attribute:

# Delete read-only files (requires -Force)
Get-ChildItem -Path "C:\Temp" -Recurse -File |
    Where-Object { $_.IsReadOnly } |
    Remove-Item -Force

# Remove read-only attribute first, then delete
Get-ChildItem -Path "C:\Temp" -Recurse -File |
    Where-Object { $_.IsReadOnly } |
    ForEach-Object {
        $_.IsReadOnly = $false
        Remove-Item -Path $_.FullName
    }

Safe Deletion with -WhatIf {#whatif}

Preview deletions before executing:

# Preview what would be deleted
Remove-Item -Path "C:\Temp\*" -WhatIf

# Preview recursive deletion
Get-ChildItem -Path "C:\Logs" -Filter "*.log" -Recurse |
    Remove-Item -WhatIf

# Complex query preview
Get-ChildItem -Path "C:\Data" -Recurse -File |
    Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-30) } |
    Remove-Item -WhatIf

# Count what would be deleted
$toDelete = Get-ChildItem -Path "C:\Temp" -Filter "*.tmp" -Recurse
Write-Host "Would delete $($toDelete.Count) files"
$toDelete | Remove-Item -WhatIf

Confirm Before Deleting {#confirm}

Interactive confirmation:

# Prompt for each file
Remove-Item -Path "C:\Temp\*" -Confirm

# Custom confirmation
$files = Get-ChildItem -Path "C:\Temp" -Filter "*.log"
$response = Read-Host "Delete $($files.Count) log files? (Y/N)"

if ($response -eq 'Y') {
    $files | Remove-Item -Force
    Write-Host "Files deleted"
} else {
    Write-Host "Deletion cancelled"
}

# Confirm for large deletions only
$files = Get-ChildItem -Path "C:\Data" -Recurse -File
if ($files.Count -gt 100) {
    $files | Remove-Item -Confirm
} else {
    $files | Remove-Item -Force
}

Performance Optimization {#performance}

Optimize deletion for large datasets:

# Faster: Use -Filter with Get-ChildItem
Get-ChildItem -Path "C:\Logs" -Filter "*.log" -Recurse |
    Remove-Item -Force

# Slower: Use Where-Object filtering
Get-ChildItem -Path "C:\Logs" -Recurse |
    Where-Object { $_.Extension -eq '.log' } |
    Remove-Item -Force

# Batch deletion
$files = Get-ChildItem -Path "C:\Temp" -Filter "*.tmp" -Recurse
Write-Host "Deleting $($files.Count) files..."
$files | Remove-Item -Force

# Progress tracking for large operations
$files = Get-ChildItem -Path "C:\Data" -Recurse -File
$total = $files.Count
$count = 0

foreach ($file in $files) {
    Remove-Item -Path $file.FullName -Force
    $count++
    if ($count % 100 -eq 0) {
        Write-Progress -Activity "Deleting Files" -Status "$count of $total" `
            -PercentComplete (($count / $total) * 100)
    }
}

Real-World Use Cases {#use-cases}

Use Case 1: Clean Old Log Files

# Automated log cleanup
$logPath = "C:\Logs"
$daysToKeep = 30
$cutoffDate = (Get-Date).AddDays(-$daysToKeep)

$oldLogs = Get-ChildItem -Path $logPath -Filter "*.log" -Recurse |
    Where-Object { $_.LastWriteTime -lt $cutoffDate }

$sizeFreed = ($oldLogs | Measure-Object -Property Length -Sum).Sum / 1GB

Write-Host "Deleting $($oldLogs.Count) log files"
Write-Host "Freeing $([math]::Round($sizeFreed, 2))GB disk space"

$oldLogs | Remove-Item -Force

Write-Host "Cleanup complete"

Use Case 2: Clean Temp Folders

# Clean Windows temp folders
$tempPaths = @(
    "$env:TEMP"
    "C:\Windows\Temp"
    "C:\Windows\Prefetch"
)

foreach ($path in $tempPaths) {
    if (Test-Path $path) {
        Write-Host "Cleaning $path..."
        Get-ChildItem -Path $path -Force -Recurse -ErrorAction SilentlyContinue |
            Remove-Item -Force -Recurse -ErrorAction SilentlyContinue
    }
}

Use Case 3: Remove Duplicate Files

# Find and delete duplicate files by hash
$files = Get-ChildItem -Path "C:\Documents" -Recurse -File |
    Get-FileHash |
    Group-Object -Property Hash |
    Where-Object { $_.Count -gt 1 }

foreach ($group in $files) {
    Write-Host "Found $($group.Count) duplicates of $($group.Group[0].Path)"

    # Keep first, delete others
    $group.Group | Select-Object -Skip 1 | ForEach-Object {
        Remove-Item -Path $_.Path -Force
        Write-Host "  Deleted: $($_.Path)"
    }
}

Use Case 4: Clean Build Artifacts

# Clean Visual Studio build artifacts
$projectRoot = "C:\Projects"
$foldersToDelete = @("bin", "obj", ".vs", "packages")

foreach ($folder in $foldersToDelete) {
    Get-ChildItem -Path $projectRoot -Filter $folder -Recurse -Directory |
        ForEach-Object {
            Write-Host "Deleting $($_.FullName)"
            Remove-Item -Path $_.FullName -Recurse -Force
        }
}

Use Case 5: Automated Backup Cleanup

# Keep only last 7 daily backups
$backupPath = "C:\Backups"
$backupFiles = Get-ChildItem -Path $backupPath -Filter "backup_*.zip" |
    Sort-Object LastWriteTime -Descending

# Keep newest 7, delete the rest
$toDelete = $backupFiles | Select-Object -Skip 7

if ($toDelete) {
    Write-Host "Deleting $($toDelete.Count) old backups"
    $toDelete | Remove-Item -Force
} else {
    Write-Host "No old backups to delete"
}

Common Mistakes {#mistakes}

❌ Mistake 1: Forgetting -Force

# Wrong - may fail on read-only files
Remove-Item -Path "C:\Temp\*"

# Correct - force deletion
Remove-Item -Path "C:\Temp\*" -Force

❌ Mistake 2: Not Using -WhatIf First

# Dangerous - deletes immediately
Get-ChildItem -Path "C:\Data" -Recurse | Remove-Item -Force

# Safe - preview first
Get-ChildItem -Path "C:\Data" -Recurse | Remove-Item -WhatIf
# Then if OK, remove -WhatIf

❌ Mistake 3: Deleting Folders When Meaning Files

# Wrong - deletes folders too
Remove-Item -Path "C:\Temp\*" -Recurse -Force

# Correct - files only
Get-ChildItem -Path "C:\Temp" -File -Recurse | Remove-Item -Force

❌ Mistake 4: Not Handling Errors

# Bad - errors abort script
Remove-Item -Path "C:\Temp\*" -Recurse -Force

# Good - continue on errors
Remove-Item -Path "C:\Temp\*" -Recurse -Force -ErrorAction SilentlyContinue

# Better - log errors
Remove-Item -Path "C:\Temp\*" -Recurse -Force -ErrorAction SilentlyContinue -ErrorVariable deletionErrors
if ($deletionErrors) {
    Write-Warning "Some files could not be deleted:"
    $deletionErrors | ForEach-Object { Write-Warning $_.Exception.Message }
}

❌ Mistake 5: Inefficient Filtering

# Slow - filters after retrieval
Get-ChildItem -Path "C:\Logs" -Recurse |
    Where-Object { $_.Extension -eq '.log' } |
    Remove-Item

# Fast - filters during retrieval
Get-ChildItem -Path "C:\Logs" -Filter "*.log" -Recurse | Remove-Item

Best Practices {#best-practices}

✅ Always Use -WhatIf First

# Preview before executing
Remove-Item -Path "C:\Data\*" -WhatIf

✅ Use -Filter Over Where-Object

# Better performance
Get-ChildItem -Path "C:\Logs" -Filter "*.log" | Remove-Item -Force

✅ Be Specific with Paths

# Good - specific path
Remove-Item -Path "C:\Temp\OldData\*" -Force

# Dangerous - too broad
# Remove-Item -Path "C:\*" -Force

✅ Log Deletion Operations

# Good - maintain audit trail
$files = Get-ChildItem -Path "C:\Temp" -Filter "*.tmp"
$logFile = "C:\Logs\deletion_$(Get-Date -Format 'yyyyMMdd').log"

foreach ($file in $files) {
    "$(Get-Date) - Deleted: $($file.FullName)" | Out-File $logFile -Append
    Remove-Item -Path $file.FullName -Force
}

✅ Handle Errors Gracefully

# Good - robust error handling
try {
    Get-ChildItem -Path "C:\Temp" -Filter "*.log" -ErrorAction Stop |
        Remove-Item -Force -ErrorAction Stop
    Write-Host "Deletion successful"
} catch {
    Write-Error "Deletion failed: $_"
}

Frequently Asked Questions {#faqs}

Q: How do I delete files but keep folders?

A: Use -File parameter:

Get-ChildItem -Path "C:\Data" -File -Recurse | Remove-Item -Force

Q: Can I recover files deleted with Remove-Item?

A: No, files are permanently deleted (not sent to Recycle Bin). Use caution and -WhatIf first.

Q: How do I delete files older than a certain date?

A: Filter by LastWriteTime:

$cutoff = (Get-Date).AddDays(-30)
Get-ChildItem | Where-Object { $_.LastWriteTime -lt $cutoff } | Remove-Item

Q: Why am I getting “access denied” errors?

A: Files may be in use, read-only, or require elevation. Try:

# Run PowerShell as Administrator
Remove-Item -Path $file -Force

Q: How do I delete locked files?

A: Close programs using the file, or use Handle utility:

# Check what's using the file
handle.exe file.txt

# Then close the program and retry

Q: Can I delete files on remote computers?

A: Yes, use UNC paths or remoting:

# UNC path
Remove-Item -Path "\\Server01\C$\Temp\*" -Force

# PowerShell Remoting
Invoke-Command -ComputerName Server01 -ScriptBlock {
    Remove-Item -Path "C:\Temp\*" -Force
}

Q: How do I delete files with special characters in names?

A: Use literal path:

Remove-Item -LiteralPath "C:\Temp\file[1].txt" -Force

Q: What’s the fastest way to delete many files?

A: Use -Filter and avoid Where-Object:

# Fastest
Get-ChildItem -Path "C:\Temp" -Filter "*.tmp" | Remove-Item -Force

Q: How do I delete files but skip certain folders?

A: Exclude folders in filter:

Get-ChildItem -Path "C:\Data" -Recurse -File |
    Where-Object { $_.DirectoryName -notlike "*\Keep\*" } |
    Remove-Item -Force

Q: Can I delete files based on permissions?

A: Yes, check ACL:

Get-ChildItem | Where-Object {
    (Get-Acl $_.FullName).Owner -eq "DOMAIN\User"
} | Remove-Item

Conclusion

Mastering file deletion in PowerShell is essential for system administration and automation. Key takeaways:

✅ Always use -WhatIf to preview before deleting ✅ Use -Filter for better performance ✅ Handle errors with try-catch or -ErrorAction ✅ Be specific with paths to avoid accidents ✅ Log operations for audit trails ✅ Test on non-critical data before production use

File Management Operations

PowerShell Rename Files - Rename files in bulk
PowerShell List Files - List directory contents
PowerShell Delete Files Matching Pattern - Pattern-based deletion
PowerShell Delete File If Exists - Conditional deletion
PowerShell Count Files - Count directory contents

Data Selection & Filtering

PowerShell Select-Object - Select properties
PowerShell Where-Object - Filter files
PowerShell ForEach-Object - Process each file
PowerShell Get-ChildItem Filter - Advanced filtering
PowerShell Get-ChildItem Regex - Regex filtering
PowerShell Measure-Object - Calculate statistics

String & Pattern Operations

PowerShell Strings - String manipulation
PowerShell Replace Strings - String replacement
PowerShell Replace Text - Text operations

Display & Formatting

PowerShell Format Table - Format output table
PowerShell Output Table - Create tables
PowerShell Format List - List format display

Control Flow & Logic

PowerShell If-Else Statement - Conditional logic
PowerShell Switch Statement - Switch logic
PowerShell For Loops - Iterate with loops
PowerShell Try-Catch - Error handling

Variables & Collections

PowerShell Variables - Store file data
PowerShell Arrays - Work with file arrays
PowerShell Hashtables - Store file mappings
PowerShell Add-Member - Add custom properties

Output & Export

PowerShell Output to File - Write to files
PowerShell Export CSV - Export to CSV
PowerShell Import CSV - Import from CSV
PowerShell Write-Output - Display output

File Content Operations

PowerShell Get-Content - Read file contents
PowerShell Get First Line - Read first line
PowerShell Get-Content Skip First Line - Skip lines
PowerShell Get-Content Remove First Line - Remove header

Functions & Automation

PowerShell Functions - Create reusable functions
PowerShell Measure-Object - Calculate statistics
PowerShell Group-Object - Group files

Comprehensive Guides

Complete PowerShell Guide - Full PowerShell reference
Complete PowerShell Tutorial - Comprehensive course