Linux script or program to shorten filenames

Question

I haven't had much success in finding a Linux version of namemangler, which I need to rename 1000 of files so they are readable on Windows.

Does anyone know of a Linux program that can do this?

If not, then a script might work as I only need to rename all files in a folder to, say, the first 16 characters. I suspect that the script route might be worth going down but not sure where to start.

Answer 1

On Debian, Ubuntu and derivatives, if you enter man rename at a command prompt, you'll get the manual page for a rename utility that allows arbitrary Perl-like regular expression commands to be used in the renaming.

For example, this will shorten (by truncating) all files in the current directory to a length of five:

rename 's/^(.{5}).*/$1/' *

It works by capturing the first five characters then using that in the substitution, removing the rest.

Another example is to shorten filenames (sans extension) to five characters wile preserving the extension:

rename 's/^(.{5}).*(\..*)$/$1$2/' *

It captures two groups, the first being the first five character, the second being the extension. This would turn myCarefullyCraftedDocument.pdf into myCar.pdf.

Warning: Use this carefully, preferably on a copy of your directory, or by taking backups first. You have been warned!! At a bare minimum, use rename -n first, which will show you what would be done without actually doing it.

Answer 2

You can move conflicted files to other directory:

for i in *
do
    j=${i:0:16}

    if [ -e "$j" ]
    then
        mv "$i" /path/to/rename/later
    else
        mv "$i" "$j"
    fi
done

Answer 3

You can write a script to shorten file names and remove characters that Windows doesn't like in a few lines of bash. Warning, untested code, typed directly into my browser.

shopt -s dotglob extglob
for x in *; do
  y=${x//+([!-!#$%&'().0-9@A-Z^_`a-z{}~])/_}  # change all problematic characters to _
  if [[ $y = .* ]]; then y=_${y#.}; fi        # change dot files to begin with _
  y=${y:0:16}                                 # truncate names
  y=${y,,}                                    # convert to lowercase
  if [[ -e $y || $y =~ ^(aux|clock\$|com[0-9]|con|lpt[0-9]|nul|prn)(\.*)?$ ]]; then
    # The file exists or is a DOS/Windows reserved name.
    # Change foo.bar to foo~1.bar, foo~2.bar, ... (I ignore the length restriction here)
    i=1
    if [[ $y =~ \. ]]; then
      prefix=${y%%.*}; suffix=.${y#*.}
    else
      prefix=$y; suffix=
    fi
    y=${prefix}~$i$suffix
    while [[ -e $y ]]; do
      ((++i))
      y=${prefix}~$i$suffix
    done
  fi
  mv -- "$x" "$y"
done

If you need to recurse into subdirectories, call a shell script from find -depth -exec …. Or use zsh instead of bash; in zsh, **/*(od) expands to all the files under the current directory, recursively, with more deeply nested files first.

Answer 4

Shell/python/perl scripting for this kind of thing is just fine, but it seems like a gui app would be best for you, so I would recommend pyRenamer, which can do exactly what you want, among many other things (simple common operations via presets [getting rid of spaces, truncating filename from one point to another], simple search/replace, complicated regex, previewer, etc).

Your distribution might even have it in their software repository (Fedora does).

Answer 5

Some systems do not have the rename command, so as an alternative to paxdiablo's answer, here is how to do the same thing with mv.

for f in *.pdf; do 
    tmp=`echo $f | sed -r 's//^(.{5}).*(\..*)$/$1$2/'`
    mv -b ./"$f" ./"$tmp"
done

The -b flag on move creates a backup of files that would be deleted or overwritten. By changing the glob pattern in the for loop you can adjust what files it runs on, using * by itself to run on all files.

Answer 6

If you need to experiment with renaming files and happen to have KDE libraries installed on your system (or don't mind adding them), check out krename.

It allows you to do quite a few simple renaming tasks directly with its tools and also allows regular expressions for more complicated situations.

It shows you a preview of the renamed files as you build the renaming conditions. It also allows you to rename the same files again which is helpful if you want to do something complicated where doing it in stages would reduce the complexity of each stage to something you can figure out quickly.