Working with Files and Directories in PowerShell

File and directory management is one of the most common tasks in system administration and automation. PowerShell provides powerful cmdlets that make it easy to navigate, create, move, copy, and delete files and directories. In this guide, we’ll explore the essential commands for file system operations.

Essential File System Cmdlets

PowerShell uses a consistent verb-noun naming convention for its cmdlets. Here are the key cmdlets for file and directory operations:

Get-ChildItem: List files and directories (similar to ls or dir)
Set-Location: Change current directory (similar to cd)
New-Item: Create files and directories
Copy-Item: Copy files and directories
Move-Item: Move or rename files and directories
Remove-Item: Delete files and directories
Test-Path: Check if a path exists
Get-Item: Get information about a specific item

Navigating the File System

Getting Your Current Location

# Get current directory
Get-Location
# or use the variable
$pwd

# Get the current location as a string
$currentPath = (Get-Location).Path
Write-Output "Currently in: $currentPath"

Changing Directories

# Change to a specific directory
Set-Location -Path "C:\Windows"
# or use the alias
cd "C:\Users"

# Go up one level
cd ..

# Go to home directory
cd ~

# Go back to previous location
cd -

# Change to root of current drive
cd \

# Other aliasses are: sl and chdir

Listing Files and Directories with Get-ChildItem

Get-ChildItem is one of the most versatile cmdlets for exploring the file system.

# Basic listing (current directory)
Get-ChildItem
# or use aliases
ls
dir
gci

# List specific directory
Get-ChildItem -Path "C:\Windows\System32" | Select-Object -First 10

# List with detailed information
Get-ChildItem | Format-Table Name, Length, LastWriteTime

# Show hidden and system files
Get-ChildItem -Force

# Recursive listing (subdirectories too)
Get-ChildItem -Recurse -Depth 2

Filtering with Get-ChildItem

# Filter by file extension
Get-ChildItem -Filter "*.txt"
Get-ChildItem -Path "C:\Windows" -Filter "*.exe" | Select-Object -First 5

# Filter by name pattern
Get-ChildItem -Name "*log*"

# Show only directories
Get-ChildItem -Directory

# Show only files
Get-ChildItem -File

# Filter by attributes
Get-ChildItem -Attributes Hidden
Get-ChildItem -Attributes ReadOnly,!Hidden  # ReadOnly but not Hidden

Advanced Filtering Examples

# Find large files (over 1MB)
Get-ChildItem -File | Where-Object {$_.Length -gt 1MB} |
    Sort-Object Length -Descending |
    Select-Object Name, @{Name="SizeMB";Expression={[math]::Round($_.Length/1MB,2)}} -First 5

# Find recently modified files (last 7 days)
$lastWeek = (Get-Date).AddDays(-7)
Get-ChildItem -File | Where-Object {$_.LastWriteTime -gt $lastWeek} |
    Sort-Object LastWriteTime -Descending |
    Select-Object Name, LastWriteTime -First 5

# Find empty directories
Get-ChildItem -Directory -Recurse | Where-Object {
    (Get-ChildItem $_.FullName -Force | Measure-Object).Count -eq 0
} | Select-Object -First 3

Creating Files and Directories with New-Item

The New-Item cmdlet can create both files and directories.

# Create a new directory
New-Item -ItemType Directory -Path "C:\Temp\TestFolder"

# Create multiple directories at once
New-Item -ItemType Directory -Path "C:\Temp\Project\Docs", "C:\Temp\Project\Scripts"

# Create a directory structure (Force creates parent directories)
New-Item -ItemType Directory -Path "C:\Temp\Deep\Nested\Folder\Structure" -Force

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

# Create a file with content
New-Item -ItemType File -Path "C:\Temp\greeting.txt" -Value "Hello, PowerShell!"

# Create multiple files
"file1.txt", "file2.txt", "file3.txt" | ForEach-Object {
    New-Item -ItemType File -Path "C:\Temp$_" -Force
}

Copying Files and Directories with Copy-Item

Copy-Item allows you to duplicate files and entire directory structures.

# Copy a single file
Copy-Item -Path "C:\Temp\test.txt" -Destination "C:\Temp\test_copy.txt"

# Copy a file to a different directory
Copy-Item -Path "C:\Temp\test.txt" -Destination "C:\Temp\TestFolder\"

# Copy multiple files using wildcards
Copy-Item -Path "C:\Temp\*.txt" -Destination "C:\Temp\TestFolder\"

# Copy a directory and all its contents
Copy-Item -Path "C:\Temp\TestFolder" -Destination "C:\Temp\TestFolderCopy" -Recurse

# Copy with overwrite protection
Copy-Item -Path "C:\Temp\test.txt" -Destination "C:\Temp\backup.txt" -PassThru

# Copy and rename in one operation
Copy-Item -Path "C:\Temp\test.txt" -Destination "C:\Temp\renamed_file.txt"

Backup Example

# Create a backup function
function Backup-Files {
    param(
        [string]$SourcePath,
        [string]$BackupPath
    )

    $timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
    $backupFolder = Join-Path $BackupPath "Backup_$timestamp"

    if (Test-Path $SourcePath) {
        Write-Output "Creating backup of '$SourcePath' to '$backupFolder'"
        Copy-Item -Path $SourcePath -Destination $backupFolder -Recurse -Force
        Write-Output "Backup completed successfully!"
    } else {
        Write-Warning "Source path '$SourcePath' does not exist!"
    }
}

# Example usage (uncomment to run)
# Backup-Files -SourcePath "C:\Temp\TestFolder" -BackupPath "C:\Temp\Backups"

Moving and Renaming with Move-Item

Move-Item can both move files/directories to new locations and rename them.

# Move a file to a different directory
Move-Item -Path "C:\Temp\test.txt" -Destination "C:\Temp\TestFolder\"

# Rename a file (move to same directory with new name)
Move-Item -Path "C:\Temp\greeting.txt" -Destination "C:\Temp\welcome.txt"

# Move and rename in one operation
Move-Item -Path "C:\Temp\file1.txt" -Destination "C:\Temp\TestFolder\renamed_file1.txt"

# Move multiple files
Get-ChildItem -Path "C:\Temp\*.txt" | Move-Item -Destination "C:\Temp\TestFolder\"

# Move a directory
Move-Item -Path "C:\Temp\TestFolderCopy" -Destination "C:\Temp\MovedFolder"

Bulk Rename Example

# Bulk rename files - add prefix
Get-ChildItem -Path "C:\Temp\TestFolder\*.txt" | ForEach-Object {
    $newName = "PREFIX_" + $_.Name
    $newPath = Join-Path $_.Directory $newName
    Move-Item -Path $_.FullName -Destination $newPath
}

# Bulk rename files - change extension
Get-ChildItem -Path "C:\Temp\TestFolder\*.txt" | ForEach-Object {
    $newName = $_.BaseName + ".log"
    $newPath = Join-Path $_.Directory $newName
    Move-Item -Path $_.FullName -Destination $newPath
}

Deleting Files and Directories with Remove-Item

Remove-Item is used to delete files and directories. Use with caution!

# Delete a single file
Remove-Item -Path "C:\Temp\welcome.txt"

# Delete multiple files using wildcards
Remove-Item -Path "C:\Temp\*.log"

# Delete a directory and all contents
Remove-Item -Path "C:\Temp\TestFolder" -Recurse

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

# Force delete (bypass confirmation and remove read-only files)
Remove-Item -Path "C:\Temp\TestFolder" -Recurse -Force

# Delete files older than 30 days
$cutoffDate = (Get-Date).AddDays(-30)
Get-ChildItem -Path "C:\Temp" -File |
    Where-Object {$_.LastWriteTime -lt $cutoffDate} |
    Remove-Item -WhatIf  # Use -WhatIf to preview what would be deleted

Safe Delete Function

function Remove-SafelyWithBackup {
    param(
        [string]$Path,
        [string]$BackupLocation = "C:\Temp\RecycleBin"
    )

    if (-not (Test-Path $Path)) {
        Write-Warning "Path '$Path' does not exist!"
        return
    }

    # Create backup location if it doesn't exist
    if (-not (Test-Path $BackupLocation)) {
        New-Item -ItemType Directory -Path $BackupLocation -Force
    }

    # Create timestamped backup
    $timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
    $item = Get-Item $Path
    $backupName = "$($item.Name)_deleted_$timestamp"
    $backupPath = Join-Path $BackupLocation $backupName

    # Move to backup location instead of deleting
    Move-Item -Path $Path -Destination $backupPath
    Write-Output "Item moved to backup: $backupPath"
}

# Example usage (uncomment to test)
# Remove-SafelyWithBackup -Path "C:\Temp\SomeFile.txt"

Testing Path Existence with Test-Path

Test-Path is essential for safe file operations – always check if something exists before operating on it.

# Test if a file exists
if (Test-Path "C:\Windows\System32\notepad.exe") {
    Write-Output "Notepad exists!"
} else {
    Write-Output "Notepad not found!"
}

# Test if a directory exists
$testDir = "C:\Temp\TestDirectory"
if (Test-Path $testDir) {
    Write-Output "Directory '$testDir' exists"
} else {
    Write-Output "Creating directory '$testDir'"
    New-Item -ItemType Directory -Path $testDir
}

# Test path type
if (Test-Path "C:\Windows" -PathType Container) {
    Write-Output "C:\Windows is a directory"
}

if (Test-Path "C:\Windows\System32\notepad.exe" -PathType Leaf) {
    Write-Output "notepad.exe is a file"
}

# Test with wildcards
if (Test-Path "C:\Windows\*.exe") {
    Write-Output "EXE files found in C:\Windows"
}

Getting Item Information with Get-Item

Get-Item retrieves detailed information about files and directories.

# Get detailed information about a file
$file = Get-Item "C:\Windows\System32\notepad.exe"
$file | Select-Object Name, Length, CreationTime, LastWriteTime, Attributes

# Get information about a directory
$dir = Get-Item "C:\Windows"
$dir | Select-Object Name, CreationTime, Attributes

# Get file version information
$notepad = Get-Item "C:\Windows\System32\notepad.exe"
$version = $notepad.VersionInfo
Write-Output "Notepad version: $($version.FileVersion)"

# Check file attributes
$attributes = (Get-Item "C:\Windows\System32\notepad.exe").Attributes
Write-Output "Notepad attributes: $attributes"

if ($attributes -band [System.IO.FileAttributes]::ReadOnly) {
    Write-Output "File is read-only"
} else {
    Write-Output "File is not read-only"
}

Practical Real-World Examples

Let’s put it all together with some practical scenarios you might encounter.

# Example 1: Clean up temporary files
function Clear-TempFiles {
    param(
        [int]$DaysOld = 7,
        [switch]$WhatIf
    )

    $tempPaths = @(
        $env:TEMP,
        "C:\Windows\Temp"
    )

    $cutoffDate = (Get-Date).AddDays(-$DaysOld)

    foreach ($tempPath in $tempPaths) {
        if (Test-Path $tempPath) {
            Write-Output "Cleaning: $tempPath"

            Get-ChildItem -Path $tempPath -File -Recurse |
                Where-Object {$_.LastWriteTime -lt $cutoffDate} |
                ForEach-Object {
                    if ($WhatIf) {
                        Write-Output "Would delete: $($_.FullName)"
                    } else {
                        Remove-Item $_.FullName -Force -ErrorAction SilentlyContinue
                        Write-Output "Deleted: $($_.Name)"
                    }
                }
        }
    }
}

# Run with -WhatIf to see what would be deleted
Clear-TempFiles -DaysOld 7 -WhatIf

# Example 2: Organize files by extension
function Organize-FilesByExtension {
    param(
        [string]$SourcePath,
        [string]$DestinationPath
    )

    if (-not (Test-Path $SourcePath)) {
        Write-Warning "Source path does not exist: $SourcePath"
        return
    }

    if (-not (Test-Path $DestinationPath)) {
        New-Item -ItemType Directory -Path $DestinationPath -Force
    }

    Get-ChildItem -Path $SourcePath -File | ForEach-Object {
        $extension = $_.Extension.TrimStart('.').ToUpper()
        if ([string]::IsNullOrEmpty($extension)) { $extension = "NO_EXTENSION" }

        $extensionFolder = Join-Path $DestinationPath $extension

        if (-not (Test-Path $extensionFolder)) {
            New-Item -ItemType Directory -Path $extensionFolder -Force
            Write-Output "Created folder: $extension"
        }

        $destinationFile = Join-Path $extensionFolder $_.Name
        Copy-Item -Path $_.FullName -Destination $destinationFile
        Write-Output "Moved $($_.Name) to $extension folder"
    }
}

# Example usage (uncomment to test)
# Organize-FilesByExtension -SourcePath "C:\Temp" -DestinationPath "C:\Temp\Organized"

# Example 3: Find duplicate files
function Find-DuplicateFiles {
    param([string]$Path)

    if (-not (Test-Path $Path)) {
        Write-Warning "Path does not exist: $Path"
        return
    }

    Write-Output "Searching for duplicate files in: $Path"

    $files = Get-ChildItem -Path $Path -File -Recurse
    $duplicates = $files | Group-Object -Property Length | Where-Object {$_.Count -gt 1}

    foreach ($group in $duplicates) {
        $sameSize = $group.Group
        Write-Output "`nFiles with size $($group.Name) bytes:"

        # Group by hash to find true duplicates
        $hashGroups = $sameSize | Group-Object -Property {
            (Get-FileHash $_.FullName -Algorithm MD5).Hash
        } | Where-Object {$_.Count -gt 1}

        foreach ($hashGroup in $hashGroups) {
            Write-Output "  Duplicate set:"
            $hashGroup.Group | ForEach-Object {
                Write-Output "    $($_.FullName)"
            }
        }
    }
}

# Example usage (uncomment to test)
# Find-DuplicateFiles -Path "C:\Temp"

Best Practices and Tips

1. Always Use Test-Path

Before performing operations on files or directories, always check if they exist.

2. Use -WhatIf for Destructive Operations

When using cmdlets that delete or modify files, use the -WhatIf parameter to preview changes.

3. Handle Errors Gracefully

Use error handling to manage situations where files are locked or permissions are insufficient.

# Error handling example
function Safe-FileOperation {
    param([string]$FilePath)

    try {
        if (Test-Path $FilePath) {
            $file = Get-Item $FilePath
            Write-Output "File: $($file.Name), Size: $($file.Length) bytes"
        } else {
            Write-Warning "File not found: $FilePath"
        }
    }
    catch {
        Write-Error "Error accessing file: $($_.Exception.Message)"
    }
}

# Test with a file that exists and one that doesn't
Safe-FileOperation -FilePath "C:\Windows\System32\notepad.exe"
Safe-FileOperation -FilePath "C:\NonExistent\File.txt"

4. Use Proper Path Handling

# Good path handling practices
$basePath = "C:\Temp"
$fileName = "test.txt"

# Use Join-Path instead of string concatenation
$fullPath = Join-Path $basePath $fileName  # Good
$badPath = $basePath + "\\" + $fileName     # Avoid this

Write-Output "Proper path: $fullPath"

# Handle relative paths
$relativePath = ".\TestFolder\file.txt"
$absolutePath = Resolve-Path $relativePath -ErrorAction SilentlyContinue
if ($absolutePath) {
    Write-Output "Absolute path: $absolutePath"
}

# Cross-platform path handling
$crossPlatformPath = Join-Path "folder" "subfolder" "file.txt"
Write-Output "Cross-platform path: $crossPlatformPath"

Conclusion

PowerShell’s file and directory management cmdlets provide powerful and flexible ways to work with the file system. Whether you’re performing simple file operations or complex automation tasks, these cmdlets form the foundation of effective file management.

Key Takeaways:

Use Get-ChildItem for listing and filtering files and directories
Use New-Item to create files and directories
Use Copy-Item and Move-Item for file operations
Use Remove-Item carefully for deletion (consider using -WhatIf first)
Always use Test-Path to check existence before operations
Use Get-Item for detailed file/directory information
Handle errors gracefully with try/catch blocks
Use Join-Path for proper path construction

Master these cmdlets and techniques, and you’ll be able to automate virtually any file system task with confidence and reliability!