|
22.2.8 * versus .*
This section compares file globbing with regular expression
matching. There are many Unix commands which are regularly used from
shell scripts, and which provide some sort of pattern matching
mechanism: expr , egrep and sed , to name a
few. Unfortunately they each have different quoting rules regarding
whether particular meta-characters must be backslash escaped to revert
to their literal meaning and vice-versa. There is no real logic
to the particular dialect of regular expressions accepted by these
commands. To confirm the correctness of each regular expression, you
should always check them from the shell prompt with the relevant tool
before committing to a script, so I won't belabour the specifics.
Shell globbing however is much more regular (no pun intended), and
provides a reasonable and sometimes more cpu efficient solution to many
shell matching problems. The key is to make good use of the
case command, which is easier to use (because it uses globbing
rules) and doesn't require additional processes to be spawned.
Unfortunately, GNU Bash doesn't handle backslashes correctly in
glob character classes -- the backslash must be the first character in
the class, or else it will never match. For example, if you want to
detect absolute directory paths on Unix and Windows using
case , you should write the code like this:
|
case $dir in
[\\/]* | ?:[\\/]* ) echo absolute ;;
* ) echo relative ;;
esac
|
Even though expr uses regular expressions rather than shell
globbing, it is often(52) a shell builtin, so using
it to extract sections of strings can be faster than spawning a sed
process to do the same. As with echo and set , for
example, you must be careful that variable or command expansions for the
first argument to expr are not accidentally interpreted as
reserved keywords. As with echo , you can work around this
problem by prefixing any expansions with a literal `x', as follows:
|
$ foo=substr
$ expr $foo : '.*\(str\)'
expr: syntax error
$ expr x$foo : '.*\(str\)'
str
|
|