why are you using ls with an extra process to while loop? Just use a for loop with shell expansion. This is preferred way

#!/bin/bash
shopt -s nullglob
for file in *
do
  if [ -f "$file" ];then
    newfile="${file##* }"
    mv "$file" $newfile"
  fi
done

#!/bin/bash
cd $1
for f in *; do 
mv  "$f" "${f%.*}.bu"
done

You were right to consider rename first. The syntax is a little strange if you're not used to regexes but it's by far the quickest/shortest route once you know what you're doing:

rename 's/\d{4}/2503/' file*

That simply matches the first 4 numbers and swaps them for the ones you specified.

And a test harness (-vn means be verbose but don't do anything) using your filenames:

$ rename 's/\d{4}/2503/' file* -vn
file0901201437404.p renamed as file2503201437404.p
file0901201438761.p renamed as file2503201438761.p
file1003201410069.p renamed as file2503201410069.p
file2602201409853.p renamed as file2503201409853.p
file2602201410180.p renamed as file2503201410180.p

If you want to process files only in the top level of the directories (ie: one level deep), then you don't need recursion.

Both of these examples take a list of directories as arguments and rename only the files in those directories which match the more exclusive pattern: *-*.png (to avoid possible failures of the mv command).

A script that does NOT change directory:

In this first script, inside the for loop, the variable name contains the directory path to the file in addition to the base filename.

#!/bin/sh
for dir in "$@"
do
    for name in "name" "${name%-*}.png"
    done
done

A script that DOES change directory:

In this second script, inside the for loop, the name variable contains only the filename, because the current directory has been temporarily changed to the script argument.

The code between the parenthesis ( and ), is executed in a subshell environment which means that changing the current directory, as well as variables set, will not be visible to the outer shell script, eliminating the need to change "back" to the original directory.

#!/bin/sh
for dir in "dir"
        then
            for name in ./*-*.png
            do
                mv "$name" "${name%-*}.png"
            done
        fi
    )
done

Notes About These Two Scripts:

The "$@" expands to the script's command line arguments. The script will silently do nothing with no arguments.

The directory-name arguments can be any absolute path (/path/to/dirx) or relative path (dirx, path/to/diry, ., .., ../x/d1, etc).

Messages will be printed on the standard error stream (stderr) by either mv or cd if a given directory does not exist, or if there are no *-*.png files in a directory. The script will continue processing subsequent directories.

The first line of these scripts can be #!/bin/sh instead of bash because this script uses none of the bash features, thus the more portable, posix compliant, and probably faster, sh can be used. Few scripts require the extra features of the bash shell. For these and other reasons #!/bin/bash is not generally recommended for scripting.

Just use bash, no need to call external commands.

for file in *_h.png
do
  mv "$file" "${file/_h.png/_half.png}"
done

Do not add #!/bin/sh

For those that need that one-liner:

for file in *.png; do mv "$file" "${file/_h.png/_half.png}"; done

Temporary note: there is something wrong - the rename pattern does not handle filenames with path; I'm working on a fix

What is wrong in your command is two things:

find /tmp/dir -name "* *" -type f | rename 's/*/fixed_/g'

• The -name "* *" matches only file names with a space in it - that's not what you want, right?

  • the solution is to just leave it out; We do not want to exclude files matching some name - we want all.

• The rename pattern is wrong in two ways

  • you used a shell glob pattern, but it needs to be a regular expression, in short a regex (It can be some general perl expression - let's ignore it and use only s///g)
  • the fixed pattern would match the complete name, and replace it with fixed_. You want to "replace" the "first 0 characters" with fixed_, technically. That's the start of the line, matched with ^. We can leave out the g because there is only one replacement needed per line.

Putting it together, it looks like this:

find /tmp/dir -type f | rename 's/^/fixed_/'

Most standard shells provide a way to do simple text substitution within shell variables. http://tldp.org/LDP/abs/html/parameter-substitution.html explains as follows:

${var/Pattern/Replacement}

First match of Pattern, within var replaced with Replacement.

So use this script to loop through all the appropriate files and rename each of them:

for file in aro_tty-mIF-*_opt
do
    mv -i "${file}" "${file/-mIF-/-mImpFRA-}"
done

I have added a -i option so you have the chance to confirm each renaming operation. As always, you should make a backup of all your files before doing any large amount of renaming or deleting.

Escape the space, e.g. Spring\ 2011, or use quotes, e.g. 'Spring 2011'. In the future, it's typically a bad idea to use file names with spaces in them on any *NIX.

If you've got rename, you can use this:

rename ' ' '_' [filenames...]

To do this in a single command, you can simply do this:

mv some/long/path/to/file/{myfiel.txt,myfile.txt}

Which is an example for the full file name, given that it's a typo you can do something like:

mv some/long/path/to/file/myfi{el,le}.txt

Both will expand to the full command, these are called brace expansions. They are supported by zsh.

If we can assume that your file names do not contain ; (this is a huge assumption, ; is perfectly valid in file names, so you need to be sure about this), then you can just read your input text file, split on ; and save the result in two variables, allowing you to rename:

while IFS=';' read old new ; do mv "$old" "$new" ; done < filenames.csv

Here, we set the input field separator (IFS) to a ;, then read the input file, split on ; and assign the old and new filenames to their respective variables.

Now, your input example also has spaces around the ;. This means that the file name isn't "this_is_a_file.ext" but "this_is_a_file.ext " with an extra space, and that file won't exist. So before running the command above, you need to remove those extra spaces. You can do this with sed, telling it to replace all cases of two or more spaces ( *, that is one space, then another space and a *) around a ; with just the ;:

$ sed 's/  *;  */;/g' filenames.csv 
this_is_a_file.ext;new_filename_1.ext
this_is_another_file.ext;new_filename_2.ext
this is a filename with spaces.ext;new_filename_3.ext

Combining the two commands gives the one you really want to run:

$ sed 's/  *;  */;/g' filenames.csv |  
   while IFS=';' read old new ; do 
     echo "mv \"$old\" \"$new\"" ; 
done 
mv "this_is_a_file.ext" "new_filename_1.ext"
mv "this_is_another_file.ext" "new_filename_2.ext"
mv "this is a filename with spaces.ext" "new_filename_3.ext"

Once you are sure that is the right output, remove the echo and run again to actually rename the files:

sed 's/  *;  */;/g' filenames.csv |  
   while IFS=';' read old new ; do 
     mv -- "$old" "$new" ; 
done 

The -- is there to protect against file names starting with -. See What does "--" mean in terminal commands?.