Reputation: 21921

grep a tab in UNIX

How do I grep tab (\t) in files on the Unix platform?

Upvotes: 564

Answers (22)

antimirov

Reputation: 5114

In shells like Bash, Zsh and others, you can use shell syntax to pass an actual tab character to grep.

The trick is to use $ sign before single quotes. Since this is a feature of the shell, it also works for cut and other tools.

grep $'\t' sample.txt

(If you're using this syntax in a shell script, you should use a #!/bin/bash shebang to explicitly request the Bash shell, as /bin/sh may not support the syntax.)

Upvotes: 466

Accidental brine

Reputation: 369

You can type

grep \t foo

grep '\t' foo

to search for the tab character in the file foo. You can probably also do other escape codes, though I've only tested \n. Although it's rather time-consuming, and unclear why you would want to, in zsh you can also type the tab character, back to the begin, grep and enclose the tab with quotes.

Upvotes: -4

Fjor

Reputation: 439

Build the regex previously, like this:

regex=$'\t'

and then use it:

grep "$regex" file

Other example, with TAB inside the regex:

regex=$'[A-Z][a-z]+\t[A-Z][a-z]+'
echo -e "John\tSmith" | grep -E "$regex"

When we want to use variables in the regex, build it by concatenating the strings without spaces:

first="[A-Z][a-z]+"
last="[A-Z][a-z]+"
regex="$first"'\t'"$last"
echo -e "John\tSmith" | grep -E "$regex"

[RECOMMENDED] This means we can define a TAB variable and write clear code to ease future debugging:

#-- build REGEX to find name parts
TAB=$'\t'
firstname="[A-Z][a-z]+"
surname="[A-Z][a-z]+"
nameregex="${firstname}${TAB}${surname}"
#-- test for person name
echo -e "John\tSmith" | grep -E "$nameregex"

Tested with Bash versions 3.0, 4.2 and 5.1.

Upvotes: 0

Raman

Reputation: 19675

The $'\t' notation given in other answers is shell-specific -- it seems to work in bash and zsh but is not universal.

NOTE: The following is for the fish shell and does not work in bash:

In the fish shell, one can use an unquoted \t, for example:

grep \t foo.txt

Or one can use the hex or unicode notations e.g.:

grep \X09 foo.txt
grep \U0009 foo.txt

(these notations are useful for more esoteric characters)

Since these values must be unquoted, one can combine quoted and unquoted values by concatenation:

grep "foo"\t"bar"

Upvotes: 2

YullyBear

Reputation: 17

The answer is simpler. Write your grep and within the quote type the tab key, it works well at least in ksh

grep "  " *

Upvotes: 0

Guido Flohr

Reputation: 2350

You can also use a Perl one-liner instead of grep resp. grep -P:

perl -ne 'print if /\t/' FILENAME

Upvotes: 0

Silasvb

Reputation: 332

Using the 'sed-as-grep' method, but replacing the tabs with a visible character of personal preference is my favourite method, as it clearly shows both which files contain the requested info, and also where it is placed within lines:

sed -n 's/\t/\*\*\*\*/g' file_name

If you wish to make use of line/file info, or other grep options, but also want to see the visible replacement for the tab character, you can achieve this by

grep -[options] -P '\t' file_name | sed 's/\t/\*\*\*\*/g'

As an example:

$ echo "A\tB\nfoo\tbar" > test
$ grep -inH -P '\t' test | sed 's/\t/\*\*\*\*/g'
test:1:A****B
test:2:foo****bar

EDIT: Obviously the above is only useful for viewing file contents to locate tabs --- if the objective is to handle tabs as part of a larger scripting session, this doesn't serve any useful purpose.

Upvotes: 0

gruic

Reputation: 1

This works well for AIX. I am searching for lines containing JOINED<\t>ACTIVE

voradmin cluster status | grep  JOINED$'\t'ACTIVE

 vorudb201   1       MEMBER(g) JOINED        ACTIVE
*vorucaf01   2       SECONDARY JOINED        ACTIVE

Upvotes: 0

AIXroot

Reputation: 186

On ksh I used

grep "[^I]" testfile

Upvotes: 1

Zsigmond Lőrinczy

Reputation: 377

+1 way, that works in ksh, dash, etc: use printf to insert TAB:

grep "$(printf 'BEGIN\tEND')" testfile.txt

Upvotes: 2

ghostdog74

Reputation: 342977

use gawk, set the field delimiter to tab (\t) and check for number of fields. If more than 1, then there is/are tabs

awk -F"\t" 'NF>1' file

Upvotes: 2

Julio

Reputation: 115

A good choice is to use sed.

sed -n '/\t/p' file

Examples (works in bash, sh, ksh, csh,..):

[~]$ cat testfile
12 3
1 4 abc
xa      c
        a       c\2
1 23

[~]$ sed -n '/\t/p' testfile 
xa      c
        a       c\2
[~]$ sed -n '/\ta\t/p' testfile
        a       c\2

(This answer has been edited following suggestions in comments. Thank you all)

Upvotes: 6

tjmoore

Reputation: 1084

One way is (this is with Bash)

grep -P '\t'

-P turns on Perl regular expressions so \t will work.

As user unwind says, it may be specific to GNU grep. The alternative is to literally insert a tab in there if the shell, editor or terminal will allow it.

Upvotes: 40

unwind

Reputation: 400079

If using GNU grep, you can use the Perl-style regexp:

grep -P '\t' *

Upvotes: 495

Alois Mahdal

Reputation: 11253

Another way of inserting the tab literally inside the expression is using the lesser-known $'\t' quotation in Bash:

grep $'foo\tbar'        # matches eg. 'foo<tab>bar'

(Note that if you're matching for fixed strings you can use this with -F mode.)

Sometimes using variables can make the notation a bit more readable and manageable:

tab=$'\t'               # `tab=$(printf '\t')` in POSIX
id='[[:digit:]]\+'
name='[[:alpha:]_][[:alnum:]_-]*'
grep "$name$tab$id"     # matches eg. `bob2<tab>323`

Upvotes: 34

Mike Volokhov

Reputation: 119

There are basically two ways to address it:

(Recommended) Use regular expression syntax supported by grep(1). Modern grep(1) supports two forms of POSIX 1003.2 regex syntax: basic (obsolete) REs, and modern REs. Syntax is described in details on re_format(7) and regex(7) man pages which are part of BSD and Linux systems respectively. The GNU grep(1) also supports Perl-compatible REs as provided by the pcre(3) library.

In regex language the tab symbol is usually encoded by \t atom. The atom is supported by BSD extended regular expressions (egrep, grep -E on BSD compatible system), as well as Perl-compatible REs (pcregrep, GNU grep -P).

Both basic regular expressions and Linux extended REs apparently have no support for the \t. Please consult UNIX utility man page to know which regex language it supports (hence the difference between sed(1), awk(1), and pcregrep(1) regular expressions).

Therefore, on Linux:
```
$ grep -P '\t' FILE ...
```
On BSD alike system:
```
$ egrep '\t' FILE ...
$ grep -E '\t' FILE ...
```
Pass the tab character into pattern. This is straightforward when you edit a script file:
```
# no tabs for Python please!
grep -q '   ' *.py && exit 1
```
However, when working in an interactive shell you may need to rely on shell and terminal capabilities to type the proper symbol into the line. On most terminals this can be done through Ctrl+V key combination which instructs terminal to treat the next input character literally (the V is for "verbatim"):
```
$ grep '<Ctrl>+<V><TAB>' FILE ...
```
Some shells may offer advanced support for command typesetting. Such, in bash(1) words of the form $'string' are treated specially:
```
bash$ grep $'\t' FILE ...
```
Please note though, while being nice in a command line this may produce compatibility issues when the script will be moved to another platform. Also, be careful with quotes when using the specials, please consult bash(1) for details.

For Bourne shell (and not only) the same behaviour may be emulated using command substitution augmented by printf(1) to construct proper regex:
```
$ grep "`printf '\t'`" FILE ...
```

Upvotes: 9

kumar303

Reputation: 684

grep "$(printf '\t')" worked for me on Mac OS X

Upvotes: 5

odoncaoa

Reputation: 1

These alternative binary identification methods are totally functional. And, I really like the one's using awk, as I couldn't quite remember the syntaxic use with single binary chars. However, it should also be possible to assign a shell variable a value in a POSIX portable fashion (i.e. TAB=echo "@" | tr "\100" "\011"), and then employ it from there everywhere, in a POSIX portable fashion; as well (i.e grep "$TAB" filename). While this solution works well with TAB, it will also work well other binary chars, when another desired binary value is used in the assignment (instead of the value for the TAB character to 'tr').

Upvotes: 0