2.1.6 File and Directory Selection

-a

--text

Process a binary file as if it were text;
this is equivalent to the ‘--binary-files=text’ option.

--binary-files=type

If a file’s data or metadata
indicate that the file contains binary data,
assume that the file is of type type.
Non-text bytes indicate binary data; these are either output bytes that are
improperly encoded for the current locale (see Environment Variables), or null input bytes when the
-z (--null-data) option is not given (see Other Options).

By default, type is ‘binary’, and grep
suppresses output afer null input binary data is discovered,
and suppresses output lines that contain improperly encoded data.
When some output is suppressed, grep follows any output
with a one-line message saying that a binary file matches.

If type is ‘without-match’,
when grep discovers null input binary data
it assumes that the rest of the file does not match;
this is equivalent to the -I option.

If type is ‘text’,
grep processes binary data as if it were text;
this is equivalent to the -a option.

When type is ‘binary’, grep may treat non-text
bytes as line terminators even without the -z
(--null-data) option. This means choosing ‘binary’
versus ‘text’ can affect whether a pattern matches a file. For
example, when type is ‘binary’ the pattern ‘q$’ might
match ‘q’ immediately followed by a null byte, even though this
is not matched when type is ‘text’. Conversely, when
type is ‘binary’ the pattern ‘.’ (period) might not
match a null byte.

Warning: The -a (--binary-files=text) option
might output binary garbage, which can have nasty side effects if the
output is a terminal and if the terminal driver interprets some of it
as commands. On the other hand, when reading files whose text
encodings are unknown, it can be helpful to use -a or to set
‘LC_ALL='C'’ in the environment, in order to find more matches
even if the matches are unsafe for direct display.

-D action

--devices=action

If an input file is a device, FIFO, or socket, use action to process it.
If action is ‘read’,
all devices are read just as if they were ordinary files.
If action is ‘skip’,
devices, FIFOs, and sockets are silently skipped.
By default, devices are read if they are on the command line or if the
-R (--dereference-recursive) option is used, and are
skipped if they are encountered recursively and the -r
(--recursive) option is used.
This option has no effect on a file that is read via standard input.

-d action

--directories=action

If an input file is a directory, use action to process it.
By default, action is ‘read’,
which means that directories are read just as if they were ordinary files
(some operating systems and file systems disallow this,
and will cause grep
to print error messages for every directory or silently skip them).
If action is ‘skip’, directories are silently skipped.
If action is ‘recurse’,
grep reads all files under each directory, recursively,
following command-line symbolic links and skipping other symlinks;
this is equivalent to the -r option.

--exclude=glob

Skip any command-line file with a name suffix that matches the pattern
glob, using wildcard matching; a name suffix is either the whole
name, or any suffix starting after a ‘/’ and before a
non-‘/’. When searching recursively, skip any subfile whose base
name matches glob; the base name is the part after the last
‘/’. A pattern can use
‘*’, ‘?’, and ‘[’...‘]’ as wildcards,
and \ to quote a wildcard or backslash character literally.

--exclude-from=file

Skip files whose name matches any of the patterns
read from file (using wildcard matching as described
under --exclude).

--exclude-dir=glob

Skip any command-line directory with a name suffix that matches the
pattern glob. When searching recursively, skip any subdirectory
whose base name matches glob. Ignore any redundant trailing
slashes in glob.

-I

Process a binary file as if it did not contain matching data;
this is equivalent to the ‘--binary-files=without-match’ option.

--include=glob

Search only files whose name matches glob,
using wildcard matching as described under --exclude.

-r

--recursive

For each directory operand,
read and process all files in that directory, recursively.
Follow symbolic links on the command line, but skip symlinks
that are encountered recursively.
Note that if no file operand is given, grep searches the working directory.
This is the same as the ‘--directories=recurse’ option.

-R

--dereference-recursive

For each directory operand, read and process all files in that
directory, recursively, following all symbolic links.