grep(1) 맨 페이지 - 윈디하나의 솔라나라

개요

섹션
맨페이지이름
검색(S)

grep

Name
     grep - search a file for a pattern

Synopsis
     /usr/bin/grep [-c | -l | -q] [-bhinsvw] limited-regular-expression
          [filename]...


     /usr/xpg4/bin/grep [-E | -F] [-c | -l | -q] [-bhinsvx] -e pattern_list...
          [-f pattern_file]... [file]...


     /usr/xpg4/bin/grep [-E | -F] [-c | -l | -q] [-bhinsvx]
          [-e pattern_list]... -f pattern_file... [file]...


     /usr/xpg4/bin/grep [-E | -F] [-c | -l | -q] [-bhinsvx] pattern
          [file]...

Description
     The grep utility searches  text  files  for  a  pattern  and
     prints  all lines that contain that pattern.  It uses a com-
     pact non-deterministic algorithm.


     Be careful using the characters $, *, [, ^, |, (, ),  and  \
     in  the pattern_list because they are also meaningful to the
     shell. It is safest to enclose the  entire  pattern_list  in
     single quotes a'...a'.


     If no files are specified, grep assumes standard input. Nor-
     mally,  each  line  found  is copied to standard output. The
     file name is printed before each line found if there is more
     than one input file.

  /usr/bin/grep
     The /usr/bin/grep utility uses limited  regular  expressions
     like  those  described on the regexp(5) manual page to match
     the patterns.

  /usr/xpg4/bin/grep
     The options -E and  -F  affect  the  way  /usr/xpg4/bin/grep
     interprets     pattern_list.    If    -E    is    specified,
     /usr/xpg4/bin/grep interprets pattern_list as a full regular
     expression  (see  -E  for description).  If -F is specified,
     grep interprets pattern_list as a fixed string.  If  neither
     are specified, grep interprets pattern_list as a basic regu-
     lar expression as described on regex(5) manual page.

Options
     The following options are supported for  both  /usr/bin/grep
     and /usr/xpg4/bin/grep:

     -b
           Precedes each line by the block number on which it was
           found. This can be useful in locating block numbers by
           context (first block is 0).


     -c
           Prints only a count of the lines that contain the pat-
           tern.


     -h
           Prevents the name of the file containing the  matching
           line  from  being  prepended  to that line.  Used when
           searching multiple files.


     -i
           Ignores upper/lower case distinction during  comparis-
           ons.


     -l
           Prints only the names of files  with  matching  lines,
           separated  by NEWLINE characters.  Does not repeat the
           names of files when the pattern  is  found  more  than
           once.


     -n
           Precedes each line by its  line  number  in  the  file
           (first line is 1).


     -q
           Quiet. Does not write anything to the standard output,
           regardless  of  matching lines. Exits with zero status
           if an input line is selected.


     -s
           Suppresses error messages about nonexistent or unread-
           able files.


     -v
           Prints all lines except those that  contain  the  pat-
           tern.


     -w
           Searches for the expression as a word as if surrounded
           by \< and \>.


  /usr/xpg4/bin/grep
     The following options are supported  for  /usr/xpg4/bin/grep
     only:
     -e pattern_list
                        Specifies one or more patterns to be used
                        during  the search for input. Patterns in
                        pattern_list must be separated by a  NEW-
                        LINE  character.  A  null  pattern can be
                        specified by two adjacent newline charac-
                        ters in pattern_list. Unless the -E or -F
                        option is also specified, each pattern is
                        treated  as  a  basic regular expression.
                        Multiple -e and -f options  are  accepted
                        by  grep.  All  of the specified patterns
                        are used when  matching  lines,  but  the
                        order of evaluation is unspecified.


     -E
                        Matches using full  regular  expressions.
                        Treats  each  pattern specified as a full
                        regular expression. If  any  entire  full
                        regular  expression  pattern  matches  an
                        input line, the line is matched.  A  null
                        full  regular  expression  matches  every
                        line. Each pattern is  interpreted  as  a
                        full  regular  expression as described on
                        the regex(5) manual page, except  for  \(
                        and \), and including:

                            1.   A full regular  expression  fol-
                                 lowed  by  + that matches one or
                                 more  occurrences  of  the  full
                                 regular expression.

                            2.   A full regular  expression  fol-
                                 lowed  by  ? that matches 0 or 1
                                 occurrences of the full  regular
                                 expression.

                            3.   Full     regular     expressions
                                 separated  by | or by a new-line
                                 that  match  strings  that   are
                                 matched  by  any  of the expres-
                                 sions.

                            4.   A full regular  expression  that
                                 is  enclosed  in  parentheses ()
                                 for grouping.
                        The order of precedence of  operators  is
                        [],  then *?+, then concatenation, then |
                        and new-line.


     -f pattern_file
                        Reads one or more patterns from the  file
                        named by the path name pattern_file. Pat-
                        terns in pattern_file are terminated by a

                        NEWLINE  character. A null pattern can be
                        specified   by   an   empty    line    in
                        pattern_file.  Unless the -E or -F option
                        is  also  specified,  each   pattern   is
                        treated as a basic regular expression.


     -F
                        Matches using fixed strings. Treats  each
                        pattern  specified as a string instead of
                        a regular expression. If  an  input  line
                        contains  any  of  the patterns as a con-
                        tiguous sequence of bytes,  the  line  is
                        matched.  A  null  string  matches  every
                        line. See fgrep(1) for more information.


     -x
                        Considers only input lines that  use  all
                        characters in the line to match an entire
                        fixed string or regular expression to  be
                        matching lines.

Operands
     The following operands are supported:

     file
             A path name of a file to be searched  for  the  pat-
             terns.  If no file operands are specified, the stan-
             dard input is used.


  /usr/bin/grep
     pattern
                Specifies a pattern to be used during the  search
                for input.


  /usr/xpg4/bin/grep
     pattern
                Specifies one or more patterns to be used  during
                the  search for input. This operand is treated as
                if it were specified as -e pattern_list.

Usage
     The -c, -l and -q options are mutually exclusive. If  speci-
     fied together -q overrides -c which overrides -l.


     The -e pattern_list  option  has  the  same  effect  as  the
     pattern_list operand, but is useful when pattern_list begins
     with the hyphen delimiter. It is also useful when it is more
     convenient  to  provide  multiple patterns as separate argu-
     ments.

     Multiple -e and -f options are accepted and grep uses all of
     the  patterns  it  is given while matching input text lines.
     Notice that the order of evaluation is not specified. If  an
     implementation  finds  a  null  string  as  a pattern, it is
     allowed to use that pattern first, matching every line,  and
     effectively ignore any other patterns.


     The -q option provides a means of easily determining whether
     or  not  a  pattern  (or string) exists in a group of files.
     When searching several  files,  it  provides  a  performance
     improvement  (because  it  can  quit as soon as it finds the
     first match) and requires less care by the user in  choosing
     the  set  of  files to supply as arguments (because it exits
     zero if it finds a match even if grep detected an access  or
     read error on earlier file operands).

  Large File Behavior
     See largefile(5) for the description of the behavior of grep
     when  encountering  files greater than or equal to 2 Gbyte (
     2^31 bytes).

Examples
     Example 1 Finding All Uses of a Word


     To find all uses of the word "Posix" (in any  case)  in  the
     file text.mm, and write with line numbers:


       example% /usr/bin/grep -i -n posix text.mm



     Example 2 Finding All Empty Lines


     To find all empty lines in the standard input:


       example% /usr/bin/grep ^$




     or


       example% /usr/bin/grep -v .

     Example 3 Finding Lines Containing Strings


     All of the following commands  print  all  lines  containing
     strings abc or def or both:


       example% /usr/xpg4/bin/grep `abc
       def'
       example% /usr/xpg4/bin/grep -e `abc
       def'
       example% /usr/xpg4/bin/grep -e `abc' -e `def'
       example% /usr/xpg4/bin/grep -E `abc|def'
       example% /usr/xpg4/bin/grep -E -e `abc|def'
       example% /usr/xpg4/bin/grep -E -e `abc' -e `def'
       example% /usr/xpg4/bin/grep -E `abc
       def'
       example% /usr/xpg4/bin/grep -E -e `abc
       def'
       example% /usr/xpg4/bin/grep -F -e `abc' -e `def'
       example% /usr/xpg4/bin/grep -F `abc
       def'
       example% /usr/xpg4/bin/grep -F -e `abc
       def'



     Example 4 Finding Lines with Matching Strings


     Both of the following  commands  print  all  lines  matching
     exactly abc or def:


       example% /usr/xpg4/bin/grep -E `^abc$ ^def$'
       example% /usr/xpg4/bin/grep -F -x `abc def'

Environment Variables
     See environ(5) for descriptions of the following environment
     variables  that  affect the execution of grep: LANG, LC_ALL,
     LC_COLLATE, LC_CTYPE, LC_MESSAGES, and NLSPATH.

Exit Status
     The following exit values are returned:

     0
          One or more matches were found.


     1
          No matches were found.

     2
          Syntax errors or inaccessible files  (even  if  matches
          were found).

Attributes
     See attributes(5) for descriptions of the  following  attri-
     butes:

  /usr/bin/grep
     tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i)  ATTRI-
     BUTE  TYPEATTRIBUTE  VALUE  _  Availabilitysystem/core-os  _
     CSINot Enabled


  /usr/xpg4/bin/grep
     tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i)  ATTRI-
     BUTE  TYPEATTRIBUTE  VALUE _ Availabilitysystem/xopen/xcu4 _
     CSIEnabled  _  Interface  StabilityCommitted  _  StandardSee
     standards(5).

See Also
     egrep(1),   fgrep(1),    sed(1),    sh(1),    attributes(5),
     environ(5), largefile(5), regex(5), regexp(5), standards(5)

Notes
  /usr/bin/grep
     Lines are limited only by the size of the available  virtual
     memory.  If  there  is a line with embedded nulls, grep only
     matches up to the first  null.  If  the  line  matches,  the
     entire line is printed.

  /usr/xpg4/bin/grep
     The results are unspecified if  input  files  contain  lines
     longer  than LINE_MAX bytes or contain binary data. LINE_MAX
     is defined in /usr/include/limits.h.
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.
RSS ATOM XHTML 1.0 CSS3