As a routine task, users move items, such as files and folders from one place to another on our computer, so that data is sorted and makes sense. While this can be accomplished with simple copy and paste options from within the File Explorer, advanced users may prefer PowerShell for efficiency and precision.
Definition: Move-Item Cmdlet
The Move-Item cmdlet in PowerShell moves an item from one location to another in the File Explorer, with its properties, contents, and child items intact. It can be used as follows:
- Move a file or folder from one directory to another
- Move multiple files or directories at once
- Move a registry subkey from one key to another
Once added to the new location, a moved item is removed from its original location.
As a prerequisite, the new location must be supported by the same provider.
Basic Syntax of Move-Item
The Move-Item cmdlet has the following basic syntax:
Move-Item -Path "sourceFilePath" -Destination "destinationFilePath"
An example of the syntax with the supported parameters is:
Move-Item [-Path] <String[]> [[-Destination] <String>] [-Force] [-Filter <String>] [-Include <String[]>] [-Exclude <String[]>] [-PassThru] [-Credential <PSCredential>] [-WhatIf] [-Confirm] [<CommonParameters>]
Move a Single File with Move-Item
To move a single file from one location to another through PowerShell, specify the source file path and destination directory in the Move-Item cmdlet. It is as:
Move-Item -Path <source file path>\<file name> -Destination <Destination path>
You can also rename the file in the move process.
Scenario 1 – Move a single file without renaming it
This cmdlet moves the Test.txt file from the C:\Temp directory to the C:\Backup directory without renaming the file:
Move-Item -Path C:\Temp\test.txt -Destination C:\Backup
Scenario 2 – Move a single le and rename it in the move process
This cmdlet moves the Test.txt file from the C:\Temp directory to the C:\Backup directory while renaming it to UseCase.txt:
Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\UseCase.txt
Move Multiple Files
You can use wildcards in the Move-Item cmdlet to move multiple items at once, such as multiple files, from one location to another. For instance, you can easily move all files of the same extension from one location to another.
Scenario 1 – Move all files of the same extension using wildcards
This cmdlet moves all text files (*.txt) from the C:\Temp directory to the C:\Backup directory, leaving behind all other files:
Move-Item -Path C:\Temp\*.txt -Destination C:\Backup
Scenario 2 – Move all files regardless of extension
Use the Get-ChildItem cmdlet with the -File parameter to filter all files (and not folders) from the source directory. Then pipe the results to the Move-Item cmdlet to move the filtered files to the destination directory, leaving behind all folders.
In the following cmdlet, the -File parameter filters only the files in the C:\Temp directory. The Move-Item cmdlet then moves those files from C:\Temp to the C:\Backup directory, leaving folders in C:\Temp:
Get-ChildItem -Path C:\Temp\* -File | Move-Item -Destination C:\Backup
Scenario 3 – Move specific files
It is also possible to move specific files having the same or different extensions. In that case, you have to specify multiple files by providing an array of paths, using a comma to separate multiple values.
This cmdlet moves two files named Test.txt and UseCase.pdf from the C:\Temp folder to the C:\Backup folder:
Move-Item -Path C:\Temp\test.txt, C:\Temp\UseCase.pdf -Destination C:\Backup
Move a Directory
PowerShell’s Move-Item cmdlet is powerful enough to move a directory with all its contents – files, folders, sub-folders – to another directory. Or you can choose to move all content, leaving the empty directory behind. In both cases, the folder structure at the source is copied to the destination.
Scenario 1 – Move an entire directory with all its contents
This cmdlet moves the Temp folder with its contents to the C:\Backup folder.
Move-Item -Path C:\Temp -Destination C:\Backup
Notice that the Temp folder will be deleted from C:\ and placed in the Backup directory.
Scenario 2 –Move all content from a directory while leaving the directory behind
This cmdlet recursively moves all the files and folders from the Keys directory to the C:\Backup folder.
Move-Item -Path C:\Temp\Keys\* -Destination C:\Backup
Notice that in this case, the source directory (Keys) remains behind while all its content is moved. This cmdlet should leave the source directory empty.
Move Files to a Network Location
The Move-Item cmdlet can also move files to a network location. Simply provide the network path as the destination.
Consider the following:
- You must have the necessary permissions to access the network location.
- The network path must be accessible from the machine where you are running the cmdlet.
- You must do one of the following if the network location requires authentication:
- Map the network drive first using the New-PSDrive cmdlet or manually through Windows Explorer
- Specify credentials when accessing the network resource
Scenario 1 – Move a file to a network location
This cmdlet moves the Text.txt file from C:\Temp to a network location, which is a folder named Backup on a server named FileServer.
Move-Item -Path C:\Temp\test.txt -Destination \\FileServer\Backup
Scenario 2 –Prevent overwrite while moving a file
When moving a file to a network location with the Move-Item cmdlet, PowerShell will overwrite an existing file if the file name is the same, even when the -Force parameter is not provided.
To prevent overwriting, add a check before moving the file.
if (-not (Test-Path "\\FileServer\Backup\test.txt")) {
Move-Item -Path "C:\Temp\test.txt" -Destination "\\FileServer\Backup"
}
else {
Write-Host "A file with the same name already exists in the destination."
}
Test-Path checks if the file already exists in the destination. If yes, it will not move the file ad notify you instead.
Recursive File Moving
The PowerShell Move-Item cmdlet can also work with the -Recurse parameter to move all files from a directory and from all folders and sub-folders within it, to another location. You can also limit the move function to files of a specific extension.
Scenario 1 – Recursively move all files of the same extension
This cmdlet recursively moves all the PDF files from the C:\Temp directory and its sub-folders to the C:\Backup directory.
Get-ChildItem -Path C:\Temp\*.pdf -Recurse | Move-Item -Destination C:\Backup
Here, the Get-ChildItem cmdlet fetches the child items in the C:\Temp directory and its sub-folders that have a *.pdf file extension. It uses the -Recurse parameter to make the retrieval recursive.
The pipe (|) sends the results to the Move-Item cmdlet, that moves the pdf files to the Backup directory.
Note: By default, Get-ChildItem does not move hidden files. For that, use the -Force parameter with Get-ChildItem, and then pipe the results to Move-Item.
Scenario 2 – Recursively move all files
Use the -Recurse parameter with the Get-ChildItem cmdlet to recursively move files from one directory to another.
This cmdlet moves all files from the C:\Temp directory and its sub-directories to the C:\Backup directory. The -Recurse parameter is used to search through all sub-directories of the specified path while the -File parameter limits the cmdlet to retrieving files, excluding folders.
Get-ChildItem -Path C:\Temp -Recurse -File | Move-Item -Destination C:\Backup
Note that this cmdlet moves files only. No folder or sub-folder is affected. Moreover, the cmdlet moves the files to the root of the destination directory and does not create the folder structure of the source directory at the destination.
Filter Files
You can filter items based on specific criteria while moving them using the Move-Item cmdlet. For example, you may want to retain a specific file in the source directory or move files of a specific name or extension. The -Filter, -Include, and -Exclude parameters come in handy for such operations.
- The -Include parameter is used to include files that match a specific attribute, for moving. For example, you can specify file name(s) (c:\temp\test*) or extension(s) (*.txt) as attributes, so that only files matching the given attribute are moved to the destination location.
- The -Exclude parameter is used to exclude files that match a specific attribute, from being moved. For example, you can specify file name(s) (c:\temp\test*) or extension(s) (*.txt) as attributes, so that files matching the given attribute are not moved to the destination location.
- The -Filter parameter is similar to the -Include parameter but it is faster and more efficient than -Include.
Consider the following:
- You must use the whole folder content to include, exclude or filter specific data.
- These parameters can work with wildcards.
Note:
Before running the cmdlets provided in the scenarios below, make sure you are using the most recent PowerShell version. If not, then update your PowerShell version for smooth operations.
Scenario 1 – Exclude files of a specific extension
This cmdlet moves all files from the C:\Temp folder to the Backup folder except those that have a .txt extension.
Move-Item -Path C:\Temp\* -Exclude *.txt -Destination C:\Backup
Again, in the following cmdlet, the -Filter parameter will move all .docx files from C:\Temp to C:\Backup.
Move-Item -Path C:\Temp\* -Filter *.docx -Destination C:\Backup
Scenario 2 – Move files of a specific extension
This cmdlet moves only text files (.txt) from the C:\Temp folder to the Backup folder.
Move-Item -Path C:\Temp\* -Include *.txt -Destination C:\Backup
See the Move Multiple Files section for similar functions.
Scenario 3 – Move files having names that start with a specific string
This cmdlet moves files whose names start with “log”. It will not move files that do not start with “log” from C:\Temp.
Move-Item -Path C:\Temp\* -Include log* -Destination C:\Backup
Advanced Moving Scenarios
The Move-Item PowerShell cmdlet can also move files based on specific criteria, such as file size, date modified, and so on. For this purpose, you can choose any of these methods:
- Use the -Filter parameter
- Use Get-ChildItem with Where-Object to select files with specific attributes or date properties before moving them. It follows a three-step process:
- The Get-ChildItem cmdlet retrieves files from a source location.
- To filter for attributes, such as file size or last modified date, pipe the output to the Where-Object cmdlet.
- Next pipe the output to the Move-Item cmdlet to move the filtered files.
So, to move files larger than 5 GB, you find the files with Get-ChildItem, filter them with Where-Object and move them with Move-Item.
Scenario 1 – Move files and folders modified in the last X days
This cmdlet moves all files and folders modified in the last 30 days from the C:\Temp directory to the C:\RecentFiles directory.
Get-ChildItem -Path C:\Temp\* | Where-Object {$_.LastWriteTime -gt (Get-Date).AddDays(-30)} | Move-Item -Destination C:\RecentFiles
While you must be quite familiar with the Get-ChildItem and Move-Item cmdlets by now, let’s dive into Where-Object. This cmdlet filters the items modified in the last 30 days.
- $_ represents each object (file or folder) passed from Get-ChildItem.
- LastWriteTime is a property of the file/directory that shows the last time the item was modified or written to.
- (Get-Date).AddDays(-30) gets the current date and subtracts 30 days from it.
Scenario 2 – Move files and folders larger than a specific size
This cmdlet moves all files and folders that are larger than 2GB from the C:\Temp directory to the C:\LargeFiles directory.
Get-ChildItem -Path C:\Temp\* | Where-Object {$_.Length -gt 2GB} | Move-Item -Destination C:\LargeFiles
Maintain Folder Structure
The Move-Item cmdlet does not inherently copy or recreate the entire folder structure from the source to the destination path. However, there are certain ways to retain the folder structure while moving files to the destination:
- Combine the Move-Item cmdlet with other cmdlets, like Copy-Item and Remove-Item after verification
- Recreate the folder structure manually
Scenario 1 – Move a directory with its contents and folder structure intact
To move a directory with all its content and folder structure intact, see the Move a Directory section.
Scenario 2 – Move specific files while preserving folder structure
PowerShell supports more complex functions, where you can move specific files while recreating the folder structure at the destination.
This script moves specific files (e.g., .pdf files) while keeping the folder structure intact:
Get-ChildItem -Path "C:\Temp" -Recurse -Filter "*.pdf" | ForEach-Object {
$destinationPath = $_.FullName.Replace("C:\Temp", "C:\Backup")
$destinationDir = Split-Path $destinationPath
if (-not (Test-Path $destinationDir)) {
New-Item -ItemType Directory -Path $destinationDir
}
Move-Item -Path $_.FullName -Destination $destinationPath
}
Here, Get-ChildItem -Recurse gets all .pdf files in the source directory, including sub-folders. ForEach-Object loops through each file found.
Replace(“C:\Temp”, “C:\Backup”) adjusts the source path to create the corresponding path in the destination, and New-Item -ItemType Directory creates the folder structure if the destination directory does not exist.
Handle Overwrites
Occasionally, you may need to overwrite an existing file. For this purpose, use the -Force parameter with the PowerShell Move-Item cmdlet.
Scenario 1 – Overwrite a file at the destination
This cmdlet moves the test.txt file from the C:\Temp folder to the C:\Backup folder while overwriting any file that may exist at the destination with the same name.
Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\test.txt -Force
Scenario 2 – Overwrite a file at the destination after confirmation
Use the -Confirm parameter to get a confirmation prompt before overwriting files.
- This cmdlet displays a confirmation prompt if any of the PDF files already exist in the destination folder.
Move-Item -Path C:\Temp\*.pdf -Destination C:\Backup -Confirm -Force
- This cmdlet displays a confirmation prompt if the test.txt file already exists in the destination folder.
Move-Item -Path C:\Temp\test.txt -Destination C:\Backup -Confirm -Force
Type Y and press Enter to overwrite the files or type N and press Enter to skip them.
Test Commands Before Execution
Use the -WhatIf parameter with the Move-Item cmdlet to view the results, i.e., check what would happen if the cmdlet runs. With this parameter, the cmdlet does not run but expected results are displayed. You can therefore be confident that the cmdlet does not move any item that is otherwise not intended to be moved.
Scenario 1 – View the expected result of a cmdlet without running it
This cmdlet displays the results when you attempt to use the Move-Item cmdlet to move all items from the C:\Temp folder to the Backup folder.
Move-Item -Path C:\Temp\* -Destination C:\Backup -WhatIf
Error Handling and Logging
You should consider implementing error handling and logging when using PowerShell’s Move-Item cmdlet to ensure that the script behaves as expected, and any issues are easily tracked and identified. PowerShell provides:
- Try-Catch for error handling
- Write-Log to write to log files
Basic error handling with Try-Catch
Following is a basic Try-Catch block for moving a file with error handling:
Try {
Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\test.txt -ErrorAction Stop
} Catch {
Write-Output "Error moving file: $_"
}
Here’s what you need to know.
- The Try block attempts to run the Move-Item cmdlet.
- The -ErrorAction Stop parameter tells PowerShell to stop the action and throw an error in case of an issue (say, the file does not exist or there are permission issues), and enter the Catch block.
- -The Catch block catches the error the Move-Item cmdlet throws.
- Write-Output displays the error message ($_ contains the error details). You can also replace Write-Output with logging functions like Write-Log to save the error to a log file.
The -ErrorAction parameter specifies what should happen if an error occurs. Possible values are:
- Stop – The operation will stop on the error
- Continue – The operation will continue after an error
- SilentlyContinue – The operation will ignore the error without displaying anything
- Inquire – Prompts the user for input when an error occurs
- Ignore – Ignores the error
Best Practices for File Management with PowerShell
Limit the cmdlet to one source and destination folder
The Move-Item cmdlet does not create a folder or the directory structure at the destination. You also cannot move two files of the same name from two different source locations at the same time. Hence it’s best to specify one source and one destination folder in a cmdlet.
Plan file organization
You must be clear about your file organization structure, especially before moving files in bulk. Firstly, the source directory must be organized with files and folders properly maintained, so while moving Items, you know that is being moved. Secondly, the folder structure at the destination must be well-defined, so every item moves as desired. This helps you easily locate each moved file.
Test cmdlets on sample data
Test the Move-Item cmdlet on sample data to ensure that the results are as expected. This will help address any oversight into overwrites or conflicts.
If you do not have enough sample data or you want to save time, use the -WhatIf parameter to simulate the move without actually running the cmdlet. In this way, you can test cmdlets and scripts to view the outcome before making any changes.
Keep backups
As a precaution, back up all the important files and folders before you use the Move-Item cmdlet, particularly the overwrite ones –to avoid being disoriented later.
Implement logging and error handling
Logging and error handling are useful tools to handle unexpected errors. Implementing these helps to identify and track any errors in the Move-Item operations.
You can either use the -ErrorAction parameter or the try-catch blocks in your cmdlets for error handling.
Conclusion
The PowerShell Move-Item cmdlet holds the power of a wizard when it comes to managing and organizing files. It caters to both novice and advanced users with a simple syntax at its very basis, that you can build up with parameters and scripts. You can move a single file, multiple files, hidden and read-only files, an entire directory with all its contents to another location, rename a file while moving it, handle overwrites, and much more. The cmdlet also supports logging and error handling to ensure that file moves are reliable and safe.
FAQs
What happens if a file with the same name already exists at the destination?
When you try to move a file using the Move-Item cmdlet and a file with the same name already exists the destination, then one of the following happens:
- The Move-Item cmdlet is run without the -Force parameter:
Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\test.txt
The cmdlet throws an error and does not move the file.
- With the -Force parameter:
Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\test.txt -Force
PowerShell will overwrite the file at the destination without asking for confirmation. This will replace the file in the destination with the file you’re moving.
See the Handle Overwrites section for additional information.
Can I move multiple files at once?
Yes, that’s possible with PowerShell’s Move-Item. You can:
- Move files of the same extension, files with different extensions, and all files from the root of a source directory. You can use the following cmdlet to move all files from the root of the source directory:
Get-ChildItem -Path C:\Temp\* -File | Move-Item -Destination C:\Backup
See the Move Multiple Files section for details.
- To recursively move all files of the same extension from the source directory, use this cmdlet:
Get-ChildItem -Path C:\Temp\*.pdf -Recurse | Move-Item -Destination C:\Backup
See the Recursive File Moving section for details.
- Move the source directory with all its contents using this cmdlet:
Move-Item -Path C:\Temp -Destination C:\Backup
See the Move a Directory section for details.
How do I move files with specific attributes?
The Move-Item cmdlet can move files based on specific criteria, such as file size, date modified, and so on. Here is a list of the common attributes that you can filter on:
- Hidden
- ReadOnly
- Archive
- Compressed
- Encrypted
Use these in the Where-Object filter to target files with those attributes. You can also combine multiple conditions using -and or -or in Where-Object to filter files with multiple attributes.
See the Filter Files and Advanced Moving Scenarios topics for additional information.
Can I use Move-Item to move files between different drives?
The simple answer is, yes. Files will be moved to the location you specify as the destination, be it the same as the source drive or a different drive.
How do you move a file and overwrite using Move-Item?
If you want to overwrite a file at the destination with a file you are moving, use the -Force parameter with Move-Item. For example:
Move-Item -Path C:\Temp\test.txt -Destination C:\Backup\test.txt -Force
PowerShell will replace the test.txt file in the Backup folder with the test.txt file from the Temp folder without asking for confirmation. See the Handle Overwrites section for additional information.
How can I move hidden files using PowerShell?
While moving a folder or multiple files of the same extension, the Move-Item cmdlet does not move hidden or read-only files. Use the Get-ChildItem cmdlet with the -Force parameter to include hidden and system files in the output, and then pipe the results to Move-Item.
You can use this cmdlet, for example, to move all the files, including hidden files.
Get-ChildItem -Path C:\Temp\ -Force | Move-Item -Destination C:\Backup\
To specifically move hidden files (and not visible files), use this cmdlet:
Get-ChildItem -Path C:\Temp\ -Force | Where-Object { $_.Attributes -match 'Hidden' } | Move-Item -Destination C:\Backup\
As you added a condition to filter hidden files, the cmdlet moves only the files that have the “Hidden” attribute set.
What are some common errors when using Move-Item and how can I troubleshoot them?
Some common errors along with their explanation and solution is given below.
File already exists
When you attempt to move a file or folder to a destination where a file already exists with the same name, the following error is displayed:
Move-Item : Cannot create a file when that file already exists.
Use the -Force parameter to overwrite the existing file.
Access Denied
When you do not have the necessary permissions to move the file, the following error is displayed:
Move-Item : Access to the path 'C:\Path\to\file.txt' is denied.
There could be many reasons for this, such as the file is protected, the destination folder requires admin privileges, or the file is in use by another process.
To resolve the issue, make sure you have the needful permissions. It is recommended that you run PowerShell as an administrator. Moreover, make sure that the file is not in use by another application.
File Locked by Another Process
When the file to be moved is being used by another program or process, the following error is displayed:
Move-Item : The process cannot access the file because it is being used by another process.
To resolve the issue, close any applications using the file.
Path Too Long
By default, Windows has a maximum path length of 260 characters, and Move-Item will fail if the source or destination path exceeds this limit. PowerShell displays the following error:
Move-Item : The specified path, file name, or both are too long.
To resolve the issue, either use shorter directory or file names, or enable long path support in Windows 10/11 or Windows Server via Group Policy or the registry.
Invalid Path or File Name
When source path or destination path is incorrect, misspelled, or does not exist, the following error is displayed:
Move-Item : Cannot find path 'C:\InvalidPath\file.txt' because it does not exist.
Double-check the path.
Destination Directory Does not Exist
When the destination directory does not exist, the following error is displayed:
Move-Item : Could not find part of the path 'C:\Backup\'Make sure the destination directory exists. Else create it before moving the files.
Moving a Directory into Itself
PowerShell does not allow you to move a directory into one of its sub-directories. On trying to do so, the following error is displayed:
Move-Item : Cannot move item 'C:\Temp\' to a subdirectory of itself, 'C:\Temp\Logs\'.
Make sure the destination is not a sub-folder of the source directory.
Is it possible to move files based on their content?
By itself, the Move-Item cmdlet cannot move files based on their content. You can, however, use Get-Content or other file reading methods with conditional logic (such as If-Else statements) to read the content of a file and then use Move-Item to move the file accordingly.
Here’s a sample script that checks if a file contains a specific word or phrase. If yes, it moves the file.
Note: Make the following changes before you run the script:
- Modify the $searchString variable to match the content you want to filter.
- Change $sourceDirectory and $destinationDirectory to the appropriate paths.
$sourceDirectory = "C:\SourceFolder"
$destinationDirectory = "C:\DestinationFolder"
$searchString = "SpecificText"
# Get all files in the source directory
Get-ChildItem -Path $sourceDirectory -File | ForEach-Object {
$filePath = $_.FullName
# Read the content of the file
$content = Get-Content -Path $filePath
# Check if the file contains the search string
if ($content -match $searchString) {
# Move the file to the destination directory
$destinationPath = Join-Path -Path $destinationDirectory -ChildPath $_.Name
Move-Item -Path $filePath -Destination $destinationPath
Write-Host "Moved file: $filePath to $destinationPath"
}
else {
Write-Host "File does not contain search string: $filePath"
}
}
Get-ChildItem gets all the files from the source folder and ForEach-Object loops through each file. Get-Content reads the content of each file to checks if the content matches the specified string. Then Move-Item moves the files containing the string to the destination folder.
What if the file I am trying to move does not exist, or the source path is not valid?
In either case, PowerShell will throw an error.
Move-Item : Cannot find path 'C:\Temp\AppLog.txt' because it does not exist.
Similarly, if any element of the destination path does not exist, the cmdlet fails. It does not create a missing directory or any element of the path.
A good idea is to run Test-Path to check if the file exists. This cmdlet returns $true if all elements of the path exist and $false if any are missing.
Test-Path -Path C:\Backups\AppLogs
False
