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