pipe question

[HMW]

Hi all!

I realize this might be too basic for this section, but nevertheless; I am wondering how to execute something that comes out of a pipe.

For instance, say that I do:

ls | grep -i foo

No problem there, but what if I want to move the files that are found (f.ex. Foo.txt foo.pl) to another directory. What I WANT to do is something like this:

mv | ls | grep -i foo ~/wherever

This will def. not work, I know!

I hope that made some sense, appreciate any input from all y'all.

Thanks for reading this,

HMW

[Irithori]

So you want
- to move all files, directorys, links, etc,
- that dont have case insensitive "foo" as as part of the name to another place?

First question is then, if you want to preserve the directory structure.
If yes, rsync is your friend

For no (and as well as a more general approach):
Use find to list the files/dirs/etc you are interested in, and pipe that list to a while read construct

To make it even more general: of course it doesnt need to be find, that creates the list.

[Rubberman]

You can also execute code within a find command:

find . -iname '*foo*' -exec mv {} ~/wherever \;

The {} symbol is expanded into the path+filename, so this example would move all files with foo (in upper or lower case) in the name to ~/wherever.

[dizzio]

You can also do something like this using xargs

ls | grep -i foo | xargs -i mv {} bar/

this will move all files matching "foo" to the bar directory.

dizzio

[ProfTheory]

Or try this:
mv $(ls | grep -i foo) ~/wherever

Here the source will be the result of what is in $().

[ramin.honary]

This is my favorite technique for executing a command on a list of files:

find . -name '*.pdf' | (while read F; do echo $F; mv $F ../pdf/; done)

#Or, you can save to a temporary file, then work on the file

find . -name '*.pdf' >temp-file.txt
(while read F; do echo $F; mv $F other-dir; done) <temp-file.txt

The idea is to pipes a list of files to a subshell, and the subshell (the part in parenthases) uses "read" to read every line given to it, storing each line in the variable "$F". You can then do whatever you want with $F.

This technique can be gives you more control than "find" or "xargs".

Find's "exec" command is limited because it only allows you to execute a single program -- it does not allow per-item redirections, nor variables, nor conditionals like "if" or "case". But by piping to a subshell, you can execute a miniature script on each file, with redirections and variables and everything. Find also does not let you use the filename twice in the same command.

Xargs can have problems with very large lists. Xargs must first buffer the entire output of "find" in memory, and when "find" finally finishes, it will execute the given command, passing the whole buffer as a list of arguments. Piping to a subshell does not require copying the output of "find" to memory at all. Using the pipe, each found item is executed one at a time as soon as it is found, no need for extra memory, no need to wait for find to complete.

If all you need is to move a few files from one place to another, then any of these will work:

mv *.pdf *.html ../other-dir/
    #or...
mv -t ../other-dir/ $(find . -name '*.pdf' -o -name '*.html')
    #or...
find . \( -name '*.pdf' -o -name '*.html' \) -exec mv '{}' other-dir \;

But for even slightly more complex tasks, the piping to a subshell works better.

[HMW]

Thanks, to all of you. You all gave me very good answers, and now I have several to choose from. My favourite might be ProfTheory's answer, since I like the idea of working with ”return values”, but all were awesome. I love this place!

Best,

HMW

[ProfTheory]

If that doesn't work you can try this instead:

for a in $(ls | grep -i foo); do mv $a ~/wherever; done

That executes repetitive mv commands with $a as the source from the list provided by $(ls | grep -i foo).