The pattern description language is relatively easy. Any character that's not mentioned below matches itself.
The NUL character may not occur in a pattern. If special characters are quoted, they're matched literally, i.e. without their special meaning.

Normal pattern language

Sequence

Description

*

Matches any string, including the null string (empty string)

?

Matches any single character

X

Matches the character X which can be any character that has no special meaning

\X

Matches the character X, where the character's special meaning is stripped by the backslash

\\

Matches a backslash

[…]

Defines a pattern bracket expression (see below). Matches any of the enclosed characters at this position.

Bracket expressions

The bracket expression […] mentioned above has some useful applications:

Bracket expression

Description

[XYZ]

The "normal" bracket expression, matching either X, Y or Z

[X-Z]

A range expression: Matching all the characters from X to Y (your current locale, defines how the characters are sorted!)

Bugs and Portability considerations

* Counter-intuitively, only the [!chars] syntax for negating a character class is specified by POSIX for shell pattern matching. [^chars] is merely a commonly-supported extension. Even dash supports [^chars], but not posh.

* All of the extglob quantifiers supported by bash were supported by ksh88. The set of extglob quantifiers supported by ksh88 are identical to those supported by Bash, mksh, ksh93, and zsh.

* mksh does not support POSIX character classes. Therefore, character ranges like [0-9] are somewhat more portable than an equivalent POSIX class like [:digit:].

* Bash uses a custom runtime interpreter for pattern matching. (at least) ksh93 and zsh translate patterns into regexes and then use a regex compiler to emit and cache optimized pattern matching code. This means Bash may be an order of magnitude or more slower in cases that involve complex back-tracking (usually that means extglob quantifier nesting). You may wish to use Bash's regex support (the =~ operator) if performance is a problem, because Bash will use your C library regex implementation rather than its own pattern matcher.

ksh93 extras

ksh93 supports some very powerful pattern matching features in addition to those described above.

* ksh93 supports arbitrary quantifiers just like ERE using the {from,to}(pattern-list) syntax. {2,4}(foo)bar matches between 2-4 "foo"'s followed by "bar". {2,}(foo)bar matches 2 or more "foo"'s followed by "bar". You can probably figure out the rest. So far, none of the other shells support this syntax.

* In ksh93, a pattern-list may be delimited by either & or |. & means "all patterns must be matched" instead of "any pattern". For example,

[[ fo0bar == @(fo[0-9]&+([[:alnum:]]))bar ]]

would be true while

[[ f00bar == @(fo[0-9]&+([[:alnum:]]))bar ]]

is false, because all members of the and-list must be satisfied. No other shell supports this so far, but you can simulate some cases in other shells using double extglob negation. The aforementioned ksh93 pattern is equivalent in Bash to:

[[ fo0bar == !(!(fo[0-9])|!(+([[:alnum:]])))bar ]]

, which is technically more portable, but ugly.

* ksh93's printf builtin can translate from shell patterns to ERE and back again using the %R and %P format specifiers respectively.

What if we want to match a particular pattern for 'n' number of times??

Jan Schampera, 2010/09/17 06:47

This is not possible with patterns (or extended patterns). Patterns like this are not a substitute for regular expressions (but infact usually patterns can do the most "common" work, sometimes people (ab)use regular expressions for very very easy tasks in shell coding). Maybe Bash will have a new feature like this for extended patterns in future.