Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
grep(1)								       grep(1)

NAME
       grep - search a file for	a pattern

SYNOPSIS
       /usr/bin/grep [-bchilnsvw] limited-regular-expression [filename...]

       /usr/xpg4/bin/grep  [-E	|  -F]	 [-c  |	 -l | -q]  [-bhinsvwx] -e pat-
       tern_list...  [-f pattern_file]... [file...]

       /usr/xpg4/bin/grep [-E |	-F]  [-c |  -l	|  -q]	 [-bhinsvwx]  [-e pat-
       tern_list...] -f	pattern_file...	[file...]

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

       The grep	utility	searches text files for	a pattern and prints all lines
       that  contain  that pattern.  It	uses a compact non-deterministic algo-
       rithm.

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

       If no files are specified, grep assumes standard	input. Normally,  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 pat-
       tern_list. If  -E  is  specified,  /usr/xpg4/bin/grep  interprets  pat-
       tern_list as a full regular expression (see -E for description).	 If -F
       is specified, grep interprets pattern_list as a fixed string.  If  nei-
       ther  are  specified,  grep  interprets pattern_list as a basic regular
       expression as described on regex(5) manual page.

       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 pattern.

       -h	Prevents  the  name  of	 the file containing the matching line
		from being appended to that line.  Used	when searching	multi-
		ple files.

       -i	Ignores	upper/lower case distinction during comparisons.

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

       -s	Suppresses error  messages  about  nonexistent	or  unreadable
		files.

       -v	Prints all lines except	those that contain the pattern.

       -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 sep-
		       arated by a NEWLINE character. A	null  pattern  can  be
		       specified  by  two  adjacent newline characters in pat-
		       tern_list. Unless the -E	or -F option  is  also	speci-
		       fied,  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 unspeci-
		       fied.

       -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  expres-
		       sion  matches  every line.  Each	pattern	is interpreted
		       as a  full  regular  expression	as  described  on  the
		       regex(5)	manual page, except for	\( and \), and includ-
		       ing:

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

			   2.  A full regular expression followed  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 expressions.

			   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.  Patterns 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	speci-
		       fied as a string	instead	of a regular expression. If an
		       input line contains any of the patterns as a contiguous
		       sequence	of bytes, the line is matched. A  null	string
		       matches every line.  See	fgrep(1) for more information.

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

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

       The following operands are supported:

       file	       A path name of a	file to	be searched for	the  patterns.
		       If  no  file operands are specified, the	standard 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.

       The  -e pattern_list option has the same	effect as the pattern_list op-
       erand, but is useful when pattern_list begins with  the	hyphen	delim-
       iter.  It is also useful	when it	is more	convenient to provide multiple
       patterns	as separate arguments.

       Multiple	-e and -f options are accepted and grep	uses all of  the  pat-
       terns  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).

       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'

       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.

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

       See attributes(5) for descriptions of the following attributes:

   /usr/bin/grep
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWcsu			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Not Enabled		   |
       +-----------------------------+-----------------------------+

   /usr/xpg4/bin/grep
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWxcu4			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Enabled			   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Standard			   |
       +-----------------------------+-----------------------------+

       egrep(1),  fgrep(1),  sed(1),  sh(1), attributes(5), environ(5),	large-
       file(5),	regex(5), regexp(5), standards(5)

   /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.

				  23 May 2005			       grep(1)

NAME | SYNOPSIS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=grep&sektion=1&manpath=SunOS+5.10>

home | help