grep (逐行处理文本)

grep [OPTIONS] PATTERN [FILE...]

Overview

Grep, which stands for "global regular expression print," is a powerful tool for matching a regular expression against text in a file, multiple files, or a stream of input. It searches for the PATTERN of text that you specify on the command line, and outputs the results for you.

Let's say want to quickly locate the phrase "our products" in HTML files on your machine. Let's start by searching a single file. Here, our PATTERN is "our products" and our FILE is product-listing.html.

A single line was found containing our pattern, and grep outputs the entire matching line to the terminal. The line is longer than our terminal width so the text wraps around to the following lines, but this output corresponds to exactly one line in our FILE.

Note: The PATTERN is interpreted by grep as a regular expression. In the above example, all the characters we used (letters and a space) are interpreted literally in regular expressions, so only the exact phrase will be matched. Other characters have special meanings, however — some punctuation marks, for example. For more information, see our Regular Expression Quick Reference.

Viewing grep output in color

If we use the --color option, our successful matches will be highlighted for us:

It will be even more useful if we know where the matching line appears in our file. If we specify the -n option, grep will prefix each matching line with the line number:

Our matching line is prefixed with "18:" which tells us this corresponds to line 18 in our file.

What if "our products" appears at the beginning of a sentence, or appears in all uppercase? We can specify the -i option to perform a case-insensitive match:

Using the -i option, grep finds a match on line 23 as well.

If we have multiple files to search, we can search them all using a wildcard in our FILE name. Instead of specifying product-listing.html, we can use an asterisk ("*") and the .html extension. When the command is executed, the shell will expand the asterisk to the name of any file it finds (within the current directory) which ends in ".html".

Notice that each line starts with the specific file where that match occurs.

We can extend our search to subdirectories and any files they contain using the -r option, which tells grep to perform its search recursively. Let's change our FILE name to just an asterisk ("*"), so that it will match any file or directory name, and not just HTML files:

This gives us three additional matches. Notice that the directory name is included for any matching files that are not in the current directory.

The true power of grep is that it can be used to match regular expressions. (That's what the "re" in "grep" stands for). Regular expressions use special characters in the PATTERN string to match a wider array of strings. Let's look at a simple example.

Let's say you want to find every occurrence of a phrase similar to "our products" in your HTML files, but the phrase should always start with "our" and end with "products". We can specify this PATTERN instead: "our.*products".

In regular expressions, the period (".") is interpreted as a single-character wildcard. It means "any character that appears in this place will match." The asterisk ("*") means "the preceding character, appearing zero or more times, will match." So the combination ".*" will match any number of any character. For instance, "our amazing products", "ours, the best-ever products", and even "ourproducts" will match. And because we're specifying the -i option, "OUR PRODUCTS" and "OuRpRoDuCtS will match as well. Let's run the command with this regular expression, and see what additional matches we can get:

Here, we also got a match from the phrase "our fine products".

Grep is a powerful tool that can help you work with text files, and it gets even more powerful when you become comfortable using regular expressions.

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

Also, three variant programs egrep, fgrep and rgrep are available:

• egrep is the same as running grep -E. In this mode, grep evaluates your PATTERN string as an extended regular expression (ERE). Nowadays, ERE does not "extend" very far beyond basic regular expressions, but they can still be very useful. 
• fgrep is the same as running grep -F. In this mode, grep evaluates your PATTERN string as a "fixed string" — every character in your string is treated literally. For example, if your string contains an asterisk ("*"), grep will try to match it with an actual asterisk rather than interpreting this as a wildcard. If your string contains multiple lines (if it contains newlines), each line will be considered a fixed string, and any of them can trigger a match.
• rgrep is the same as running grep -r. In this mode, grep will perform its search recursively. If it encounters a directory, it will traverse into that directory and continue searching. (Symbolic links are ignored; if you want to search directories that are symbolically linked, you should use the -R option instead).

In older operating systems, egrep, fgrep and rgrep were distinct programs with their own executables. In modern systems, these special command names are shortcuts to grep with the appropriate flags enabled. They are functionally equivalent.

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" (BRE), "extended" (ERE) and "perl" (PRCE). 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.

The fundamental building blocks are the regular expressions that match a single character. Most characters, including all letters and digits, are regular expressions that match themselves. Any meta-character with special meaning may be quoted by preceding it with a backslash.

The period (.) matches any single character.

A bracket expression is a list of characters enclosed by [ and ]. It matches any single character in that list; if the first character of the list is the caret ^ then it matches any character not in the list. For example, the regular expression [0123456789] matches any single 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.

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

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

A regular expression may be followed by one of several repetition operators:

Two regular expressions may be concatenated; the resulting regular expression matches any string formed by concatenating two substringsthat respectively match the concatenated expressions.

Two regular expressions may be joined by the infix operator |; the resulting regular expression matches any string matching either alternate expression.

Repetition takes precedence over concatenation, which in turn takes precedence over alternation. A whole expression may be enclosed in parentheses to override these precedence rules and form a subexpression.

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

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

Traditional versions of 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.

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

Other variables of note:

The exit status is 0 if selected lines are found, and 1 if not found. If an error occurred the exit status is 2.