Perl-based Regular Expression Pattern

AKA: Perl Regular Expression.
Context:
- It can be used in a Perl-based Regular Expression Replace Statement, such as s/a([bc])d/x$1y/g;.
- …
Example(s):
- …
Counter-Example(s):
- a Perl String Operation.
- a Java Regular Expression, Python Regular Expression.
See: Perl Coding Notes, Regular Expression Statement.

Examples

http://www.cs.tut.fi/~jkorpela/perl/regexp.html

expression	matches...
`abc`	`abc` (that exact character sequence, but anywhere in the string)
`a.c\.`	an `a` followed by any single character (not newline) followed by a `c` followed by a period
`a?b*c+`	zero or one `a`s followed by zero or more `b`s followed by one or more `c`s.
`^abc\|abc$`	the string `abc` at the beginning or at the end of the string
`ab{2,4}c`	an `a` followed by two, three or four `b`’s followed by a `c`
`ab{2,}c`	an `a` followed by at least two `b`’s followed by a `c`
`.{81,}`	a line with at least 80 chars
`[abc]`	any one of `a`, `b` and `c`
`[Aa]bc`	either of `Abc` and `abc`
`[abc]+`	any (nonempty) string of `a`’s, `b`’s and `c’s` (such as `a`, `abba`, `acbabcacaa`)
`[^abc]+`	any (nonempty) string which does not contain any of `a`, `b` and `c` (such as `defg`)
`\d\d`	any two decimal digits, such as `42`; same as \d{2}
`\w+`	a “word”: a nonempty sequence of alphanumeric characters and low lines (underscores), such as `foo` and `12bar8` and `foo_1`
`100\s*mk`	the strings `100` and `mk` optionally separated by any amount of white space (spaces, tabs, newlines)
`abc\b`	`abc` when followed by a word boundary (e.g. in `abc!` but not in `abcd`)
`perl\B`	`perl` when not followed by a word boundary (e.g. in `perlert` but not in `perl stuff`)

http://en.wikipedia.org/wiki/Regular_expression#Perl-derivative_regular_expressions
- Perl has a more consistent and richer syntax than the POSIX basic (BRE) and extended (ERE) regular expression standards. An example of its consistency is that \ always escapes a non-alphanumeric character. Other examples of functionality possible with Perl but not POSIX-compliant regular expressions is the concept of lazy quantification (see the next section), possessive quantifies to control backtracking, named capture groups, and recursive patterns. … many other utilities and programming languages have adopted syntax similar to Perl's — for example, Java, JavaScript, PCRE, Python, Ruby, Microsoft's .NET Framework, and the W3C's XML Schema all use regular expression syntax similar to Perl's.