Linux why can't I pipe find result to rm?

Question

sorry if this is a noobie question but I can\'t find a good answer.

To find then remove something I can use

find . -name \".txt\" -exec rm \"{}\" \\;         


        

Answer 1

Pipe sends output of first command to the standard input of second. rm does not accept standard input so you can't pipe to it. You could use xargs to achieve the same effect. You can find example for xargs specifically for your case in man page for xargs.

Answer 2

"why can't I pipe find result to rm?"

When you pipe something to a program, the pipe replaces the keyboard input. Keep this in mind and ask youself the next question: What would rm do with a keyboard? Delete your keystrokes ? (a bit silly indeed) Accepting interactive control ? (rm is not interactive except sometimes when it needs confirmation, which indeed can be given by a pipe.)

As a matter of fact, when rm is already running, you can't type commands to let it delete files....so you can't do that with a pipe either.

If you keep in mind that a pipe replaces the keyboard/screen combination, things will immediately appear more logical.

Now the other way around. You can pipe a datastream into grep. Does that mean that you can let grep read the keystrokes from your keyboard as input data instead ?

YES! That is actually what it natively (without piping) does.

(b.t.w. note that you can not pipe nor type the search argument into grep )

So now you know why you can't pipe to rm and expect it to work as a commandline argument.

tl;dr :

Anatomy of a program according to UNIX philosophy:
file in, file out, keyboard in, screen out. -> Pipe does only replace keyboard and screen.

Answer 3

find . -name ".txt" | grep "foo" | xargs -I{} rm {}

Answer 4

An alternative without using pipes :

xargs rm -f <<< $(find . -name ".txt")

Answer 5

To expand on @Alex Gitelman's answer: yes, there's a difference between "standard input" and the command line.

When you type rm a.txt b.txt c.txt, the files you list after rm are known as arguments and are made available to rm through a special variable (called argv internally). The standard input, on the other hand, looks to a Unix program like a file named stdin. A program can read data from this "file" just as it would if it opened a regular file on disk and read from that.

rm, like many other programs, takes its arguments from the command line but ignores standard input. You can pipe anything to it you like; it'll just throw that data away. That's where xargs comes in handy. It reads lines on standard input and turns them into command-line arguments, so you can effectively pipe data to the command line of another program. It's a neat trick.

For example:

find . -name ".txt" | xargs rm
find . -name ".txt" | grep "foo" | xargs rm  

Note that this will work incorrectly if there are any filenames containing newlines or spaces. To deal with filenames containing newlines or spaces you should use instead:

find . -name ".txt" -print0 | xargs -0 rm

This will tell find to terminate the results with a null character instead of a newline. However, grep won't work as before then. Instead use this:

find . -name ".txt" | grep "foo" | tr "\n" "\0" | xargs -0 rm

This time tr is used to convert all newlines into null characters.