mv command to rename single files or directories in Linux by specifying the current path and the new target name. For batch renaming operations involving multiple files, combine find with -exec mv or use a for loop to iterate through file lists. While basic renaming is straightforward, complex pattern-based changes often require tools like sed or awk to generate the necessary commands safely before execution.
The Basic Rename Command
The primary tool for renaming files in Linux is mv, which stands for move. Despite its name, this command handles both moving files between directories and renaming them within the same directory. The syntax is simple: you provide the source filename followed by the destination filename.
mv old_filename.txt new_filename.txtIf you are working in a terminal where the current directory contains the file, you can use relative paths. If the file is located elsewhere, provide the full absolute path. It is important to note that if a file named new_filename.txt already exists, mv will overwrite it without warning unless you have aliases set up for safety. Always verify the existence of the target name before executing the command to prevent accidental data loss.
Bulk Renaming with Loops
Renaming dozens or hundreds of files one by one using mv is inefficient. A more effective approach involves using a for loop in Bash to process multiple files simultaneously. This method allows you to apply consistent naming conventions across a directory.
For example, to add a prefix to all text files in the current directory, you can use the following script:
for file in *.txt; do
mv "$file" "prefix_$file"
doneThis loop iterates through every file matching the *.txt pattern. Inside the loop, the variable $file holds the current filename. The mv command then renames it by prepending prefix_. Quoting the variables with double quotes ensures that filenames containing spaces are handled correctly. Without quotes, a file named my document.txt would be interpreted as two separate arguments, causing the command to fail.
Advanced Pattern Replacement Using Sed
When renaming requires changing specific parts of a filename based on a pattern, manual loops become cumbersome. Here, we can leverage sed to transform filenames. However, sed operates on text streams, not directly on the filesystem. Therefore, we must pipe the output of a listing command into sed and then execute the resulting mv commands.
A common technique involves using ls (or preferably find) to list files, piping them to sed to construct the mv command, and then passing that output to bash for execution.
ls *.log | sed 's/\(.*\)\.log/mv & \1_archived.log/' | bashIn this example, sed captures the part of the filename before the extension using \(.*\). It then constructs a command that moves the original file to a new name with _archived appended. The final | bash executes these generated commands. Note that this approach assumes filenames do not contain newlines or special characters that could break the pipeline. For robust production scripts, using find ... -print0 with xargs -0 is safer.
Alternative Approach with Awk
Similar to sed, awk can be used to manipulate strings within filenames. awk offers more powerful string manipulation capabilities, such as splitting strings by delimiters. This is useful when you need to replace a substring in the middle of a filename rather than just appending or prepending.
Consider a scenario where you want to replace spaces with underscores in all files:
ls | awk '{system("mv \"" $0 "\" \"" gsub(/ /, "_", $0) "\'")}'This command uses gsub to globally substitute spaces with underscores. The system() function executes the constructed mv command. While powerful, this method is less readable than standard shell loops and should be used only when complex string processing is required. For simpler cases, built-in shell parameter expansion is often cleaner.
Safety and Best Practices
Before running any bulk rename operation, it is crucial to test your commands. You can preview the results by printing the mv commands instead of executing them. Replace | bash with | cat or simply remove the mv part to see what would happen.
Additionally, always backup important directories before performing mass modifications. Accidental overwrites are irreversible if no backups exist. Understanding how to manage file permissions and ownership is also relevant, as mv preserves the original file's metadata, including permissions and timestamps.
For more information on text processing utilities that complement file management tasks, you might find our guide on Find and replace string in a file using 'sed' or 'awk' helpful. It details how to use these tools for content modification inside files, which often pairs with renaming workflows.
Frequently Asked Questions
Does mv change the inode number of a file?
No, renaming a file within the same filesystem does not change its inode number. The inode stores the metadata and pointer to the data blocks, and since the data remains in place, the inode stays the same. Only moving a file to a different filesystem creates a new inode.
How can I undo a rename if I make a mistake?
Linux does not have a built-in "undo" button for file operations. If you renamed a file incorrectly, you must manually rename it back using the mv command with the correct names. Having a recent backup or snapshot is the only reliable way to recover from significant errors.
Can I rename files recursively in subdirectories?
The basic mv command only renames the specified file. To rename files recursively, you need to use find with the -exec option or write a script that traverses directories. Be cautious with recursive renames as they can affect many files unintentionally.
What happens if I try to rename a file to an existing name?
By default, mv will silently overwrite the existing file. This behavior can lead to data loss. To prevent this, you can use the -i (interactive) flag, which prompts you for confirmation before overwriting. Many users alias mv to mv -i for safety.
Is there a GUI tool for bulk renaming in Linux?
Yes, several desktop environments offer GUI tools for bulk renaming. File managers like Nautilus (GNOME) and Dolphin (KDE) often include batch rename features accessible via right-click menus. Third-party applications like renameqt or qrenamer provide more advanced graphical interfaces for complex patterns.