grep – Difference Between [] and \(\) in Basic Regular Expression

grepregular expression

Consider:

$ echo '<H1>heading</H1>' | grep '<H\(1\|3\|2\)>.*</H\1>'
$ <H1>heading</H1>

and

$ echo '<H1>heading</H3>' | grep '<H[1-3]>.*</H\1>'
$ grep: Invalid back reference

first command works just fine.

Doesn't [1-3] and \(1\|3\|2\) both mean 1 or 2 or 3 ? if not why? and what the difference between them?
why back-reference works with only \(\) ?

Best Answer

() means «groupping» which means set a part of the string which can operate as 1 item, and for backrefference too.
[] means symbols set

So if you use parenthesis just for single symbols the meaning is same. But usually it used for multisymbol strings like (cat|dog)

Related Solutions

Grep Options – Difference Between -e and -E

-e is strictly the flag for indicating the pattern you want to match against. -E controls whether you need to escape certain special characters.

man grep explains -E it a bit more:

   Basic vs Extended Regular Expressions
   In basic regular expressions the meta-characters ?, +, {, |, (, and ) lose their special meaning; instead use the backslashed versions \?, \+, \{, \|, \(, and \).

   Traditional  egrep  did  not  support  the  {  meta-character, and some egrep implementations support \{ instead, so portable scripts should avoid { in grep -E patterns and should use [{] to match a
   literal {.

   GNU grep -E attempts to support traditional usage by assuming that { is not special if it would be the start of an invalid interval specification.  For example, the command grep -E '{1' searches for
   the two-character string {1 instead of reporting a syntax error in the regular expression.  POSIX.2 allows this behavior as an extension, but portable scripts should avoid it.

Bash – difference between .* and * in regular Expression

notation (.*)

The * in the regular expressions .* and * is referring to a count, not characters per say, more exactly it means 'zero or more'. Furthermore, the . means 'any single character'.

So when you put them together you get 'zero or more of any characters'. For example strings like these:

linux
linnnnnx
lnx
hi linux
lx

Would be matched by <l.*x>. The last one is important, it shows that the .* can match nothing too.

notation (*)

The use of * alone as I said is a counter. So when you put it after a letter such as 'l' the * is saying 'zero or more of l'.

Notice if we grep for l*x, this will match l...x, but probably not for the reason you'd think.

% echo "l...x" | grep "l*x"
l...x

It's matching on the trailing 'x'. The 'l' has nothing to do with why this is getting matched, other than the fact that the 'x' is preceded by 'zero or more l's'.