LinuxGuruz
Toll Free Numbers
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads
  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    grep

    
    
    

    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 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)

    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

Toll Free Numbers

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz