Automating Directory Renaming with Number Matching List using Shell Scripting

Automating directory renaming with a number-matching list in Linux requires mapping specific numeric identifiers to target folder names. This approach eliminates manual typing errors and ensures consistent naming conventions across large datasets. By using bash loops and parameter expansion, you can efficiently process thousands of directories without external dependencies or complex configuration files.

Understanding the Number Matching Concept

The core challenge in automated renaming is establishing a reliable link between a source identifier (the number) and the destination name. Unlike simple sequential renaming, which ignores input data, this method uses an explicit mapping strategy. You must define how the script interprets the numbers provided in your list. For instance, if your list contains "101" and "102", the script must know whether these correspond to "alpha", "beta", or other semantic labels stored in a separate file or generated dynamically. This distinction is critical because vague definitions lead to failed operations. A robust solution does not assume exact name matches but rather constructs them based on a predictable pattern or a lookup table. The script reads the input list, extracts the numeric value, and applies a transformation rule to generate the new directory name. This process ensures that even if the input order changes, the output remains deterministic and correct.

Preparing the Input Data

Before writing the script, you need two distinct components: the list of numbers and the target naming convention. The most common format for the number list is a plain text file where each line contains a single integer. For example, create a file named ids.txt containing:

101
102
103
104

If you are working with existing directories that already have temporary names, you might need to extract these IDs first. However, for pure automation, it is safer to start with a clean slate. Ensure that the directory structure is backed up before running any bulk rename operations. This step prevents irreversible data loss if the logic contains bugs. You can also integrate this process with scheduled tasks to automate routine maintenance, as discussed in our guide on Implementing Commands for Scheduled Tasks in Linux.

Writing the Bash Script

The following script demonstrates a safe way to rename directories based on a number-to-name mapping. It assumes a direct correlation where the number is padded or used as a prefix. Adjust the logic inside the loop to fit your specific naming requirements.

#!/bin/bash

# Check if the input file exists
INPUT_FILE="ids.txt"
if [[ ! -f "$INPUT_FILE" ]]; then
    echo "Error: $INPUT_FILE not found."
    exit 1
fi

# Read the file line by line
while IFS= read -r number || [[ -n "$number" ]]; do
    # Skip empty lines
    [[ -z "$number" ]] && continue

    # Define the target name. 
    # Example: Rename 'dir_101' to 'project_alpha_101'
    # Modify this string to match your desired naming convention
    NEW_NAME="project_alpha_${number}"
    
    # Construct the full path assuming current directory
    OLD_PATH="./dir_${number}"
    NEW_PATH="./${NEW_NAME}"

    # Check if the old directory exists
    if [[ -d "$OLD_PATH" ]]; then
        # Check if the new name already exists to prevent overwriting
        if [[ ! -e "$NEW_PATH" ]]; then
            mv "$OLD_PATH" "$NEW_PATH"
            echo "Renamed: $OLD_PATH -> $NEW_PATH"
        else
            echo "Skipped: $NEW_PATH already exists."
        fi
    else
        echo "Warning: Directory $OLD_PATH not found."
    fi
done < "$INPUT_FILE"

This script uses a while loop to iterate through each line of ids.txt. The IFS= read -r combination preserves whitespace and backslashes, which is crucial for robustness. Inside the loop, we construct the old and new paths using variable interpolation. The mv command performs the actual rename. Notice the safety checks: verifying the existence of the source directory and ensuring the destination does not already exist. These guards prevent accidental data loss.

Handling Edge Cases and Errors

Real-world scenarios often involve messy data. Your input list might contain duplicates, non-numeric characters, or missing entries. To handle this, add validation logic before the rename operation. For example, you can use a regular expression to ensure the input is purely numeric:

if [[ ! "$number" =~ ^[0-9]+$ ]]; then
    echo "Invalid number: $number"
    continue
fi

Additionally, consider using set -e at the beginning of your script to stop execution immediately if any command fails unexpectedly. This is particularly useful when dealing with permissions or disk space issues. If you are integrating this script into a larger deployment pipeline, refer to our article on Automating Deployments and Log Updates with Bash Script for best practices on logging and error handling. Logging every action allows you to audit changes later, which is essential for debugging complex renaming sequences.

Optimizing for Performance

When dealing with thousands of directories, performance becomes a concern. The basic loop above is straightforward but may be slow due to the overhead of spawning multiple processes for each echo and test command. For high-volume operations, consider buffering output or using more efficient tools like find combined with xargs. However, for most administrative tasks, the readability and safety of the bash loop outweigh the minor performance cost. Always test with a small subset of data first to verify the naming logic before scaling up.

Frequently Asked Questions

How do I restore original names if the script fails?

The safest way to restore original names is to maintain a backup of the directory structure before running the script. You can use tar to create an archive of the parent folder, allowing you to extract the original state if needed. Without a backup, reversing the changes manually is error-prone and time-consuming.

Can I use this script for files instead of directories?

Yes, you can modify the condition from -d (directory) to -f (file) in the script. This change allows the script to rename individual files based on the same number-matching logic. Ensure that the path construction reflects the file extensions required by your workflow.

What if my numbering scheme has leading zeros?

If your IDs have leading zeros (e.g., 001, 002), treat them as strings rather than integers to preserve the formatting. In bash, variables are strings by default, so no special handling is needed unless you perform arithmetic operations. Avoid using arithmetic expansion like $((number)) if you want to keep the leading zeros intact.

Is there a risk of overwriting existing directories?

Yes, if two different numbers map to the same target name, the second rename will overwrite the first. Our script includes a check to skip renaming if the destination already exists, which prevents silent data loss. Always review the log output to identify skipped items and resolve naming conflicts manually.

How can I make the script executable?

Use the chmod +x rename_script.sh command to make the script executable. Then, run it using ./rename_script.sh. Ensure you have the necessary permissions to modify the directories you intend to rename. Running the script as root may be required if the directories are owned by another user.