Working with Files and Folders

The Log File That Taught Me Everything

Three years ago, I was troubleshooting a mysterious application crash that only happened in production. The only clue was buried in 50GB of log files spread across multiple servers, spanning 3 months. Manual searching was impossible.

I wrote my first PowerShell script to search those logs:

Get-ChildItem -Path "\\server\logs" -Filter "*.log" -Recurse |
    Select-String -Pattern "Exception|Error" -Context 2, 5 |
    Export-Csv errors.csv

In 15 minutes, I had every error from 3 months of logs with context lines. The pattern that emerged led me to the root cause within an hour. That script saved me days of manual log review and taught me the power of automated file operations.

Understanding Paths in PowerShell

PowerShell works with file system paths across Windows, macOS, and Linux.

Current Location

# Get current directory
Get-Location
pwd  # Alias

# Change directory
Set-Location -Path "C:\Users"
cd "C:\Users"  # Alias

# Go to parent directory
Set-Location ..
cd ..

# Go to home directory
Set-Location ~
cd ~

# Go back to previous location
Set-Location -
cd -

# Push and pop locations (directory stack)
Push-Location "C:\Windows"  # Save current, go to new
Pop-Location                 # Return to saved

Path Formats

# Windows paths (backward slash)
"C:\Users\John\Documents"

# Unix-style paths (PowerShell handles both on Windows)
"C:/Users/John/Documents"

# UNC paths (network shares)
"\\server\share\folder"

# Relative paths
".\subfolder\file.txt"      # Current directory
"..\parent\file.txt"        # Parent directory

# Home directory
"~\Documents"               # Current user home

Working with Paths

# Join paths (handles separators)
Join-Path -Path "C:\Users" -ChildPath "John\Documents"

# Split paths
Split-Path -Path "C:\Users\John\file.txt" -Parent    # C:\Users\John
Split-Path -Path "C:\Users\John\file.txt" -Leaf      # file.txt

# Test if path exists
Test-Path -Path "C:\Users\John"  # True or False

# Get absolute path
Resolve-Path -Path ".\file.txt"

# Convert to absolute path
$ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath(".\file.txt")

Navigating and Exploring

Listing Files and Folders

# List current directory
Get-ChildItem
ls   # Alias
dir  # Alias

# List specific path
Get-ChildItem -Path "C:\Windows"

# Include hidden files
Get-ChildItem -Force

# Recursive listing
Get-ChildItem -Recurse

# Filter by name
Get-ChildItem -Filter "*.txt"
Get-ChildItem -Filter "test*"

# Only files
Get-ChildItem -File

# Only directories
Get-ChildItem -Directory

# Exclude items
Get-ChildItem -Exclude "*.log"

Advanced Filtering

# Files modified in last 7 days
Get-ChildItem | Where-Object {$_.LastWriteTime -gt (Get-Date).AddDays(-7)}

# Files larger than 100MB
Get-ChildItem -Recurse -File | Where-Object {$_.Length -gt 100MB}

# Find specific file types
Get-ChildItem -Recurse | Where-Object {$_.Extension -in '.txt', '.log', '.csv'}

# Empty directories
Get-ChildItem -Recurse -Directory | Where-Object {-not $_.GetFileSystemInfos()}

Creating and Deleting

Creating Items

# Create directory
New-Item -Path "C:\Temp\NewFolder" -ItemType Directory

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

# Create file with content
New-Item -Path "C:\Temp\config.txt" -ItemType File -Value "Initial content"

# Create multiple directories
New-Item -Path "C:\Temp\Project\{Src,Tests,Docs}" -ItemType Directory

# Create file and parent directories
New-Item -Path "C:\Temp\Deep\Nested\file.txt" -ItemType File -Force

Deleting Items

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

# Delete directory
Remove-Item -Path "C:\Temp\OldFolder" -Recurse

# Delete with confirmation
Remove-Item -Path "C:\Temp\*" -Confirm

# Delete without confirmation (careful!)
Remove-Item -Path "C:\Temp\test.txt" -Force

# Preview deletion with -WhatIf
Remove-Item -Path "C:\Temp\*.log" -WhatIf

# Delete empty directories
Get-ChildItem -Recurse -Directory | 
    Where-Object {-not $_.GetFileSystemInfos()} |
    Remove-Item

Copying and Moving

Copying Files and Folders

# Copy file
Copy-Item -Path "source.txt" -Destination "destination.txt"

# Copy to directory
Copy-Item -Path "file.txt" -Destination "C:\Backup\"

# Copy directory recursively
Copy-Item -Path "C:\Source" -Destination "C:\Backup" -Recurse

# Copy multiple files
Copy-Item -Path "C:\Source\*.txt" -Destination "C:\Backup\"

# Copy with filter
Get-ChildItem -Filter "*.log" | Copy-Item -Destination "C:\Logs\"

# Copy and rename
Copy-Item -Path "old-config.txt" -Destination "new-config.txt"

Moving Files and Folders

# Move file
Move-Item -Path "source.txt" -Destination "C:\NewLocation\"

# Move and rename
Move-Item -Path "old-name.txt" -Destination "new-name.txt"

# Move directory
Move-Item -Path "C:\OldFolder" -Destination "C:\NewLocation\"

# Move with filter
Get-ChildItem -Filter "*.bak" | Move-Item -Destination "C:\Backup\"

Renaming Items

# Rename file
Rename-Item -Path "old.txt" -NewName "new.txt"

# Rename directory
Rename-Item -Path "OldFolder" -NewName "NewFolder"

# Bulk rename with pattern
Get-ChildItem -Filter "*.txt" | ForEach-Object {
    Rename-Item -Path $_.FullName -NewName ($_.Name -replace "old", "new")
}

# Add prefix to all files
Get-ChildItem | Rename-Item -NewName {"backup_" + $_.Name}

# Change extension
Get-ChildItem -Filter "*.txt" | Rename-Item -NewName {$_.Name -replace "\.txt$", ".log"}

Reading Files

Reading Entire File

# Read file as array of lines
$content = Get-Content -Path "file.txt"

# Read as single string
$content = Get-Content -Path "file.txt" -Raw

# Read first 10 lines
Get-Content -Path "file.txt" -TotalCount 10
Get-Content -Path "file.txt" -Head 10  # Alias

# Read last 10 lines
Get-Content -Path "file.txt" -Tail 10

# Monitor file (like tail -f)
Get-Content -Path "app.log" -Wait -Tail 10

Reading Specific Encoding

# Read UTF8
Get-Content -Path "file.txt" -Encoding UTF8

# Read ASCII
Get-Content -Path "file.txt" -Encoding ASCII

# Read Unicode
Get-Content -Path "file.txt" -Encoding Unicode

Searching File Content

# Search for pattern
Select-String -Path "file.txt" -Pattern "error"

# Search multiple files
Select-String -Path "*.log" -Pattern "exception"

# Case-sensitive search
Select-String -Path "file.txt" -Pattern "Error" -CaseSensitive

# Search recursively
Select-String -Path "*.txt" -Pattern "TODO" -Recurse

# Get context lines
Select-String -Path "app.log" -Pattern "Error" -Context 2, 5  # 2 before, 5 after

# Search with regex
Select-String -Path "file.txt" -Pattern "^\d{4}-\d{2}-\d{2}"

Writing Files

Writing Content

# Write to file (overwrites)
Set-Content -Path "output.txt" -Value "Hello, World!"

# Append to file
Add-Content -Path "log.txt" -Value "New log entry"

# Write array to file (each element on new line)
$data = @("Line 1", "Line 2", "Line 3")
Set-Content -Path "file.txt" -Value $data

# Write with specific encoding
Set-Content -Path "file.txt" -Value "Content" -Encoding UTF8

# Out-File (another way to write)
"Hello" | Out-File -FilePath "output.txt"
Get-Process | Out-File -FilePath "processes.txt"

# Append with Out-File
"New line" | Out-File -FilePath "file.txt" -Append

Writing Formatted Data

# Write command output
Get-Process | Out-File -FilePath "processes.txt"

# Write with specific width
Get-Process | Out-File -FilePath "processes.txt" -Width 200

# Write without headers
Get-Service | Select-Object Name, Status | Out-File -FilePath "services.txt" -NoNewline

Working with CSV Files

CSV files are perfect for tabular data.

Importing CSV

# Import CSV
$data = Import-Csv -Path "users.csv"

# Import with different delimiter
$data = Import-Csv -Path "data.txt" -Delimiter "`t"  # Tab-delimited

# Import without headers (uses column numbers)
$data = Import-Csv -Path "data.csv" -Header "Name", "Email", "Department"

# Access data
$data[0].Name
$data | Where-Object {$_.Department -eq "IT"}

Exporting CSV

# Export to CSV
Get-Process | Select-Object Name, CPU, WorkingSet | 
    Export-Csv -Path "processes.csv" -NoTypeInformation

# Export with specific delimiter
$data | Export-Csv -Path "data.txt" -Delimiter "`t" -NoTypeInformation

# Append to CSV
Get-Service | Select-Object Name, Status | 
    Export-Csv -Path "services.csv" -Append -NoTypeInformation

# Convert to CSV string (not file)
$csvString = Get-Process | Select-Object Name, CPU | ConvertTo-Csv -NoTypeInformation

CSV Real-World Example

# Read server list
$servers = Import-Csv -Path "servers.csv"
# servers.csv has columns: ServerName, IP, Environment

# Check each server
$results = foreach ($server in $servers) {
    [PSCustomObject]@{
        ServerName = $server.ServerName
        IP = $server.IP
        Environment = $server.Environment
        Pingable = Test-Connection -ComputerName $server.IP -Count 1 -Quiet
        LastCheck = Get-Date
    }
}

# Export results
$results | Export-Csv -Path "server-status.csv" -NoTypeInformation

Working with JSON Files

JSON is great for structured configuration data.

Importing JSON

# Import JSON
$config = Get-Content -Path "config.json" -Raw | ConvertFrom-Json

# Access properties
$config.database.server
$config.api.endpoint

# Import array of objects
$users = Get-Content -Path "users.json" -Raw | ConvertFrom-Json
$users | Where-Object {$_.active -eq $true}

Exporting JSON

# Export to JSON
$config = @{
    database = @{
        server = "SQLSERVER01"
        port = 1433
        name = "ProductionDB"
    }
    api = @{
        endpoint = "https://api.example.com"
        timeout = 30
    }
}

$config | ConvertTo-Json -Depth 3 | Out-File -FilePath "config.json"

# Export with formatting
Get-Process | Select-Object Name, CPU, WorkingSet | 
    ConvertTo-Json | Out-File -FilePath "processes.json"

# Pretty print JSON
$config | ConvertTo-Json -Depth 5 | Set-Content -Path "config.json"

Working with XML Files

Importing XML

# Import XML
[xml]$xml = Get-Content -Path "config.xml"

# Access elements
$xml.configuration.appSettings.add

# XPath queries
$xml.SelectNodes("//appSettings/add[@key='ServerName']")

# Iterate XML
foreach ($item in $xml.configuration.appSettings.add) {
    Write-Host "$($item.key) = $($item.value)"
}

Creating XML

# Create XML
$xml = New-Object System.Xml.XmlDocument
$root = $xml.CreateElement("Configuration")
$xml.AppendChild($root)

$setting = $xml.CreateElement("Setting")
$setting.SetAttribute("Name", "ServerName")
$setting.SetAttribute("Value", "SERVER01")
$root.AppendChild($setting)

# Save XML
$xml.Save("C:\config.xml")

# Export objects to XML
Get-Service | Export-Clixml -Path "services.xml"
$services = Import-Clixml -Path "services.xml"

Real-World File Operations

Log Analysis Script

# Analyze application logs
$logPath = "C:\Logs"
$startDate = (Get-Date).AddDays(-7)

$errors = Get-ChildItem -Path $logPath -Filter "*.log" -Recurse |
    Where-Object {$_.LastWriteTime -gt $startDate} |
    ForEach-Object {
        Select-String -Path $_.FullName -Pattern "ERROR|EXCEPTION" -Context 0, 3
    }

# Group errors by type
$errorReport = $errors | ForEach-Object {
    [PSCustomObject]@{
        File = $_.Filename
        Line = $_.LineNumber
        Error = $_.Line
        Context = $_.Context.PostContext -join "`n"
    }
} | Group-Object Error | Select-Object Count, Name

$errorReport | Export-Csv -Path "error-analysis.csv" -NoTypeInformation

Backup Script

# Backup important files
$sourcePath = "C:\Important"
$backupPath = "\\BackupServer\Backups\$(Get-Date -Format 'yyyy-MM-dd')"

# Create backup directory
New-Item -Path $backupPath -ItemType Directory -Force

# Copy files modified in last 24 hours
Get-ChildItem -Path $sourcePath -Recurse -File |
    Where-Object {$_.LastWriteTime -gt (Get-Date).AddHours(-24)} |
    ForEach-Object {
        $dest = $_.FullName.Replace($sourcePath, $backupPath)
        $destDir = Split-Path -Path $dest -Parent
        New-Item -Path $destDir -ItemType Directory -Force -ErrorAction SilentlyContinue
        Copy-Item -Path $_.FullName -Destination $dest -Force
    }

# Create backup manifest
Get-ChildItem -Path $backupPath -Recurse -File | 
    Select-Object FullName, Length, LastWriteTime |
    Export-Csv -Path "$backupPath\manifest.csv" -NoTypeInformation

File Organization

# Organize downloads by file type
$downloadsPath = "C:\Users\$env:USERNAME\Downloads"

$fileTypes = @{
    Images = @('*.jpg', '*.jpeg', '*.png', '*.gif')
    Documents = @('*.pdf', '*.docx', '*.xlsx', '*.pptx')
    Archives = @('*.zip', '*.rar', '*.7z')
    Videos = @('*.mp4', '*.avi', '*.mkv')
}

foreach ($type in $fileTypes.Keys) {
    $destPath = Join-Path -Path $downloadsPath -ChildPath $type
    New-Item -Path $destPath -ItemType Directory -Force -ErrorAction SilentlyContinue
    
    foreach ($pattern in $fileTypes[$type]) {
        Get-ChildItem -Path $downloadsPath -Filter $pattern -File | 
            Move-Item -Destination $destPath -ErrorAction SilentlyContinue
    }
}

Common Pitfalls

1. Forgetting to Use -Force for Nested Paths

Problem: Creating nested directories fails Solution: Use -Force to create parent directories

# Fails if parent doesn't exist
New-Item -Path "C:\Deep\Nested\Folder\file.txt" -ItemType File

# Works
New-Item -Path "C:\Deep\Nested\Folder\file.txt" -ItemType File -Force

2. Not Using -Raw When Needed

Problem: Get-Content returns array when you need string Solution: Use -Raw for single string

# Returns array of lines
$content = Get-Content -Path "file.txt"

# Returns single string
$content = Get-Content -Path "file.txt" -Raw

3. Forgetting -NoTypeInformation in CSV Export

Problem: CSV has type information header Solution: Always use -NoTypeInformation

# Includes #TYPE header
Export-Csv -Path "data.csv"

# Clean CSV
Export-Csv -Path "data.csv" -NoTypeInformation

4. Not Handling Errors in File Operations

Problem: Script stops on permission errors Solution: Use -ErrorAction

# Script continues on errors
Get-ChildItem -Path "C:\" -Recurse -ErrorAction SilentlyContinue

Key Takeaways

• Use Join-Path for cross-platform path handling

• Test-Path before operations on uncertain paths

• Get-ChildItem with filters is powerful for file discovery

• -WhatIf preview changes before destructive operations

• CSV and JSON are ideal for structured data

• Select-String is grep for PowerShell

• -Raw reads files as single string

• -Recurse processes directory trees

• Error handling prevents script failures

What You've Learned

✅ Navigating and exploring the file system ✅ Creating, copying, moving, and deleting files and folders ✅ Reading and writing files with various encodings ✅ Searching file content with Select-String ✅ Working with CSV, JSON, and XML files ✅ Real-world file operation patterns ✅ Common pitfalls and how to avoid them

Next Steps

Now that you can work with files and data, it's time to create reusable scripts. In PowerShell Scripting Basics, you'll discover:

• Creating .ps1 script files

• Script parameters and validation

• Execution policies

• Comment-based help

• Building production-ready scripts

Let's transform your PowerShell knowledge into reusable automation tools.

---

Ready to write scripts? Continue to PowerShell Scripting Basics →