Can someone explain what the following expressions mean with grep
? How is that different from egrep
?
With grep
:
^[0-9]\+$
[0-9]\{3\}.*[0-9]\{3\}
^.*[0-9]$
With egrep
:
^[0-9]{7}$
^.*$
Unix & Linux Stack Exchange is a question and answer site for users of Linux, FreeBSD and other Un*x-like operating systems. It only takes a minute to sign up.
Sign up to join this communityegrep
started up as a new grep
implementation in Unix V7 in the late 70s with a new regexp engine and syntax (awk
, also released V7 used that same new extended regexp (ERE) syntax instead of the one used by grep
/ed
/sed
). Since then, POSIX has merged the feature of the egrep
command into grep
with the -E
option and deprecated egrep
.
Nowadays, on some systems, egrep
is just a sh
-script which just does something like exec grep -E "$@"
and is just there for backward compatibility, to accommodate scripts that haven't been updated to use grep -E
instead.
$ cat /usr/bin/egrep
#!/bin/sh
exec grep -E "$@"
so, there egrep
is just grep -E
with no any differences at all.
The ^
is used for start-of-line anchor and accordingly $
is used for end-of-line anchor.
This [0-9]
matches collating elements in the 0 to 9 range in your locale. That used to only include 0123456789, but depending on the system and locale may include many more.
This {min,Max}
is known interval expression.
This .*
matches any sequence of 0 or more characters.
EREs (as in egrep
/ awk
) introduced a few new operators: +
, ?
and |
and removed back-reference support.
The grouping operators which where \(...\)
in BREs (basic regexps as used in grep
) are (...)
instead in EREs.
Regexps didn't initially have interval operators. They were first added as \{x,y\}
in BREs, but not in EREs as doing so would have broken backward compatibility. That was changed by POSIX which did specify {x,y}
for EREs in the 90s. To this day, there are still egrep
or awk
implementations that still don't support it though.
The GNU implementation of grep
(and other utilities using BREs) has gone further and added the +
, ?
, |
ERE operators to BREs as \+
, \?
, \|
and does support back-references with EREs (grep -E
) as non-standard extensions for consistency, so in those implementations, BREs and EREs are functionally equivalent, only the syntax is different.
see also Why does my regular expression work in X but not in Y?.
And here in https://www.regular-expressions.info/posix.html#bre also I found very good information about ERE/BRE and some more;
I found this regex comparison also from here https://www.regular-expressions.info/refrepeat.html very useful and combined 4 of them as following:
Feature | Syntax | Description | Example | GNU BRE | GNU ERE | POSIX BRE | POSIX ERE |
---|---|---|---|---|---|---|---|
Greedy quantifier | ? (question mark) | Makes the preceding item optional. Greedy, so the optional item is included in the match if possible. | abc? matches abc or ab | no | YES | no | YES |
Greedy quantifier | ? | Makes the preceding item optional. Greedy, so the optional item is included in the match if possible. | abc? matches abc or ab | YES | no | no | no |
Greedy quantifier | * (star) | Repeats the previous item zero or more times. Greedy, so as many items as possible will be matched before trying permutations with less matches of the preceding item, up to the point where the preceding item is not matched at all. | ".*" matches "def" "ghi" in abc "def" "ghi" jkl | YES | YES | YES | YES |
Greedy quantifier | + (plus) | Repeats the previous item once or more. Greedy, so as many items as possible will be matched before trying permutations with less matches of the preceding item, up to the point where the preceding item is matched only once. | ".+" matches "def" "ghi" in abc "def" "ghi" jkl | no | YES | no | YES |
Greedy quantifier | + | Repeats the previous item once or more. Greedy, so as many items as possible will be matched before trying permutations with less matches of the preceding item, up to the point where the preceding item is matched only once. | ".+" matches "def" "ghi" in abc "def" "ghi" jkl | YES | no | no | no |
Fixed quantifier | {n} where n is an integer >= 1 | Repeats the previous item exactly n times. | a{3} matches aaa | no | YES | no | YES |
Greedy quantifier | {n,m} where n >= 0 and m >= n | Repeats the previous item between n and m times. Greedy, so repeating m times is tried before reducing the repetition to n times. | a{2,4} matches aaaa, aaa or aa | no | YES | no | YES |
Greedy quantifier | {n,} where n >= 0 | Repeats the previous item at least n times. Greedy, so as many items as possible will be matched before trying permutations with fewer matches of the preceding item, up to the point where the preceding item is matched only n times. | a{2,} matches aaaaa in aaaaa | no | YES | no | YES |
Greedy quantifier | {,m} where m >= 1 | Repeats the previous item between zero and m times. Greedy, so repeating m times is tried before reducing the repetition to zero times. | a{,4} matches aaaa, aaa, aa, a, or the empty string | no | YES | no | no |
Fixed quantifier | {n} where n is an integer >= 1 | Repeats the previous item exactly n times. | a{3} matches aaa | YES | no | YES | no |
Greedy quantifier | {n,m} where n >= 0 and m >= n | Repeats the previous item between n and m times. Greedy, so repeating m times is tried before reducing the repetition to n times. | a{2,4} matches aaaa, aaa or aa | YES | no | YES | no |
Greedy quantifier | {n,} where n >= 0 | Repeats the previous item at least n times. Greedy, so as many items as possible will be matched before trying permutations with fewer matches of the preceding item, up to the point where the preceding item is matched only n times. | a{2,} matches aaaaa in aaaaa | YES | no | YES | no |
Greedy quantifier | {,m} where m >= 1 | Repeats the previous item between zero and m times. Greedy, so repeating m times is tried before reducing the repetition to zero times. | a{,4} matches aaaa, aaa, aa, a, or the empty string | YES | no | no | no |