Grep Command Builder

Build a grep command without remembering which of -E, -F, -P and -G you need, or why --include sometimes does nothing. Type the text or pattern you are looking for, choose how grep should read it (basic, extended, fixed string or PCRE), decide whether case matters, point it at a file or a directory tree, and pick the output you want: matching lines with context, line numbers, a count, or just the list of files that contain a match. The command is assembled as you type, every flag is explained in plain English, and a checks panel catches the mistakes that quietly return the wrong results — a \d in a basic regex, -o combined with -v, context options that a summary flag silently ignores. The pattern tester below runs the same pattern against text you paste or load, highlighting every match line by line, so you can confirm it matches what you think before you touch a terminal. Everything runs in your browser, nothing is uploaded, and no command is executed here.

100% private. The builder, the pattern tester and the generated script are all created with JavaScript in this tab. Patterns, filenames and any file you load are read with the browser’s own FileReader API — they are never sent to this website or to anyone else, and nothing is ever executed — you review the command and run it yourself.

Quick starts

1. What to search for

Text or pattern One pattern per line. Two or more patterns are OR-ed together with -e, which is how grep searches for alternatives without writing a regular expression.

How grep should read the pattern -E gives you + ? | ( ) { } as operators. In basic mode those characters are literals and you need \+, \|, \(.

Case

Whole words only — -w

Whole lines only — -x

Show lines that do not match — -v

2. Where to search

File or directory Paths with spaces or globs are quoted for you. A directory only works with recursion — without it grep prints “Is a directory” and moves on. Recursion -R follows symlinked directories and can loop forever on a bad link. Prefer -r.

Only these files (--include) Comma separated globs matched against the file name. Needs recursion; without -r it is silently ignored. Never these files (--exclude) Matched against the file name, so *.min.js works and vendor/* does not. Never these directories (--exclude-dir) Prunes the directory before grep descends into it, so this is also a big speed win.

3. What to print

Context lines (-C) Lines of context before and after each match. Leave empty for none. Lines before only (-B) Ignored when -C is set — use one or the other. Lines after only (-A) Useful for stack traces, where the interesting part follows the error line.

File names in the output Stop after N matches per file Emits -m N. Handy for finding the first occurrence in each file. Binary files Without -I, one stray binary in a source tree turns your output into noise.

Line numbers — -n

Colour the match — --color=always

Only the matched text — -o

Count matching lines — -c

List the files that match — -l

List the files that don’t — -L

Silent, exit status only — -q

Generated command

Ready

Checks on this command

What each part does

Part	Plain English

Test the pattern on your own text

Paste a log file, a config snippet or a block of source and see exactly which lines match, with every hit highlighted. This runs the pattern from step 1 through the browser’s regex engine — it is an approximation of GNU grep (the differences are noted below), but it catches the expensive mistakes: a pattern that matches nothing, or one that matches every line.

Sample text

Browser regex flavour: JavaScript, which is close to -E and (for the basics) to -P. Lookarounds and \d work here and in -P, but not in basic or extended mode; POSIX bracket expressions such as [[:digit:]] work in grep but not here. -w and -x are approximated the way grep applies them to each line.

Paste an existing grep command

Drop a command you already have (from a script, a man page or your shell history) and the form is filled in from it. Anything the form cannot represent is listed so you know what will be dropped.

A loaded file is read with the browser’s FileReader — it is never uploaded.

How it works

grep reads each line of its input and prints the ones that match a pattern. That is the whole idea, and almost every surprise comes from two details: which regex dialect is in use, and what grep does when you point it at a directory. By default grep reads a basic regular expression (BRE), in which + ? | ( ) { } are ordinary characters. -E switches to extended regular expressions, where they become operators — which is why grep 'a|b' silently searches for the literal text a|b while grep -E 'a|b' searches for either letter. This builder defaults to -E for that reason.

Recursion is the other trap. grep pattern dir/ does not search inside dir, it just prints grep: dir: Is a directory; you need -r. Once you have -r, the --include, --exclude and --exclude-dir filters start working — they are ignored without it, which is the single most common reason a “filtered” grep returns everything. --include and --exclude match the file name (GNU grep also matches the path), so --include='*.py' is right and --include='src/*.py' is not portable.

Context comes from -A (after), -B (before) and -C (both). They are display options only, and grep ignores them the moment you ask for a summary instead of lines: with -c, -l, -L, -q or -o no context is printed. When several matches are close together their context blocks are merged and separated by --, so the output stays valid to pipe onwards.

Patterns are always single-quoted here. Unquoted, the shell expands * against your current directory and expands $VAR before grep ever sees it — the classic symptom is a pattern that works in one directory and matches nothing in another. Single quotes stop both; the only character that needs care is a literal apostrophe, which the builder escapes for you.

grep dialects and what changes between them

Mode	Flag	What it means in practice
Basic (BRE)	none (or `-G`)	The historical default. `+ ? \| ( ) { }` are literals; write `\+`, `\?`, `\\|`, `\(` for the operators. No `\d` or `\w` — `\d` matches a letter d.
Extended (ERE)	`-E` / `egrep`	Operators work unescaped: `a\|b`, `colou?r`, `[0-9]{2,4}`. Still no `\d` or lookarounds — GNU treats `\d` as a plain d.
Fixed string	`-F` / `fgrep`	Every character is literal. Plus `-w` or `-x` when you want word or line boundaries. Fastest option for a literal search.
Perl (PCRE)	`-P`	`\d \w \s`, lookahead and lookbehind. GNU grep only — the BSD grep shipped with macOS rejects `-P`, and it is slow on large trees.

The options this builder can emit

Option	What it does	Gotcha
-i	Ignore case in the pattern.	Also folds character classes, so `[a-z]` matches uppercase.
-v	Invert: print lines that do not match.	With `-o` nothing is printed at all.
-w / -x	Match whole words / whole lines.	`-w` still allows a match inside a longer word with punctuation.
-r / -R	Recurse into directories; `-R` also follows symlinks.	Without one of them, a directory argument is an error, not a search.
--include / --exclude	Filter files by name glob.	Ignored without recursion. Matches the basename.
--exclude-dir	Prune whole directories.	Also a large speed win on repositories.
-A / -B / -C	Print N lines after / before / around each hit.	No effect with `-c`, `-l`, `-L`, `-q` or `-o`.
-n	Prefix each line with its line number.	Ignored by `-l` and `-c`, which print no lines.
-o	Print only the matched text, one per line.	Implies you lose the rest of the line; `-c` then still counts lines, not hits.
-c / -l / -L	Count matching lines, list matching files, list non-matching files.	They replace the normal output entirely, so `-n` and context do nothing.
-m N	Stop reading a file after N matching lines.	`-m 0` matches nothing and exits 1.
-I / -a	Skip binary files / treat them as text.	grep’s default is to print “Binary file … matches” and stop.
--color=always	Highlight the matched text.	`always` keeps the colour through a pipe; use `auto` for terminals.

Exit codes, and why grep “fails” in scripts

Status	Meaning
0	At least one line matched.
1	No match at all — this is a normal, successful search that found nothing.
2	A real error: a file was missing, a directory was given without `-r`, or the regex was invalid.

Under set -e, or with && chains, status 1 aborts a script even though nothing broke. Guard it with if grep -q pattern file; then, or append || true. Likewise -q is the right way to test for a match: it stops at the first hit and prints nothing.

Troubleshooting

Symptom	Cause and fix
grep: dir: Is a directory	Add `-r`. grep does not search directories by default.
Binary file … matches	The tree contains an object file or image. Add `-I`, or restrict with `--include`.
Invalid regular expression	Unbalanced `[` or `(`, or a backslash before an ordinary character in BRE. Switch to `-E` and fix the grouping.
grep -P: invalid option …	BSD grep on macOS. Use `ggrep -P` from Homebrew coreutils, or rewrite with `-E`.
Pattern matches nothing that obviously exists	Unquoted pattern expanded by the shell, or `*` taken from your working directory. Quote it.
--include does nothing	Recursion is off. Add `-r`.
Permission denied flood	Searching `/` as a normal user. Narrow the path, or add `-s` to silence the messages (the builder leaves that to you).
Output is huge	Add `-l` for the file list, `-c` for counts, or `-m 1` per file while you are exploring.

Related tools

Spot a bug or want a custom utility built? I'd love to hear from you. Get in touch
Luke Keam | techgeek.biz