grep
grep programs
grep searches the input files
for lines containing a match to a given
pattern list. When it finds a match in a line, it copies the line to standard
output (by default), or does whatever other sort of output you have requested
with options.
Though grep expects to do the matching on text,
it has no limits on input line length other than available memory,
and it can match arbitrary characters within a line.
If the final byte of an input file is not a newline,
grep silently supplies one.
Since newline is also a separator for the list of patterns, there
is no way to match newline characters in a text.
grep
grep comes with a rich set of options from POSIX.2 and GNU
extensions.
grep, traditional
grep did not conform to POSIX.2, because traditional
grep lacked a `-q' option and its `-s' option behaved
like GNU grep's `-q' option. Shell scripts intended
to be portable to traditional grep should avoid both
`-q' and `-s' and should redirect
output to `/dev/null' instead.
grep to the standard output stream.
This version number should be included in all bug reports.
grep normally outputs either
a one-line message saying that a binary file matches, or no message if
there is no match. If type is `without-match',
grep assumes that a binary file does not match;
this is equivalent to the `-I' option. If type
is `text', grep processes a binary file as if it were
text; this is equivalent to the `-a' option.
Warning: `--binary-files=text' might output binary garbage,
which can have nasty side effects if the output is a terminal and if the
terminal driver interprets some of it as commands.
grep runs on MS-DOS or MS-Windows, the printed
byte offsets
depend on whether the `-u' (`--unix-byte-offsets') option is
used; see below.
grep to print error
messages for every directory). If action is `skip',
directories are silently skipped. If action is `recurse',
grep reads all files under each directory, recursively; this is
equivalent to the `-r' option.
grep guesses the file type by looking
at the contents of the first 32kB read from the file.
If grep decides the file is a text file, it strips the
CR characters from the original file contents (to make
regular expressions with ^ and $ work correctly).
Specifying `-U' overrules this guesswork, causing all
files to be read and passed to the matching mechanism
verbatim; if the file is a text file with CR/LF pairs
at the end of each line, this will cause some regular
expressions to fail. This option has no effect on platforms other than
MS-DOS and MS-Windows.
grep to report byte offsets as if the file were Unix style
text file, i.e., the byte offsets ignore the CR characters which were
stripped. This will produce results identical to running grep on
a Unix machine. This option has no effect unless `-b'
option is also used; it has no effect on platforms other than MS-DOS and
MS-Windows.
mmap system call to read input, instead of
the default read system call. In some situations, `--mmap'
yields better performance. However, `--mmap' can cause undefined
behavior (including core dumps) if an input file shrinks while
grep is operating, or if an I/O error occurs.
NUL character) instead of the
character that normally follows a file name. For example, `grep
-lZ' outputs a zero byte after each file name instead of the usual
newline. This option makes the output unambiguous, even in the presence
of file names containing unusual characters like newlines. This option
can be used with commands like `find -print0', `perl -0',
`sort -z', and `xargs -0' to process arbitrary file names,
even those that contain newline characters.
NUL character) instead of a newline. Like the `-Z'
or `--null' option, this option can be used with commands like
`sort -z' to process arbitrary file names.
Several additional options control which variant of the grep
matching engine is used. See section 4 grep programs.
Grep's behavior is affected by the following environment variables.
GREP_OPTIONS
GREP_OPTIONS is
`--binary-files=without-match --directories=skip', grep
behaves as if the two options `--binary-files=without-match' and
`--directories=skip' had been specified before
any explicit options. Option specifications are separated by
whitespace. A backslash escapes the next character, so it can be used to
specify an option containing whitespace or a backslash.
LC_ALL
LC_MESSAGES
LANG
LC_MESSAGES locale, which determines
the language that grep uses for messages. The locale is determined
by the first of these variables that is set. American English is used
if none of these environment variables are set, or if the message
catalog is not installed, or if grep was not compiled with national
language support (NLS).
LC_ALL
LC_CTYPE
LANG
LC_CTYPE locale, which determines the
type of characters, e.g., which characters are whitespace. The locale is
determined by the first of these variables that is set. The POSIX
locale is used if none of these environment variables are set, or if the
locale catalog is not installed, or if grep was not compiled with
national language support (NLS).
POSIXLY_CORRECT
grep behaves as POSIX.2 requires; otherwise,
grep behaves more like other GNU programs. POSIX.2
requires that options that
follow file names must be treated as file names; by default, such
options are permuted to the front of the operand list and are treated as
options. Also, POSIX.2 requires that unrecognized options be
diagnosed as
"illegal", but since they are not really against the law the default
is to diagnose them as "invalid". POSIXLY_CORRECT also
disables _N_GNU_nonoption_argv_flags_, described below.
_N_GNU_nonoption_argv_flags_
N is grep's numeric process ID.) If the
ith character of this environment variable's value is `1', do
not consider the ith operand of grep to be an option, even if
it appears to be one. A shell can put this variable in the environment
for each command it runs, specifying which operands are the results of
file name wildcard expansion and therefore should not be treated as
options. This behavior is available only with the GNU C library, and
only when POSIXLY_CORRECT is not set.
Normally, exit status is 0 if matches were found, and 1 if no matches were found (the `-v' option inverts the sense of the exit status). Exit status is 2 if there were syntax errors in the pattern, inaccessible input files, or other system errors.
grep programs
grep searches the named input files (or standard input if no
files are named, or the file name `-' is given) for lines containing
a match to the given pattern. By default, grep prints the
matching lines. There are three major variants of grep,
controlled by the following options.
In addition, two variant programs EGREP and FGREP are available. EGREP is the same as `grep -E'. FGREP is the same as `grep -F'.
A regular expression is a pattern that describes a set of strings.
Regular expressions are constructed analogously to arithmetic expressions,
by using various operators to combine smaller expressions.
grep understands two different versions of regular expression
syntax: "basic" and "extended". In GNU grep, there is no
difference in available functionality using either syntax.
In other implementations, basic regular expressions are less powerful.
The following description applies to extended regular expressions;
differences for basic regular expressions are summarized afterwards.
The fundamental building blocks are the regular expressions that match a single character. Most characters, including all letters and digits, are regular expressions that match themselves. Any metacharacter with special meaning may be quoted by preceding it with a backslash. A list of characters enclosed by `[' and `]' matches any single character in that list; if the first character of the list is the caret `^', then it matches any character not in the list. For example, the regular expression `[0123456789]' matches any single digit. A range of characters may be specified by giving the first and last characters, separated by a hyphen.
Finally, certain named classes of characters are predefined, as follows.
Their interpretation depends on the LC_CTYPE locale; the
interpretation below is that of the POSIX locale, which is the default
if no LC_CTYPE locale is specified.
DEL). In other character sets, these are
the equivalent characters, if any.
0 1 2 3 4 5 6 7 8 9.
a b c d e f g h i j k l m n o p q r s t u v w x y z.
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~.
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z.
0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f.
For example, `[[:alnum:]]' means `[0-9A-Za-z]', except the latter depends upon the POSIX locale and the ASCII character encoding, whereas the former is independent of locale and character set. (Note that the brackets in these class names are part of the symbolic names, and must be included in addition to the brackets delimiting the bracket list.) Most metacharacters lose their special meaning inside lists. To include a literal `]', place it first in the list. Similarly, to include a literal `^', place it anywhere but first. Finally, to include a literal `-', place it last.
The period `.' matches any single character. The symbol `\w' is a synonym for `[[:alnum:]]' and `\W' is a synonym for `[^[:alnum]]'.
The caret `^' and the dollar sign `$' are metacharacters that respectively match the empty string at the beginning and end of a line. The symbols `\<' and `\>' respectively match the empty string at the beginning and end of a word. The symbol `\b' matches the empty string at the edge of a word, and `\B' matches the empty string provided it's not at the edge of a word.
A regular expression may be followed by one of several repetition operators:
Two regular expressions may be concatenated; the resulting regular expression matches any string formed by concatenating two substrings that respectively match the concatenated subexpressions.
Two regular expressions may be joined by the infix operator `|'; the resulting regular expression matches any string matching either subexpression.
Repetition takes precedence over concatenation, which in turn takes precedence over alternation. A whole subexpression may be enclosed in parentheses to override these precedence rules.
The backreference `\n', where n is a single digit, matches the substring previously matched by the nth parenthesized subexpression of the regular expression.
In basic regular expressions the metacharacters `?', `+', `{', `|', `(', and `)' lose their special meaning; instead use the backslashed versions `\?', `\+', `\{', `\|', `\(', and `\)'.
Traditional egrep did not support the `{' metacharacter,
and some egrep implementations support `\{' instead, so
portable scripts should avoid `{' in `egrep' patterns and
should use `[{]' to match a literal `{'.
GNU egrep attempts to support traditional usage by
assuming that `{' is not special if it would be the start of an
invalid interval specification. For example, the shell command
`egrep '{1'' searches for the two-character string `{1'
instead of reporting a syntax error in the regular expression.
POSIX.2 allows this behavior as an extension, but portable scripts
should avoid it.
Here is an example shell 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.
See section 5 Regular Expressions. The `-i' option causes grep
to ignore case, causing it to match the line `Hello, world!', which
it would not otherwise match. See section 2 Invoking grep, for more details about
how to invoke grep.
Here are some common questions and answers about grep usage.
grep -l 'main' *.clists the names of all C files in the current directory whose contents mention `main'.
grep -r 'hello' /home/gigisearches for `hello' in all files under the directory `/home/gigi'. For more control of which files are searched, use
find, grep and xargs. For example,
the following command searches only C files:
find /home/gigi -name '*.c' -print | xargs grep 'hello' /dev/null
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.
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'.
grep -C 2 'hello' *prints two lines of context around each matching line.
grep 'eli' /etc/passwd /dev/null
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.
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.
grep 'paul' /etc/motd | grep 'franc,ois'finds all lines that contain both `paul' and `franc,ois'.
cat /etc/passwd | grep 'alain' - /etc/motd
Email bug reports to bug-gnu-utils@gnu.org. Be sure to include the word "grep" somewhere in the "Subject:" field.
Large repetition counts in the `{m,n}' construct may cause
grep to use lots of memory. In addition, certain other
obscure regular expressions require exponential time and
space, and may cause grep to run out of memory.
Backreferences are very slow, and may require exponential time.
This is a general index of all issues discussed in this manual, with the
exception of the grep commands and command-line options.
grep usage
grep, Q&A
This is an alphabetical list of all grep commands, command-line
options, and environment variables.
This document was generated on 29 March 2000 using the texi2html translator version 1.51a.