Regular Expressions

Some people, when confronted with a problem, think “I know, I’ll use regular expressions.” Now they have two problems. --Jamie Zawinski, in comp.lang.emacs

Used to extremes in Perl. Available in many languages. The following is designed as a quick reference / memory jog for experienced RE users. Any new users should... A) find another solution B) copy existing working code C) join a newsgroup or mailing list and ask for help D) take a class. RE is like shaking hands with an octopus.

Matches
^	beginning
$	end
.	any character
[.-.]	any character from the first "." to the second where . is any character
	e.g. [A-Z] matches any uppercase letter

Literals
\.	Quote. Treats "." as a literal value where . is any character
	e.g. \$ matches the dollar sign, not the end of line.
\###	Byte where ### are three octal digits.
\x##	Byte where ## are two hexadecimal digits.


Flow control
(.*)	Group. Matches everything in the parens or nothing. Saves the match in $# were # 
	counts up the groups. 
	e.g. Time: (..):(..):(..) will put the hours in $1, minutes in $2 and seconds in $3.
.*|.*	Or. If the pattern before the "|" fails to match, it will try the pattern after.
	e.g. A|B will match A or B

Repeat
*	0 or more times. Same as {0,}. Will "eat" to the end unless followed by ? or something else
+	1 or more times. Same as {1,}. Will "eat" to the end unless followed by ? or something else
?	0 or 1 times. Same as {0,1}
{n}	Match exactly n times
{n,}	Match at least n times. Will "eat" to the end unless followed ? or something else
{n,m}	Match at least n but not more than m times.
.*?	Match the minimum number of times possible where .* is one of the repeat patterns above.
	e.g. foo(.*)bar used against "the food is barbecued in the barn" will set $1 to "d is barbecued in the "
	 but foo(.*?)bar will set it to "d is ". Notice
	 that foo(.*)barb will also produce "d is "

For a regular expression to match, the entire regular expression must match, not just part of it. So if the beginning of a pattern containing a quantifier succeeds in a way that causes later parts in the pattern to fail, the matching engine backs up and recalculates the beginning part--that's why it's called backtracking.

Also:

• Javascript RegExp Validations
• Microsoft JScript RegExps

See also:

• https://docs.microsoft.com/en-us/dotnet/standard/base-types/backtracking-in-regular-expressions
  In the Regular Expression (?<!\\)[\\](\d) the (?<!\\) is a "Lookbehind Assertion" which does not use up the backslash while matching. Using [^\\] instead causes "\1\2" to fail to match the \2, while "\1 \2" will find \2. (?<!\\) finds both in both cases. +
• http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html Perl Regular Expression for validating an email address as per RFC:822^. It's only 64K long...+
• http://blogs.msdn.com/oldnewthing/archive/2006/05/22/603788.aspx Regexps are NOT a be all and end all. Thanks to "Al" for this link to a good example where a combination of regexp and scripting is used to validate IPv4 dotted IP addresses.+
• http://www.faqs.org/docs/diveintopython/dialect_re.html
• http://ghettographics.org/mpr/hacks/mgrep.c.txt JIT-compile ed-like regular expressions to i386 code.
• http://perl.plover.com/Regex/article.html (cached 20010216093727) and spend some time on it... it made it make a bit more sense for me....

Samples:

IPv4 dotted IP address: Anything from "/^\d+\.\d+\.\d+\.\d+$/" (which allows "448.90210.0.65535") to "/^([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])\.([1-9]?\d|1\d\d|2[0-4]\d|25[0-5])$/" which is impossible for normal humans to understand. +

Interested: