使用带有或不带有引号的grep regex模式之间的区别？

Question

I'm learning from Linux Academy and the tutorial shows how to use grep and regex.

He is putting his regex pattern in between quotes something like this:

grep 'pattern' file.txt

This seems to be the same than doing it without quotes:

grep pattern file.txt 

But when he does something like this, he needs to escape the { and }:

grep '^A\{1,4\}' file.txt 

And after doing some testing these scape characters don't seem to be needed when writing the pattern without the quotes.

grep ^A{1,4} file.txt

So what is the difference between these two methods? Are the quotations necessary? Why in the first case the escape characters are needed?

Lastly, I've also seen other methods like grep -E and egrep, which is the most common method that people use to grep with regex?

Edit: Thanks for the reminder that the pattern goes before the file.

Many thanks!

Answer 1

You can sometimes get away with omitting quotes, but it's safest not to. This is because the syntax of regular expressions overlaps that of filename wildcard patterns, and when the shell sees something that looks like a wildcard pattern (and it isn't in quotes), the shell will try to "expand" it into a list of matching filenames. If there are no matching files, it gets passed through unchanged, but if there are matches it gets replaced with the matching filenames.

Here's a simple example. Suppose we're trying to search file.txt for an "a" followed optionally by some "b"s, and print only the matches. So you run:

grep -o ab* file.txt

Now, " ab* could be interpreted as a wildcard pattern looking for files that start with "ab", and the shell will interpret it that way. If there are no files in the current directory that start with "ab", this won't cause a problem. But suppose there are two, "abcd.txt" and "abcdef.jpg". Then the shell expands this to the equivalent of:

grep -o abcd.txt abcdef.jpg file.txt

...and then grep will search the files abcdef.jpg and file.txt for the regex pattern abcd.txt .

So, basically, using an unquoted regex pattern might work, but is not safe . So don't do it.

BTW, I'd also recommend using single-quotes instead of double-quotes, because there are some regex characters that're treated specially by the shell even when they're in double-quotes (mostly dollar sign and backslash/escape). Again, they'll often get passed through unchanged, but not always, and unless you understand the (somewhat messy) parsing rules, you might get unexpected results.

BTW^2, for similar reasons you should (almost) always put double-quotes around variable references (eg grep -O 'ab* "$filename" instead of grep -O 'ab*' $filename ). Single-quotes don't allow variable references at all; unquoted variable references are subject to word splitting and wildcard expansion, both of which can cause trouble. Double-quoted variables get expanded and nothing else .

BTW^3, there are a bunch of variants of regular expression syntax. The reason the curly braces in your example expression need to be escaped is that, by default, grep uses POSIX "basic" regular expression syntax ("BRE") . In BRE syntax, some regex special characters (including curly brackets and parentheses) must be escaped to have their special meaning (and some others, like alternation with | , are just not available at all). grep -E , on the other hand, uses "extended" regular expression syntax ("ERE"), in which those characters have their special meanings unless they're escaped.

And then there's the Perl-compatible syntax (PCRE), and many other variants. Using the wrong variant of the syntax is a common cause of trouble with regular expressions (eg using perl extensions in an ERE context, as here and here ). It's important to know which variant the tool you're using understands, and write your regex to that syntax.

Here's a simple example: "a", followed by 1 to 3 space-like characters, followed by "b", in various regex syntax variants:

a[[:space:]]\{1,3\}b    # BRE syntax
a[[:space:]]{1,3}b      # ERE syntax
a\s{1,3}b               # PCRE syntax

Just to make things more complicated, some tools will nominally accept one syntax, but also allow some extensions from other syntax variants. In the example above, you can see that perl added the shorthand \\s for a space-like character, which is not part of either POSIX standard syntax. But in fact many tools that nominally use BRE or ERE will actually accept the \\s shorthand.

Answer 2

Actually, there are two completely unrelated aspects of escaping in your question. The first has to do how to represent strings in bash. This is about readability, which usually means personal taste. For example, I don't like escaping, hence I prefer writing ab\\ cd as 'ab cd' . Hence, I would write

echo 'ab cd'
grep -F 'ab cd' myfile.txt

instead of

echo ab\ cd
grep -F ab\ cd myfile.txt

but there is nothing wrong with either one, and you can choose whichever looks simpler to you.

The other aspect indeed is related to grep , at least as long as you do not use the -F option in grep , which always interprets the search argument literally. In this case, the shell is not involved, and the question is whether a certain character is interpreted as a regexp character or as a literal. Gordon Davisson has already explained this in detail, so I give only an example which combines both aspects:

Say you want to grep for a space, followed by one or more periods, followed by another space. You can't write this as

grep -E  .+  myfile.txt

because the spaces would be eaten by bash and the . would have special meaning to grep . Hence, you have to choose some escape mechanism. My personal style would be

grep -E ' [.]+ ' myfile.txt

but many people dislike the [.] and prefer \\. instead. This would then become

grep -E ' \.+ ' myfile.txt

This still uses quotes to salvage the spaces from the shell, but escapes the period for grep. If you prefer to use no quotes at all, you can write

grep -E \ \\.+\  myfile.txt

Note that you need to prefix the \\ which is intended for grep by another \\ , because the backslash has, like a space, a special meaning for the shell, and if you would not write \\\\. , grep would not see a backslash-period, but just a period.