$ find . -name "*.bat" -exec bash -c "basename \"{}\" .bat | xargs -i@ mv @.bat @.bak" ";"

is only slightly unreadable (Yes, that semicolon really does have to be there). I’ve no idea why you’d resort to -print0 and the like, since like everything else it can be solved with an extra layer of indirection, err, I mean quotes.

Of course this find is only good enough if you’re ok with it recursively ‘backing up’ innocent .bat files. You have been warned.

The problem as I see it is the “for” command itself. What it’s doing is expanding the *.bat bit into a space-delimited list of filenames (eg “foo.bat bar.bat I love Unix.bat”), then iterating over them one word at a time (“foo.bat”, “bar.bat”, “I”, “love”, “Unix.bat”).

Wrong. In fact, “for” is the recommended way of iterating over a glob. What happens is that the shell expands the *.bat glob into a list of filenames, each of which gets passed as a unit to ”for”, which then assigns it to f. Therefore “for” will always work, even where your sed script will fail (ie. when face of filenames with newlines in them).

Your code still fails because you’re not quoting the variables when using them, causing the shell to expand the variable into a list of IFS-delimited strings. So while the shell passes “I love Unix.bat” as a single string to “for”, and that assigns it to f all right, the $f in your call to mv then expands to “I”, “love”, “Unix.bat”, which blows up. To avoid that, you use doublequotes:

for f in *.bat ; do mv "$i" "${i%.bat}.bak" ; done

Your Linux Zealots weren’t very well versed in the ways of Unix.

Btw: notice that I said the shell expands the glob into a list? That means that the ls your ls *.bat incantation is superfluous; by the time ls is invoked, the actual work has already happened. This is called a useless use of ls *.

Richard:

find -name '*.bat' -print0 | sed 's!\\.bat\x0!\x0!g' | xargs -0i mv {}.bat {}.bak

Also I understand what you are trying to say with the “for” statement and verified that the correctly quoted version works correctly. Thanks, and now all I have to internalise is the ${f%.bat} syntax (I’ve read that section in the manpage n times and it still baffles me).

One minor point: your wording implies that “for” is not part of the shell (ie “the shell passes to”). This is not the case, as “for” is an integral part of the shell, it’s not even a builtin.

Btw: notice that I said the shell expands the glob into a list? That means that the ls your ls *.bat incantation is superfluous; by the time ls is invoked, the actual work has already happened.

Err, care to explain this? How would you rewrite the following expression to remove the ls?

ls *.bat | sed -e "s/[\\\"$]/\\&/g" -e "s/(.*).bat$/mv \"\1.bat\" \"\1.bak\"/" | sh

(missing backslash corrected)

“for” is an integral part of the shell, it’s not even a builtin.

I know. What I was referring to is that glob expansion and “for” execution happen in different stages.

How would you rewrite the following expression to remove the ls?

With anything that prints its argument list. In the simplest cases, even echo might suffice. If you’re using bash, it’s very simple: it has is a builtin printf, so you can just say “printf '%s\n' *.bat”.

Heh. That suggests an alternative to my reply to Richard:

printf '%s\0' *.bat | sed 's!\.bat\x0!\x0!g' | xargs -0i mv {}.bat {}.bak

from os import walk, rename
from os.path import join

directory = "scans for rosie copy" extfrom = ".jpg" extto = ".gif"

extfrom = ".gif"

extto = ".jpg"

for root, dirs, files in walk(directory): for fileName in files: if fileName.endswith(extfrom): newFileName = fileName.replace(extfrom, extto) rename(join(root, fileName), join(root, newFileName))

I put it to you that the idle reader can figure out what’s going on here which is more important than fewer lines of code.

Sorry for the digression.

In these cases, optimising for brevity gets you under the threshold of being able to memorise it in entirety. So the next time you come across the same problem, you simply are able to regurgitate the command and tailor for the situation. Agree that the python script is clearer, but does it follow you around to every system? If not, what then? Rewrite it? Go download it from another machine?

There’s also a middle ground between uber-shell scripting and using a real language like python. Frequently I simply load up the directory listing in emacs and use a macro function to mould it to my will. Once I’ve got a list of shell commands to run, just hit M-| to run them.

Lastly, I can’t help but recommend python list comprehensions, they’re fantastic:

from os import walk, rename
from os.path import join
extfrom = ".bat"
extto = ".bak"
for dirpath, dirnames, filenames in walk("."):
    map( lambda (old, new): rename(join(dirpath,old), join(dirpath,new)), \
         [ (file, file.replace(extfrom,extto)) \
           for file in filenames if file.endswith(extfrom) ] )

Which, come to think of it, doesn’t prove a point about either readability or brevity. But it is cool nonetheless…