Home : Computers : Linux : Man Pages : egrep

egrep


SYNOPSIS

       grep [OPTIONS] PATTERN [FILE...]
       grep [OPTIONS] [-e PATTERN | -f FILE] [FILE...]


DESCRIPTION

       grep  searches the named input FILEs (or standard input if no files are
       named, or if a single hyphen-minus (-) is given as file name) for lines
       containing  a  match to the given PATTERN.  By default, grep prints the
       matching lines.

       In addition, two variant programs egrep and fgrep are available.  egrep
       is  the  same  as  grep -E.   fgrep  is  the  same  as grep -F.  Direct
       invocation as either egrep or fgrep is deprecated, but is  provided  to
       allow historical applications that rely on them to run unmodified.


OPTIONS

   Generic Program Information
       --help Print  a  usage  message  briefly summarizing these command-line
              options and the bug-reporting address, then exit.

       -V, --version
              Print the version number of grep to the standard output  stream.
              This  version  number should be included in all bug reports (see
              below).

   Matcher Selection
       -E, --extended-regexp
              Interpret PATTERN as an extended regular  expression  (ERE,  see
              below).  (-E is specified by POSIX.)

       -F, --fixed-strings, --fixed-regexp
              Interpret  PATTERN  as  a  list  of  fixed strings, separated by
              newlines, any of which is to be matched.  (-F  is  specified  by
              POSIX,  --fixed-regexp  is an obsoleted alias, please do not use
              it in new scripts.)

       -G, --basic-regexp
              Interpret PATTERN  as  a  basic  regular  expression  (BRE,  see
              below).  This is the default.

       -P, --perl-regexp
              Interpret  PATTERN as a Perl regular expression.  This is highly
              experimental and grep -P may warn of unimplemented features.

   Matching Control
       -e PATTERN, --regexp=PATTERN
              Use PATTERN as  the  pattern.   This  can  be  used  to  specify
              multiple search patterns, or to protect a pattern beginning with
              a hyphen (-).  (-e is specified by POSIX.)

       -f FILE, --file=FILE
              Obtain patterns  from  FILE,  one  per  line.   The  empty  file
              at the  beginning  of  the  line,  or  preceded  by  a  non-word
              constituent  character.  Similarly, it must be either at the end
              of the line or followed by  a  non-word  constituent  character.
              Word-constituent   characters   are  letters,  digits,  and  the
              underscore.

       -x, --line-regexp
              Select only those matches that exactly  match  the  whole  line.
              (-x is specified by POSIX.)

       -y     Obsolete synonym for -i.

   General Output Control
       -c, --count
              Suppress  normal output; instead print a count of matching lines
              for each input file.  With the -v,  --invert-match  option  (see
              below), count non-matching lines.  (-c is specified by POSIX.)

       --color[=WHEN], --colour[=WHEN]
              Surround   the  matched  (non-empty)  strings,  matching  lines,
              context lines, file  names,  line  numbers,  byte  offsets,  and
              separators  (for fields and groups of context lines) with escape
              sequences to display them in color on the terminal.  The  colors
              are  defined  by  the  environment  variable  GREP_COLORS.   The
              deprecated environment variable GREP_COLOR is  still  supported,
              but  its setting does not have priority.  WHEN is never, always,
              or auto.

       -L, --files-without-match
              Suppress normal output; instead print the  name  of  each  input
              file from which no output would normally have been printed.  The
              scanning will stop on the first match.

       -l, --files-with-matches
              Suppress normal output; instead print the  name  of  each  input
              file  from  which  output would normally have been printed.  The
              scanning will stop on the first  match.   (-l  is  specified  by
              POSIX.)

       -m NUM, --max-count=NUM
              Stop  reading  a file after NUM matching lines.  If the input is
              standard input from a regular file, and NUM matching  lines  are
              output,  grep  ensures  that the standard input is positioned to
              just after the last matching line before exiting, regardless  of
              the  presence of trailing context lines.  This enables a calling
              process to resume a search.  When grep stops after NUM  matching
              lines,  it  outputs  any trailing context lines.  When the -c or
              --count option is also  used,  grep  does  not  output  a  count
              greater  than NUM.  When the -v or --invert-match option is also
              used, grep stops after outputting NUM non-matching lines.

       -o, --only-matching
              its -s option behaved like GNU  grep.   Portable  shell  scripts
              should  avoid  both  -q  and -s and should redirect standard and
              error output to /dev/null instead.  (-s is specified by POSIX.)

   Output Line Prefix Control
       -b, --byte-offset
              Print the 0-based byte offset within the input file before  each
              line of output.  If -o (--only-matching) is specified, print the
              offset of the matching part itself.

       -H, --with-filename
              Print the file name for each match.  This is  the  default  when
              there is more than one file to search.

       -h, --no-filename
              Suppress  the  prefixing  of  file names on output.  This is the
              default when there is only one file (or only standard input)  to
              search.

       --label=LABEL
              Display  input  actually  coming  from  standard  input as input
              coming  from  file  LABEL.   This  is  especially  useful   when
              implementing  tools  like  zgrep,  e.g.,  gzip -cd foo.gz | grep
              --label=foo -H something.  See also the -H option.

       -n, --line-number
              Prefix each line of output with the 1-based line  number  within
              its input file.  (-n is specified by POSIX.)

       -T, --initial-tab
              Make  sure  that the first character of actual line content lies
              on a tab stop, so that the alignment of tabs looks normal.  This
              is  useful  with  options that prefix their output to the actual
              content: -H,-n, and -b.  In order  to  improve  the  probability
              that lines from a single file will all start at the same column,
              this also causes the line number and byte offset (if present) to
              be printed in a minimum size field width.

       -u, --unix-byte-offsets
              Report  Unix-style  byte  offsets.   This  switch causes grep to
              report byte offsets as if the file were a Unix-style text  file,
              i.e.,  with  CR  characters  stripped  off.   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.

       -Z, --null
              Output a zero byte (the ASCII  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
              Places a line containing  a  group  separator  (described  under
              --group-separator)  between  contiguous groups of matches.  With
              the -o or --only-matching option,  this  has  no  effect  and  a
              warning is given.

       -C NUM, -NUM, --context=NUM
              Print  NUM  lines of output context.  Places a line containing a
              group  separator  (described  under  --group-separator)  between
              contiguous  groups  of  matches.  With the -o or --only-matching
              option, this has no effect and a warning is given.

       --group-separator=SEP
              Use SEP as a group separator. By default SEP  is  double  hyphen
              (--).

       --no-group-separator
              Use empty string as a group separator.

   File and Directory Selection
       -a, --text
              Process  a binary file as if it were text; this is equivalent to
              the --binary-files=text option.

       --binary-files=TYPE
              If the first few bytes of a file indicate that the file contains
              binary  data, assume that the file is of type TYPE.  By default,
              TYPE is binary, and 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: grep
              --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.

       -D ACTION, --devices=ACTION
              If an input file is a device, FIFO  or  socket,  use  ACTION  to
              process  it.   By  default,  ACTION  is  read,  which means that
              devices are read just as if they were ordinary files.  If ACTION
              is skip, devices are silently skipped.

       -d ACTION, --directories=ACTION
              If  an  input file is a directory, use ACTION to process it.  By
              default, ACTION is read, i.e., read directories just as if  they
              were   ordinary   files.   If  ACTION  is  skip,  silently  skip
              directories.  If ACTION is recurse, read all  files  under  each
              directory,  recursively,  following  symbolic links only if they
              are on the command line.  This is equivalent to the -r option.

       --exclude=GLOB
              Skip  files  whose  base  name  matches  GLOB  (using   wildcard
              this is equivalent to the --binary-files=without-match option.

       --include=GLOB
              Search  only  files whose base name matches GLOB (using wildcard
              matching as described under --exclude).

       -r, --recursive
              Read all files  under  each  directory,  recursively,  following
              symbolic  links  only  if they are on the command line.  This is
              equivalent to the -d recurse option.

       -R, --dereference-recursive
              Read all files under each directory,  recursively.   Follow  all
              symbolic links, unlike -r.

   Other Options
       --line-buffered
              Use  line  buffering  on  output.   This can cause a performance
              penalty.

       -U, --binary
              Treat the file(s) as binary.  By default, under MS-DOS  and  MS-
              Windows,  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.

       -z, --null-data
              Treat the input as a set of lines, each  terminated  by  a  zero
              byte  (the  ASCII 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.


REGULAR EXPRESSIONS

       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 three different versions of regular expression syntax:
       "basic," "extended" and "perl." In GNU grep, there is no difference  in
       available  functionality between basic and extended syntaxes.  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.
       Perl   regular  expressions  give  additional  functionality,  and  are
       documented  in  pcresyntax(3)  and  pcrepattern(3),  but  may  not   be
       digit.

       Within a  bracket  expression,  a  range  expression  consists  of  two
       characters separated by a hyphen.  It matches any single character that
       sorts  between  the  two  characters,  inclusive,  using  the  locale's
       collating  sequence  and  character set.  For example, in the default C
       locale, [a-d] is equivalent to [abcd].  Many locales sort characters in
       dictionary   order,  and  in  these  locales  [a-d]  is  typically  not
       equivalent to [abcd]; it might be equivalent to [aBbCcDd], for example.
       To  obtain  the  traditional interpretation of bracket expressions, you
       can use the C locale by setting the LC_ALL environment variable to  the
       value C.

       Finally,  certain  named  classes  of  characters are predefined within
       bracket expressions, as follows.  Their names are self explanatory, and
       they   are   [:alnum:],  [:alpha:],  [:cntrl:],  [:digit:],  [:graph:],
       [:lower:], [:print:], [:punct:], [:space:], [:upper:], and  [:xdigit:].
       For  example,  [[:alnum:]]  means  the  character  class of numbers and
       letters in the current locale. In the C locale and ASCII character  set
       encoding,  this is the same as [0-9A-Za-z].  (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 expression.)  Most
       meta-characters lose their special meaning inside bracket  expressions.
       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.

   Anchoring
       The caret ^ and the dollar sign $ are meta-characters that respectively
       match the empty string at the beginning and end of a line.

   The Backslash Character and Special Expressions
       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.  The symbol \w is a synonym for [_[:alnum:]] and
       \W is a synonym for [^_[:alnum:]].

   Repetition
       A regular expression may be  followed  by  one  of  several  repetition
       operators:
       ?      The preceding item is optional and matched at most once.
       *      The preceding item will be matched zero or more times.
       +      The preceding item will be matched one or more times.
       {n}    The preceding item is matched exactly n times.
       {n,}   The preceding item is matched n or more times.
       {,m}   The  preceding  item  is matched at most m times.  This is a GNU
              extension.
       {n,m}  The preceding item is matched at least n  times,  but  not  more
              than m times.

   Concatenation

   Back References and Subexpressions
       The back-reference \n, where n is a single digit, matches the substring
       previously  matched  by  the  nth  parenthesized  subexpression  of the
       regular expression.

   Basic vs Extended Regular Expressions
       In basic regular expressions the meta-characters ?, +, {, |, (,  and  )
       lose  their  special  meaning; instead use the backslashed versions \?,
       \+, \{, \|, \(, and \).

       Traditional egrep did not support the { meta-character, and some  egrep
       implementations  support \{ instead, so portable scripts should avoid {
       in grep -E patterns and should use [{] to match a literal {.

       GNU grep -E 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 command grep -E '{1' searches for  the
       two-character  string  {1  instead  of  reporting a syntax error in the
       regular expression.  POSIX allows this behavior as  an  extension,  but
       portable scripts should avoid it.


ENVIRONMENT VARIABLES

       The   behavior  of  grep  is  affected  by  the  following  environment
       variables.

       The locale for category LC_foo is  specified  by  examining  the  three
       environment  variables  LC_ALL, LC_foo, LANG, in that order.  The first
       of these variables that is set specifies the locale.  For  example,  if
       LC_ALL  is not set, but LC_MESSAGES is set to pt_BR, then the Brazilian
       Portuguese locale is used for the LC_MESSAGES category.  The  C  locale
       is  used  if none of these environment variables are set, if the locale
       catalog is not installed, or if grep was  not  compiled  with  national
       language support (NLS).

       GREP_OPTIONS
              This variable specifies default options to be placed in front of
              any  explicit  options.   For  example,   if   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.

       GREP_COLOR
              This variable specifies the  color  used  to  highlight  matched
              (non-empty) text.  It is deprecated in favor of GREP_COLORS, but
              still supported.  The mt, ms, and mc capabilities of GREP_COLORS
              have  priority  over  it.  It can only specify the color used to
              highlight the matching non-empty text in any  matching  line  (a
              selected  line  when the -v command-line option is omitted, or a
                     matching  lines  when  -v  is specified).  If however the
                     boolean rv capability and the -v command-line option  are
                     both  specified,  it  applies  to  context matching lines
                     instead.  The default  is  empty  (i.e.,  the  terminal's
                     default color pair).

              cx=    SGR substring for whole context lines (i.e., non-matching
                     lines when the -v  command-line  option  is  omitted,  or
                     matching  lines  when  -v  is specified).  If however the
                     boolean rv capability and the -v command-line option  are
                     both specified, it applies to selected non-matching lines
                     instead.  The default  is  empty  (i.e.,  the  terminal's
                     default color pair).

              rv     Boolean  value  that reverses (swaps) the meanings of the
                     sl= and cx= capabilities when the -v command-line  option
                     is specified.  The default is false (i.e., the capability
                     is omitted).

              mt=01;31
                     SGR substring for matching non-empty text in any matching
                     line  (i.e.,  a  selected  line  when the -v command-line
                     option  is  omitted,  or  a  context  line  when  -v   is
                     specified).   Setting  this is equivalent to setting both
                     ms= and mc= at once to the same value.  The default is  a
                     bold   red   text   foreground   over  the  current  line
                     background.

              ms=01;31
                     SGR substring for matching non-empty text in  a  selected
                     line.  (This is only used when the -v command-line option
                     is omitted.)  The effect  of  the  sl=  (or  cx=  if  rv)
                     capability  remains  active  when  this  kicks  in.   The
                     default is a bold red text foreground  over  the  current
                     line background.

              mc=01;31
                     SGR  substring  for  matching non-empty text in a context
                     line.  (This is only used when the -v command-line option
                     is  specified.)   The  effect  of  the cx= (or sl= if rv)
                     capability  remains  active  when  this  kicks  in.   The
                     default  is  a  bold red text foreground over the current
                     line background.

              fn=35  SGR substring for file names prefixing any content  line.
                     The  default  is  a  magenta  text  foreground  over  the
                     terminal's default background.

              ln=32  SGR substring for  line  numbers  prefixing  any  content
                     line.   The  default  is a green text foreground over the
                     terminal's default background.

                     terminals for which the  back_color_erase  (bce)  boolean
                     terminfo  capability  does  not  apply,  when  the chosen
                     highlight colors do not affect the background, or when EL
                     is  too  slow or causes too much flicker.  The default is
                     false (i.e., the capability is omitted).

              Note that boolean capabilities have no  =...   part.   They  are
              omitted (i.e., false) by default and become true when specified.

              See   the   Select   Graphic  Rendition  (SGR)  section  in  the
              documentation of the text terminal that is  used  for  permitted
              values   and  their  meaning  as  character  attributes.   These
              substring values are integers in decimal representation and  can
              be  concatenated with semicolons.  grep takes care of assembling
              the result into a  complete  SGR  sequence  (\33[...m).   Common
              values to concatenate include 1 for bold, 4 for underline, 5 for
              blink, 7 for inverse, 39 for default foreground color, 30 to  37
              for  foreground  colors,  90  to 97 for 16-color mode foreground
              colors, 38;5;0 to 38;5;255  for  88-color  and  256-color  modes
              foreground colors, 49 for default background color, 40 to 47 for
              background colors, 100  to  107  for  16-color  mode  background
              colors,  and 48;5;0 to 48;5;255 for 88-color and 256-color modes
              background colors.

       LC_ALL, LC_COLLATE, LANG
              These variables specify the locale for the LC_COLLATE  category,
              which  determines the collating sequence used to interpret range
              expressions like [a-z].

       LC_ALL, LC_CTYPE, LANG
              These variables specify the locale for  the  LC_CTYPE  category,
              which  determines the type of characters, e.g., which characters
              are whitespace.

       LC_ALL, LC_MESSAGES, LANG
              These variables specify the locale for the LC_MESSAGES category,
              which  determines the language that grep uses for messages.  The
              default C locale uses American English messages.

       POSIXLY_CORRECT
              If set, grep behaves as POSIX requires; otherwise, grep  behaves
              more  like other GNU programs.  POSIX 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 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_
              (Here N is grep's numeric process ID.)  If the ith character  of

       it is therefore advisable, for the sake of portability,  to  use  logic
       that  tests  for  this  general  condition  instead  of strict equality
       with 2.


COPYRIGHT

       Copyright 1998-2000, 2002, 2005-2014 Free Software Foundation, Inc.

       This is free software; see the source for copying conditions.  There is
       NO  warranty;  not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR
       PURPOSE.


BUGS

   Reporting Bugs
       Email bug reports to <bug-grep@gnu.org>, a mailing list whose web  page
       is  <http://lists.gnu.org/mailman/listinfo/bug-grep>.   grep's Savannah
       bug tracker is located at <http://savannah.gnu.org/bugs/?group=grep>.

   Known Bugs
       Large repetition counts in the {n,m} 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.

       Back-references are very slow, and may require exponential time.


SEE ALSO

   Regular Manual Pages
       awk(1),  cmp(1),  diff(1),  find(1), gzip(1), perl(1), sed(1), sort(1),
       xargs(1), zgrep(1), read(2),  pcre(3),  pcresyntax(3),  pcrepattern(3),
       terminfo(5), glob(7), regex(7).

   POSIX Programmer's Manual Page
       grep(1p).

   TeXinfo Documentation
       The  full  documentation  for  grep  is maintained as a TeXinfo manual,
       which you can read at http://www.gnu.org/software/grep/manual/.  If the
       info and grep programs are properly installed at your site, the command

              info grep

       should give you access to the complete manual.


NOTES

       This  man  page  is maintained only fitfully; the full documentation is
       often more up-to-date.

       GNU's not Unix, but Unix is a beast; its plural form is Unixen.


User Commands GNU grep 2.20 GREP(1)



Subscribe to us on YouTube