Find, grep, and execute - all in one?

Question

This is the command I've been using for finding matches (queryString) in php files, in the current directory, with grep, case insensitive, and showing matching results in line:

find . -iname "*php" -exec grep -iH queryString {} \;

Is there a way to also pipe just the file name of the matches to another script?

I could probably run the -exec command twice, but that seems inefficient.

What I'd love to do on Mac OS X is then actually to "reveal" that file in the finder. I think I can handle that part. If I had to give up the inline matches and just let grep show the files names, and then pipe that to a third script, that would be fine, too - I would settle.

But I'm actually not even sure how to pipe the output (the matched file names) to somewhere else...

Help! :)

Clarification

I'd like to reveal each of the files in a finder window - so I'm probably not going to using the -q flag and stop at the first one.

I'm going to run this in the console, ideally I'd like to see the inline matches printed out there, as well as being able to pipe them to another script, like oascript (applescript, to reveal them in the finder). That's why I have been using -H - because I like to see both the file name and the match.

If I had to settle for just using -l so that the file name could more easily be piped to another script, that would be OK, too. But I think after looking at the reply below from @Charlie Martin, that xargs could be helpful here in doing both at the same time with a single find, and single grep command.

I did say bash but I don't really mind if this needs to be ran as /bin/sh instead - I don't know too much about the differences yet, but I do know there are some important ones.

Thank you all for the responses, I'm going to try some of them at the command line and see if I can get any of them to work and then I think I can choose the best answer. Leave a comment if you want me to clarify anything more.

Thanks again!

Answer 1

You bet. The usual thing is something like

  $ find /path -name pattern -print | xargs command

So you might for example do

  $ find . -name '*.[ch]' -print | xargs grep -H 'main' 

(Quiz: why -H?)

You can carry on with this farther; for example. you might use

  $ find . -name '*.[ch]' -print | xargs grep -H 'main' | cut -d ':' -f 1

to get the vector of file names for files that contain 'main', or

  $ find . -name '*.[ch]' -print | xargs grep -H 'main' | cut -d ':' -f 1 |
      xargs growlnotify -

to have each name become a Growl notification.

You could also do

 $ grep pattern `find /path -name pattern`

or

 $ grep pattern $(find /path -name pattern)

(in bash(1) at least these are equivalent) but you can run into limits on the length of a command line that way.

Update

To answer your questions:

(1) You can do anything in bash you can do in sh. The one thing I've mentioned that would be any different is the use of $(command) in place of using backticks around command, and that works in the version of sh on Macs. The csh, zsh, ash, and fish are different.

(2) I think merely doing $ open $(dirname arg) will opena finder window on the containing directory.

Answer 2

It sounds like you want to open all *.php files that contain querystring from within a Terminal.app session.

You could do it this way:

find . -name '*.php' -exec grep -li 'querystring' {} \; | xargs open

With my setup, this opens MacVim with each file on a separate tab. YMMV.

Answer 3

Replace -H with -l and you will get a list of those filenames that matched the pattern.

Answer 4

if you have bash4, simply do

grep pattern /path/**/*.php

the ** operator is like

grep pattern `find -name \*.php -print`

Answer 5

find /home/aaronmcdaid/Code/ -name '*.cpp' -exec grep -q -iH boost {} \; -exec echo {} \;

The first change I made is to add -q to your grep command. This is "Exit immediately with zero status if any match is found".

The good news is that this speeds up grep when a file has many matching lines. You don't care how many matches there are. But that means we need another exec on the end to actually print the filenames when grep has been successful

Answer 6

Pipe to another script:

 find . -iname "*.php" | myScript

File names will come into the stdin of myScript 1 line at a time.

You can also use xargs to form/execute commands to act on each file:

 find . -iname "*.php" | xargs ls -l

act on files you find that match:

find . -iname "*.php" | xargs grep -l pattern | myScript

act that don't match pattern

find . -iname "*.php" | xargs grep -L pattern | myScript

Answer 7

The grep result will be sent to stdout, so another -exec predicate is probably the best solution here.

Answer 8

In general using multiple -exec's and grep -q will be FAR faster than piping, since find has implied short circuits -a's separating each juxtaposed pair of expressions that's not separated with an explicit operator. The main problem here, is that you want something to happen if grep matches something AND for matches to be printed. If the files are reasonably sized then this should be faster (because grep -q exits after finding a single match)

find . -iname "*php" -exec grep -iq queryString {} \; -exec grep -iH queryString {} \; -exec otherprogram {} \; 

If the files are particularly big, encapsulating it in a shell script may be faster then running multiple grep commands

find . -iname "*php" -exec bash -c \
  'out=$(grep -iH queryString "$1"); [[ -n $out ]] && echo "$out" && exit 0 || exit 1' \
bash {} \; -print 

Also note, if the matches are not particularly needed, then

find . -iname "*php" -exec grep -iq queryString {} \; -exec otherprogram {} \;

Will virtually always be faster than then a piped solution like

find . -iname "*php" -print0 | xargs -0 grep -iH | ...

Additionally, you should really have -type f in all cases, unless you want to catch *php directories

Answer 9

Regarding the question of which is faster, and you actually care about the minuscule time difference, which maybe you might if you are trying to see which will save your processor some time... perhaps testing using the command as a suffix to the "time" command, and see which one performs better.