PowerShell scripting for file management

Of course. While Robocopy is a fantastic tool for specific copy tasks, PowerShell provides a more holistic, programmable, and integrated approach to file management in Windows. It treats files and directories as objects you can filter, sort, manipulate, and act upon with incredible precision.

Core Concepts: Cmdlets and the Pipeline

PowerShell’s power comes from its cmdlets (pronounced “command-lets”) and the pipeline (|). You get objects out of one command and pipe them into the next.

Essential File Management Cmdlets:

Cmdlet	Purpose	Basic Example
Get-ChildItem (gci, dir, ls)	Lists items in a path. The workhorse for discovery.	Get-ChildItem C:\Temp
Copy-Item (copy, cp)	Copies files and directories.	Copy-Item file.txt destination\
Move-Item (move, mv)	Moves files and directories.	Move-Item file.txt newfolder\
Remove-Item (del, rm, rd)	Deletes files and directories.	Remove-Item file.txt
Rename-Item (ren)	Renames a single item.	Rename-Item old.txt new.txt
New-Item (ni)	Creates a new file or directory.	New-Item -ItemType Directory -Path .\NewFolder
Get-Content (gc, cat)	Reads the content of a file.	Get-Content log.txt
Set-Content (sc)	Writes content to a file.	"Hello" | Set-Content file.txt
Test-Path	Checks if a path exists. Great for scripts.	if (Test-Path .\file.txt) { ... }

---

Practical Examples & Scripting Concepts

Let’s move beyond basic commands and into true scripting.

1. Advanced Filtering and Discovery

The real power of Get-ChildItem is filtering with parameters and the Where-Object cmdlet.

Find all PDF files modified in the last 7 days:

Get-ChildItem -Path C:\Data -Filter *.pdf -File -Recurse | 
    Where-Object LastWriteTime -gt (Get-Date).AddDays(-7)

• -File: Only returns files, not directories.
• -Recurse: Searches through all subdirectories.
• |: Pipes the results to the next command.
• Where-Object: Filters the list to items where LastWriteTime is greater than (-gt) 7 days ago.

Find files larger than 100MB:

Get-ChildItem -Path . -Recurse -File | Where-Object Length -gt 100MB

2. Bulk Operations (The Power of the Pipeline)

You can perform actions on a whole collection of files at once.

Copy all .txt files from a folder and its subfolders to a single destination:

Get-ChildItem -Path C:\Source -Filter *.txt -File -Recurse | 
    Copy-Item -Destination C:\AllTextFiles\

Delete all .tmp files in the Temp directory (be careful!):

Get-ChildItem -Path $env:TEMP -Filter *.tmp -File -Recurse | 
    Remove-Item -Force

• $env:TEMP uses an environment variable for the system’s Temp folder path.
• -Force deletes read-only or hidden files.

3. Conditional Logic and Scripting

You can build robust scripts that make decisions.

Script to archive files older than 365 days:

# Define paths
$SourceFolder = "C:\Logs"
$ArchiveFolder = "D:\ArchivedLogs"

# Check if archive folder exists, if not, create it
if (-not (Test-Path -Path $ArchiveFolder)) {
    New-Item -ItemType Directory -Path $ArchiveFolder | Out-Null
}

# Find and move old files
$OldFiles = Get-ChildItem -Path $SourceFolder -File -Recurse | 
            Where-Object LastWriteTime -lt (Get-Date).AddDays(-365)

foreach ($File in $OldFiles) {
    # Create a subdirectory structure in the archive
    $SubPath = $File.DirectoryName.Replace($SourceFolder, "").TrimStart('\')
    $TargetDir = Join-Path -Path $ArchiveFolder -ChildPath $SubPath

    if (-not (Test-Path -Path $TargetDir)) {
        New-Item -ItemType Directory -Path $TargetDir | Out-Null
    }

    Move-Item -Path $File.FullName -Destination $TargetDir -Force
    Write-Host "Archived: $($File.Name)"
}

4. Data Processing

Read files, process the data, and output results.

Parse a log file for errors and save them to a new file:

Get-Content -Path C:\App\app.log -Tail 1000 | 
    Where-Object { $_ -match "ERROR" } | 
    Set-Content -Path C:\App\errors.txt

• -Tail 1000: Only reads the last 1000 lines of the log (efficient for large files).
• -match "ERROR": Uses regex to filter lines containing the word “ERROR”.

5. Using -WhatIf for Safety

Always test your destructive commands first! The -WhatIf parameter shows what would happen without actually doing it. This is your best friend, like Robocopy’s /L.

# See what would be deleted before doing it
Get-ChildItem -Path . -Filter *.bak -Recurse | Remove-Item -WhatIf

# If the list looks correct, run it for real
Get-ChildItem -Path . -Filter *.bak -Recurse | Remove-Item

---

Comparison: Robocopy vs. PowerShell

Feature	Robocopy	PowerShell
Primary Strength	Bulk file transfer, mirroring, sync	Object-oriented management, filtering, automation
Speed	Extremely fast and efficient at copying	Can be slower for raw file copy operations
Resilience	Excellent: restartable mode, retry logic	Basic, must be scripted manually
Filtering	Good (by name, size, attribute)	Excellent (by any property: date, size, content, etc.)
Complexity	Complex, single-purpose command	Programmable, can combine with other system tasks
Logging	Built-in, detailed logging	Must be implemented via Start-Transcript or Write-Host/Write-Output

Recommendation:

• Use Robocopy for large, complex copy/mirror/sync jobs, especially over a network. It’s the right tool for that job.
• Use PowerShell for everything else: complex filtering, automated cleanup based on logic, reading file content, managing permissions as objects, and integrating file management into larger automated workflows.