Grep OSX – How to Grep 20 Characters Before and After Match

GNU grep has the -P option for perl-style regexes, and the -o option to print only what matches the pattern. These can be combined using look-around assertions (described under Extended Patterns in the perlre manpage) to remove part of the grep pattern from what is determined to have matched for the purposes of -o.

$ grep -oP 'foobar \K\w+' test.txt
bash
happy
$

The \K is the short-form (and more efficient form) of (?<=pattern) which you use as a zero-width look-behind assertion before the text you want to output. (?=pattern) can be used as a zero-width look-ahead assertion after the text you want to output.

For instance, if you wanted to match the word between foo and bar, you could use:

$ grep -oP 'foo \K\w+(?= bar)' test.txt

or (for symmetry)

$ grep -oP '(?<=foo )\w+(?= bar)' test.txt

With GNU grep:

N=10; grep -roP ".{0,$N}foo.{0,$N}" .

Explanation:

• -o => Print only what you matched
• -P => Use Perl-style regular expressions
• The regex says match 0 to $N characters followed by foo followed by 0 to $N characters.

If you don't have GNU grep:

find . -type f -exec \
    perl -nle '
        BEGIN{$N=10}
        print if s/^.*?(.{0,$N}foo.{0,$N}).*?$/$ARGV:$1/
    ' {} \;

Explanation:

Since we can no longer rely on grep being GNU grep, we make use of find to search for files recursively (the -r action of GNU grep). For each file found, we execute the Perl snippet.

Perl switches:

• -n Read the file line by line
• -l Remove the newline at the end of each line and put it back when printing
• -e Treat the following string as code

The Perl snippet is doing essentially the same thing as grep. It starts by setting a variable $N to the number of context characters you want. The BEGIN{} means this is executed only once at the start of execution not once for every line in every file.

The statement executed for each line is to print the line if the regex substitution works.

The regex:

• Match any old thing lazily¹ at the start of line (^.*?) followed by .{0,$N} as in the grep case, followed by foofollowed by another .{0,$N} and finally match any old thing lazily till the end of line (.*?$).
• We substitute this with $ARGV:$1. $ARGV is a magical variable that holds the name of the current file being read. $1 is what the parens matched: the context in this case.
• The lazy matches at either end are required because a greedy match would eat all characters before foo without failing to match (since .{0,$N} is allowed to match zero times).

¹_{That is, prefer not to match anything unless this would cause the overall match to fail. In short, match as few characters as possible.}