grep.info: Usage

Top

Reporting Bugs

Regular Expressions

Back to Software Index

4 Usage
*******

Here is an example command that invokes GNU `grep':

     grep -i 'hello.*world' menu.h main.c

This lists all lines in the files `menu.h' and `main.c' that contain
the string `hello' followed by the string `world'; this is because `.*'
matches zero or more characters within a line.  Note: Regular
Expressions.  The `-i' option causes `grep' to ignore case, causing
it to match the line `Hello, world!', which it would not otherwise
match.  Note: Invoking, for more details about how to invoke `grep'.

   Here are some common questions and answers about `grep' usage.

  1. How can I list just the names of matching files?

          grep -l 'main' *.c

     lists the names of all C files in the current directory whose
     contents mention `main'.

  2. How do I search directories recursively?

          grep -r 'hello' /home/gigi

     searches for `hello' in all files under the `/home/gigi' directory.
     For more control over which files are searched, use `find',
     `grep', and `xargs'.  For example, the following command searches
     only C files:

          find /home/gigi -name '*.c' -print0 | xargs -0r grep -H 'hello'

     This differs from the command:

          grep -H 'hello' *.c

     which merely looks for `hello' in all files in the current
     directory whose names end in `.c'.  The `find ...' command line
     above is more similar to the command:

          grep -rH --include='*.c' 'hello' /home/gigi

  3. What if a pattern has a leading `-'?

          grep -e '--cut here--' *

     searches for all lines matching `--cut here--'.  Without `-e',
     `grep' would attempt to parse `--cut here--' as a list of options.

  4. Suppose I want to search for a whole word, not a part of a word?

          grep -w 'hello' *

     searches only for instances of `hello' that are entire words; it
     does not match `Othello'.  For more control, use `\<' and `\>' to
     match the start and end of words.  For example:

          grep 'hello\>' *

     searches only for words ending in `hello', so it matches the word
     `Othello'.

  5. How do I output context around the matching lines?

          grep -C 2 'hello' *

     prints two lines of context around each matching line.

  6. How do I force `grep' to print the name of the file?

     Append `/dev/null':

          grep 'eli' /etc/passwd /dev/null

     gets you:

          /etc/passwd:eli:x:2098:1000:Eli Smith:/home/eli:/bin/bash

     Alternatively, use `-H', which is a GNU extension:

          grep -H 'eli' /etc/passwd

  7. Why do people use strange regular expressions on `ps' output?

          ps -ef | grep '[c]ron'

     If the pattern had been written without the square brackets, it
     would have matched not only the `ps' output line for `cron', but
     also the `ps' output line for `grep'.  Note that on some platforms,
     `ps' limits the output to the width of the screen; `grep' does not
     have any limit on the length of a line except the available memory.

  8. Why does `grep' report "Binary file matches"?

     If `grep' listed all matching "lines" from a binary file, it would
     probably generate output that is not useful, and it might even
     muck up your display.  So GNU `grep' suppresses output from files
     that appear to be binary files.  To force GNU `grep' to output
     lines even from files that appear to be binary, use the `-a' or
     `--binary-files=text' option.  To eliminate the "Binary file
     matches" messages, use the `-I' or `--binary-files=without-match'
     option.

  9. Why doesn't `grep -lv' print non-matching file names?

     `grep -lv' lists the names of all files containing one or more
     lines that do not match.  To list the names of all files that
     contain no matching lines, use the `-L' or `--files-without-match'
     option.

 10. I can do "OR" with `|', but what about "AND"?

          grep 'paul' /etc/motd | grep 'franc,ois'

     finds all lines that contain both `paul' and `franc,ois'.

 11. Why does the empty pattern match every input line?

     The `grep' command searches for lines that contain strings that
     match a pattern.  Every line contains the empty string, so an
     empty pattern causes `grep' to find a match on each line.  It is
     not the only such pattern: `^', `$', `.*', and many other patterns
     cause `grep' to match every line.

     To match empty lines, use the pattern `^$'.  To match blank lines,
     use the pattern `^[[:blank:]]*$'.  To match no lines at all, use
     the command `grep -f /dev/null'.

 12. How can I search in both standard input and in files?

     Use the special file name `-':

          cat /etc/passwd | grep 'alain' - /etc/motd

 13. How to express palindromes in a regular expression?

     It can be done by using back-references; for example, a palindrome
     of 4 characters can be written with a BRE:

          grep -w -e '\(.\)\(.\).\2\1' file

     It matches the word "radar" or "civic."

     Guglielmo Bondioni proposed a single RE that finds all palindromes
     up to 19 characters long using 9 subexpressions and
     9 back-references:

          grep -E -e '^(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?)(.?).?\9\8\7\6\5\4\3\2\1$' file

     Note this is done by using GNU ERE extensions; it might not be
     portable to other implementations of `grep'.

 14. Why is this back-reference failing?

          echo 'ba' | grep -E '(a)\1|b\1'

     This gives no output, because the first alternate `(a)\1' does not
     match, as there is no `aa' in the input, so the `\1' in the second
     alternate has nothing to refer back to, meaning it will never
     match anything.  (The second alternate in this example can only
     match if the first alternate has matched--making the second one
     superfluous.)

 15. How can I match across lines?

     Standard grep cannot do this, as it is fundamentally line-based.
     Therefore, merely using the `[:space:]' character class does not
     match newlines in the way you might expect.  However, if your grep
     is compiled with Perl patterns enabled, the Perl `s' modifier
     (which makes `.' match newlines) can be used:

          printf 'foo\nbar\n' | grep -P '(?s)foo.*?bar'

     With the GNU `grep' option `-z' (Note: File and Directory
     Selection), the input is terminated by null bytes.  Thus, you
     can match newlines in the input, but the output will be the whole
     file, so this is really only useful to determine if the pattern is
     present:

          printf 'foo\nbar\n' | grep -z -q 'foo[[:space:]]\+bar'

     Failing either of those options, you need to transform the input
     before giving it to `grep', or turn to `awk', `sed', `perl', or
     many other utilities that are designed to operate across lines.

 16. What do `grep', `fgrep', and `egrep' stand for?

     The name `grep' comes from the way line editing was done on Unix.
     For example, `ed' uses the following syntax to print a list of
     matching lines on the screen:

          global/regular expression/print
          g/re/p

     `fgrep' stands for Fixed `grep'; `egrep' stands for Extended
     `grep'.