regex using \\ vs using \

The output is the same only for your string, but in general those regular expressions do different things. Let's modify your example a little by adding second pattern e,g, (with comas), third e\.g\. (dots), fourth e\,g\, (comas), and -o option to grep to print only matched parts.

• In the following case . match any char (notice '' around e.g., I will come to that later)

  $ grep -o 'e.g.' <<< grep -o 'e.g.' <<< 'this is an e.g. e,g, e\.g\. e\,g\,'
  e.g.
  e,g,
  

• Next we escape . with backslash \, so only literal . will be matched:

  $ grep -o 'e\.g\.' <<< 'this is an e.g. e,g, e\.g\. e\,g\,'
  e.g.
  

• But we can escape \ with another \, so that literal \ will be matched followed by . (i.e. any char):

  $ grep -o 'e\\.g\\.' <<< 'this is an e.g. e,g, e\.g\. e\,g\,'
  e\.g\.
  e\,g\,
  

• But if we want to match only \. not \, then yet another \ is needed to escape special meaning of the dot:

  $ grep -o 'e\\\.g\\\.' <<< 'this is an e.g. e,g, e\.g\. e\,g\,'
  e\.g\.
  

Now, because you didn't use '' around grep argument you need to add another backslashes to escape backslashes from shell interpretation, so:

grep 'e\.g\.'     => grep e\\.g\\.
grep 'e\\.g\\.'   => grep e\\\\.g\\\\.  (each backslash has to be quoted separately)
grep 'e\\\.g\\\.' => grep e\\\\\\.g\\\\\\. (3 x 2 = 6 backslashes in total)

When you do a grep e\.g\., the shell is consuming the backslash, thus you are doing a grep e.g., which matches. When you do a grep e\\.g\\., the shell is again consuming a slash, and now you are doing a grep e\.\g., which again matches. Now, a backslash to the shell looks like \\. So, when you have \\, the first one is an escape sequence, the second is a literal backslash. When you do a grep e\\\.g\\\., it still ends up being grep e\.\g., because there is not an escape sequence (\) before the first \ to make it a literal \. Keep in mind \ is a backslash, thus grep e\\\\.\\\\g ends up being grep e\\.g\\., which obviously does not match.

To see how the shell is seeing what you're doing, use echo (e.g., echo grep e\\.g\\. <<< "this is an e.g. wow" vs. echo grep e\\\\.g\\\\. <<< "this is an e.g. wow")

First, note the that single slash matches too much:

$ echo $'eegg \n e.g.' | grep e\.g\.
eegg 
 e.g.

As far as bash is concerned, an escaped period is the same as a period. bash passes on the period to grep. For grep, a period matches anything.

Now, consider:

$ echo $'eegg \n e.g.' | grep e\\.g\\.
 e.g.
$ echo $'eegg \n e.g.' | grep e\\\.g\\\.
 e.g.
$ echo $'eegg \n e.g.' | grep e\\\\.g\\\\.
$

When bash sees a double-slash, is reduces it to a single slash and passes that onto grep which, in the first of the three tests above, sees, as we want, a single slash before a period. Thus, this does the right thing.

With a triple slash, bash reduces the first two to a single slash. It then sees \.. Since an escaped period has no special meaning to bash, this is reduced to a plain period. The result is that grep sees, as we want, a slash before a period.

With four slashes, bash reduces each pair to a single slash. bash passes on to grep two slashes and a period. grep sees the two slashes and a period and reduces the two slashes to a single literal slash. Unless the input has a literal slash followed by any character, there are no matches.

To illustrate that last, remember that inside single-quotes, all characters are literal. Thus, given the following three input lines, the grep command matches only on the line with the literal slash in the input:

$ echo 'eegg
e.g.
e\.g\.' |  grep e\\\\.g\\\\.
e\.g\.

Summary of bash behavior

For bash, the rules are

• Two slashes are reduced to a single slash.

• A slash in front of a normal character, like a period, is just the normal character (period).

Thus:

$ echo \. \\. \\\. \\\\.
. \. \. \\.

There is a simple way to avoid all this confusion: on the bash command line, regular expressions should be placed in single-quotes. Inside single quotes, bash leaves everything alone.

$ echo '\. \\. \\\. \\\\.'  # Note single-quotes
\. \\. \\\. \\\\.