Regular expression syntax 
這一部分覆蓋了 ISAPI_Rewrite規(guī)定的表達(dá)句法 
Literals 
所有字符都是原意除了 ".", "*", "?", "+", "(", ")", "{", "}", "[", "]", "^" and "$".，這些字符在用“\”處理時(shí)是原意，原意指一個(gè)字符匹配自身 
Wildcard 
The dot character "." matches any single character except null character and newline character 
以下為句法 
Repeats 
A repeat is an expression that is repeated an arbitrary number of times. An expression followed by "*" can be repeated any number of times including zero. An expression followed by "+" can be repeated any number of times, but at least once. An expression followed by "?" may be repeated zero or one times only. When it is necessary to specify the minimum and maximum number of repeats explicitly, the bounds operator "{}" may be used, thus "a{2}" is the letter "a" repeated exactly twice, "a{2,4}" represents the letter "a" repeated between 2 and 4 times, and "a{2,}" represents the letter "a" repeated at least twice with no upper limit. Note that there must be no white-space inside the {}, and there is no upper limit on the values of the lower and upper bounds. All repeat expressions refer to the shortest possible previous sub-expression: a single character; a character set, or a sub-expression grouped with "()" for example. 

Examples: 

"ba*" will match all of "b", "ba", "baaa" etc.  
"ba+" will match "ba" or "baaaa" for example but not "b".  
"ba?" will match "b" or "ba".  
"ba{2,4}" will match "baa", "baaa" and "baaaa".  
Non-greedy repeats 
Non-greedy repeats are possible by appending a '?' after the repeat; a non-greedy repeat is one which will match the shortest possible string. 

For example to match html tag pairs one could use something like: 

"<\s*tagname[^>]*>(.*?)<\s*/tagname\s*>" 

In this case $1 will contain the text between the tag pairs, and will be the shortest possible matching string.  

Parenthesis 
Parentheses serve two purposes, to group items together into a sub-expression, and to mark what generated the match. For example the expression "(ab)*" would match all of the string "ababab". All sub matches marked by parenthesis can be back referenced using \N or $N syntax. It is permissible for sub-expressions to match null strings. Sub-expressions are indexed from left to right starting from 1, sub-expression 0 is the whole expression. 

Non-Marking Parenthesis 
Sometimes you need to group sub-expressions with parenthesis, but don't want the parenthesis to spit out another marked sub-expression, in this case a non-marking parenthesis (?:expression) can be used. For example the following expression creates no sub-expressions: 

"(?:abc)*"  

Alternatives 
Alternatives occur when the expression can match either one sub-expression or another, each alternative is separated by a "|". Each alternative is the largest possible previous sub-expression; this is the opposite behaviour from repetition operators. 

Examples: 

"a(b|c)" could match "ab" or "ac".  
"abc|def" could match "abc" or "def".  
Sets 
A set is a set of characters that can match any single character that is a member of the set. Sets are delimited by "[" and "]" and can contain literals, character ranges, character classes, collating elements and equivalence classes. Set declarations that start with "^" contain the compliment of the elements that follow. 

Examples: 

Character literals: 

"[abc]" will match either of "a", "b", or "c".  
"[^abc] will match any character other than "a", "b", or "c".  
Character ranges: 

"[a-z]" will match any character in the range "a" to "z".  
"[^A-Z]" will match any character other than those in the range "A" to "Z".  
Character classes 
Character classes are denoted using the syntax "[:classname:]" within a set declaration, for example "[[:space:]]" is the set of all whitespace characters. The available character classes are:  

alnum Any alpha numeric character.  
alpha Any alphabetical character a-z and A-Z. Other characters may also be included depending upon the locale.  
blank Any blank character, either a space or a tab.  
cntrl Any control character.  
digit Any digit 0-9.  
graph Any graphical character.  
lower Any lower case character a-z. Other characters may also be included depending upon the locale.  
print Any printable character.  
punct Any punctuation character.  
space Any whitespace character.  
upper Any upper case character A-Z. Other characters may also be included depending upon the locale.  
xdigit Any hexadecimal digit character, 0-9, a-f and A-F.  
word Any word character - all alphanumeric characters plus the underscore.  
unicode Any character whose code is greater than 255, this applies to the wide character traits classes only.  

There are some shortcuts that can be used in place of the character classes: 

\w in place of [:word:]  
\s in place of [:space:]  
\d in place of [:digit:]  
\l in place of [:lower:]  
\u in place of [:upper:]  
Collating elements 
Collating elements take the general form [.tagname.] inside a set declaration, where tagname is either a single character, or a name of a collating element, for example [[.a.]] is equivalent to [a], and [[.comma.]] is equivalent to [,]. ISAPI_Rewrite supports all the standard POSIX collating element names, and in addition the following digraphs: "ae", "ch", "ll", "ss", "nj", "dz", "lj", each in lower, upper and title case variations. Multi-character collating elements can result in the set matching more than one character, for example [[.ae.]] would match two characters, but note that [^[.ae.]] would only match one character.  

Equivalence classes 
Equivalenceclassestakethegeneralform[=tagname=] inside a set declaration, where tagname is either a single character, or a name of a collating element, and matches any character that is a member of the same primary equivalence class as the collating element [.tagname.]. An equivalence class is a set of characters that collate the same, a primary equivalence class is a set of characters whose primary sort key are all the same (for example strings are typically collated by character, then by accent, and then by case; the primary sort key then relates to the character, the secondary to the accentation, and the tertiary to the case). If there is no equivalence class corresponding to tagname, then [=tagname=] is exactly the same as [.tagname.]. 

To include a literal "-" in a set declaration then: make it the first character after the opening "[" or "[^", the endpoint of a range, a collating element, or precede it with an escape character as in "[\-]". To include a literal "[" or "]" or "^" in a set then make them the endpoint of a range, a collating element, or precede with an escape character.  

Line anchors 
An anchor is something that matches the null string at the start or end of a line: "^" matches the null string at the start of a line, "$" matches the null string at the end of a line.  

Back references 
A back reference is a reference to a previous sub-expression that has already been matched, the reference is to what the sub-expression matched, not to the expression itself. A back reference consists of the escape character "\" followed by a digit "1" to "9", "\1" refers to the first sub-expression, "\2" to the second etc. For example the expression "(.*)\1" matches any string that is repeated about its mid-point for example "abcabc" or "xyzxyz". A back reference to a sub-expression that did not participate in any match, matches the null string. In ISAPI_Rewrite all back references are global for entire RewriteRule and corresponding RewriteCond directives. Sub matches are numbered up to down and left to right beginning from the first RewriteCond directive of the corresponding RewriteRule directive, if there is one. 

Forward Lookahead Asserts 
There are two forms of these; one for positive forward lookahead asserts, and one for negative lookahead asserts:  

"(?=abc)" matches zero characters only if they are followed by the expression "abc".  
"(?!abc)" matches zero characters only if they are not followed by the expression "abc".  

Word operators 
The following operators are provided for compatibility with the GNU regular expression library. 

"\w" matches any single character that is a member of the "word" character class, this is identical to the expression "[[:word:]]".  
"\W" matches any single character that is not a member of the "word" character class, this is identical to the expression "[^[:word:]]".  
"\<" matches the null string at the start of a word.  
"\>" matches the null string at the end of the word.  
"\b" matches the null string at either the start or the end of a word.  
"\B" matches a null string within a word.  
Escape operator 
The escape character "\" has several meanings. 

The escape operator may introduce an operator for example: back references, or a word operator.  
The escape operator may make the following character normal, for example "\*" represents a literal "*" rather than the repeat operator.  
Single character escape sequences: 
The following escape sequences are aliases for single characters: 

 
Escape sequence Character code Meaning  
\a 0x07 Bell character.  
\t 0x09 Tab character.  
\v 0x0B Vertical tab.  
\e 0x1B ASCII Escape character.  
\0dd 0dd An octal character code, where dd is one or more octal digits.  
\xXX 0xXX A hexadecimal character code, where XX is one or more hexadecimal digits.  
\x{XX} 0xXX A hexadecimal character code, where XX is one or more hexadecimal digits, optionally a unicode character.  
\cZ z-@ An ASCII escape sequence control-Z, where Z is any ASCII character greater than or equal to the character code for '@'.  

Miscellaneous escape sequences: 
The following are provided mostly for perl compatibility, but note that there are some differences in the meanings of \l \L \u and \U:  

Escape sequence Meaning  
\w Equivalent to [[:word:]].  
\W Equivalent to [^[:word:]].  
\s Equivalent to [[:space:]].  
\S Equivalent to [^[:space:]].  
\d Equivalent to [[:digit:]].  
\D Equivalent to [^[:digit:]].  
\l Equivalent to [[:lower:]].  
\L Equivalent to [^[:lower:]].  
\u Equivalent to [[:upper:]].  
\U Equivalent to [^[:upper:]].  
\C Any single character, equivalent to '.'.  
\X Match any Unicode combining character sequence, for example "a\x 0301" (a letter a with an acute).  
\Q The begin quote operator, everything that follows is treated as a literal character until a \E end quote operator is found.  
\E The end quote operator, terminates a sequence begun with \Q.  
What gets matched? 
The regular expression will match the first possible matching string, if more than one string starting at a given location can match then it matches the longest possible string. In cases where their are multiple possible matches all starting at the same location, and all of the same length, then the match chosen is the one with the longest first sub-expression, if that is the same for two or more matches, then the second sub-expression will be examined and so on. Note that ISAPI_Rewrite uses MATCH algorithm. The result is matched only if the expression matches the whole input sequence. For example:  

RewriteCond URL ^/somedir/.* #will match any request to somedir directory and subdirectories, while  
RewriteCond URL ^/somedir/ #will match only request to the root of the somedir.  
Special note about "pathological" regular expressions 
ISAPI_Rewrite uses a very powerful regular expressions engine Regex++ written by Dr. John Maddock. But as any real thing it's not ideal: There exists some "pathological" expressions which may require exponential time for matching; these all involve nested repetition operators, for example attempting to match the expression "(a*a)*b" against N letter a's requires time proportional to 2N. These expressions can (almost) always be rewritten in such a way as to avoid the problem, for example "(a*a)*b" could be rewritten as "a*b" which requires only time linearly proportional to N to solve. In the general case, non-nested repeat expressions require time proportional to N2, however if the clauses are mutually exclusive then they can be matched in linear time - this is the case with "a*b", for each character the matcher will either match an "a" or a "b" or fail, where as with "a*a" the matcher can't tell which branch to take (the first "a" or the second) and so has to try both. 

Boost 1.29.0 Regex++ could detect "pathological" regular expressions and terminate theirs matching. When a rule fails ISAPI_Rewrite sends "500 Internal Server error - Rule Failed" status to a client to indicate configuration error. Also the failed rule is disabled to prevent performance losses 
Format string syntax 
In format strings, all characters are treated as literals except: "(", ")", "$", "\", "?", ":". 

To use any of these as literals you must prefix them with the escape character \ 

The following special sequences are recognized:  

Grouping: 
Use the parenthesis characters ( and ) to group sub-expressions within the format string, use \( and \) to represent literal '(' and ')'.  

Sub-expression expansions: 
The following perl like expressions expand to a particular matched sub-expression: 

$` Expands to all the text from the end of the previous match to the start of the current match, if there was no previous match in the current operation, then everything from the start of the input string to the start of the match.  
$' Expands to all the text from the end of the match to the end of the input string.  
$& Expands to all of the current match.  
$0 Expands to all of the current match.  
$N Expands to the text that matched sub-expression N.  

Conditional expressions: 
Conditional expressions allow two different format strings to be selected dependent upon whether a sub-expression participated in the match or not: 

?Ntrue_expression:false_expression 

Executes true_expression if sub-expression N participated in the match, otherwise executes false_expression. 

Example: suppose we search for "(while)|(for)" then the format string "?1WHILE:FOR" would output what matched, but in upper case. 

Escape sequences: 
The following escape sequences are also allowed: 

 
\a The bell character.  
\f The form feed character.  
\n The newline character.  
\r The carriage return character.  
\t The tab character.  
\v A vertical tab character.  
\x A hexadecimal character - for example \x0D.  
\x{} A possible unicode hexadecimal character - for example \x{1A0}  
\cx The ASCII escape character x, for example \c@ is equivalent to escape-@.  
\e The ASCII escape character.  
\dd An octal character constant, for example \10  
Examples例子 
Emulating host-header-based virtual sites on a single site 
例如你在兩個(gè)域名注冊(cè)www.site1.com 和 www.site2.com，現(xiàn)在你可以創(chuàng)建兩個(gè)不同的站點(diǎn)而使用單一的物理站點(diǎn)。把以下規(guī)則加入到你的httpd.ini 文件 
[ISAPI_Rewrite] 

#Fix missing slash char on folders 
RewriteCond Host: (.*) 
RewriteRule ([^.?]+[^.?/]) http\://$1$2/ [I,R] 

#Emulate site1 
RewriteCond Host: (?:www\.)?site1\.com 
RewriteRule (.*) /site1$1 [I,L] 

#Emulate site2 
RewriteCond Host: (?:www\.)?site2\.com 
RewriteRule (.*) /site2$1 [I,L] 

 
現(xiàn)在你可以把你的站點(diǎn)放在/site1 和 /site2 目錄中. 

或者你可以應(yīng)用更多的類規(guī)則： 
[ISAPI_Rewrite] 

#Fix missing slash char on folders 
RewriteCond Host: (.*) 
RewriteRule ([^.?]+[^.?/]) http\://$1$2/ [I,R] 

RewriteCond Host: (www\.)?(.+) 
RewriteRule (.*) /$2$3 
為站點(diǎn)應(yīng)該命名目錄為 /somesite1.com, /somesite2.info, etc. 
Using loops (Next flag) to convert request parameters 
假如你希望有物理URL如 http://www.myhost.com/foo.asp?a=A&b=B&c=C 使用請(qǐng)求如 http://www.myhost.com/foo.asp/a/A/b/B/c/C 參數(shù)數(shù)量可以從兩個(gè)請(qǐng)求之間變化 

至少有兩個(gè)解決辦法。你可以簡(jiǎn)單的為每一可能的參數(shù)數(shù)量添加一個(gè)分隔規(guī)則或者你可以使用一個(gè)技術(shù)說(shuō)明如下面的例子 
ISAPI_Rewrite] 
RewriteRule (.*?\.asp)(\?[^/]*)?/([^/]*)/([^/]*)(.*) $1(?2$2&:\?)$3=$4$5 [NS,I] 
這個(gè)規(guī)則將從請(qǐng)求的URL中抽取一個(gè)參數(shù)追加在請(qǐng)求字符的末尾并且從頭重啟規(guī)則進(jìn)程。所以它將循環(huán)直到所有參數(shù)被移動(dòng)到適當(dāng)?shù)奈恢?，或者直到超過(guò)RepeatLimit 
也存在許多這個(gè)規(guī)則的變種。但使用不同的分隔字符，例如。使用URLS如http://www.myhost.com/foo.asp~a~A~b~B~c~C 可以應(yīng)中下面的規(guī)則： 
ISAPI_Rewrite] 
RewriteRule (.*?\.asp)(\?[^~]*)?~([^~]*)~([^~]*)(.*) $1(?2$2&:\?)$3=$4$5 [NS,I] 
Running servers behind IIS 
假如我們有一個(gè)內(nèi)網(wǎng)服務(wù)器運(yùn)行IIS而幾個(gè)公司服務(wù)器運(yùn)行其他平臺(tái)，這些服務(wù)器不能從INTERNET直接進(jìn)入，而只能從我們公司的網(wǎng)絡(luò)進(jìn)入，有一個(gè)簡(jiǎn)單的例子可以使用代理標(biāo)記映射其他服務(wù)器到IIS命名空間： 
[ISAPI_Rewrite] 
RewriteProxy /mappoint(.+) http\://sitedomain$1 [I,U] 
Moving sites from UNIX to IIS 
這個(gè)規(guī)則可以幫助你把URL從 /~username 改變到 /username 和從 /file.html 改變到 /file.htm. 這個(gè)在你僅僅把你的站從UNIX移動(dòng)到IIS并且保持搜索引擎和其他外部頁(yè)面對(duì)老頁(yè)面的連接時(shí)是有用的 
[ISAPI_Rewrite] 

#redirecting to update old links 
RewriteRule (.*)\.html $1.htm 
RewriteRule /~(.*) http\://myserver/$1 [R] 
Moving site location 
許多網(wǎng)管問這樣的問題：他們要重定向所有的請(qǐng)求到一個(gè)新的網(wǎng)絡(luò)服務(wù)器，當(dāng)你需要建立一個(gè)更新的站點(diǎn)取代老的的時(shí)候經(jīng)常出現(xiàn)這樣的問題，解決方案是用ISAPI_Rewrite 于老服務(wù)器中 
[ISAPI_Rewrite] 

#redirecting to update old links 
RewriteRule (.+) http\://newwebserver$1 [R] 

Browser-dependent content 
Dynamically generated robots.txt 
robots.txt是一個(gè)搜索引擎用來(lái)發(fā)現(xiàn)能不能被索引的文件，但是為一個(gè)大站創(chuàng)建一個(gè)有許多動(dòng)態(tài)內(nèi)容的這個(gè)文件是很復(fù)雜的工作，我們可以寫一個(gè)robots.asp script 

現(xiàn)在使用單一規(guī)則生成 robots.txt  
[ISAPI_Rewrite] 

RewriteRule /robots\.txt /robots.asp 
Making search engines to index dynamic pages 
站點(diǎn)的內(nèi)容存儲(chǔ)在XML文件中，在服務(wù)器上有一個(gè)/XMLProcess.asp 文件處理XML文件并返回HTML到最終用戶，URLS到文檔有如下形式 
http://www.mysite.com/XMLProcess.asp?xml=/somdir/somedoc.xml 
但是許多公共引擎不能索引此類文檔，因?yàn)閁RLS包含問號(hào)（文檔動(dòng)態(tài)生成）， 
ISAPI_Rewrite可以完全消除這個(gè)問題 
[ISAPI_Rewrite] 

RewriteRule /doc(.*)\.htm /XMLProcess.asp\?xml=$1.xml 
現(xiàn)在使用如同http://www.mysite.com/doc/somedir/somedoc.htm的URL進(jìn)入文檔，搜索引擎將不知道不是somedoc.htm 文件并且內(nèi)容是動(dòng)態(tài)生成的 
Negative expressions (NOT 
有時(shí)當(dāng)模式不匹配你需要應(yīng)用規(guī)則，這種情況下你可以使用在規(guī)則表達(dá)式中稱為Forward Lookahead Asserts  
例如你需要不使用IE把所有用戶移動(dòng)到別的地點(diǎn) 
[ISAPI_Rewrite] 
# Redirect all non Internet Explorer users 
# to another location 
RewriteCond User-Agent: (?!.*MSIE).* 
RewriteRule (.*) /nonie$1 
Dynamic authentification 
例如我們?cè)谡军c(diǎn)上有一些成員域，我們?cè)谶@個(gè)域上需要密碼保護(hù)文件而我們不喜歡用BUILT-IN服務(wù)器安全，這個(gè)情況下可以建立一個(gè)ASP腳本（稱為proxy.asp），這個(gè)腳本將代理所有請(qǐng)求到成員域并且檢查請(qǐng)求允許，這里有一個(gè)簡(jiǎn)單的模板你可以放進(jìn)你自己的授權(quán)代碼 

 
現(xiàn)在我們要通過(guò)配置 ISAPI_Rewrite 通過(guò)這個(gè)頁(yè)面代理請(qǐng)求: 

[ISAPI_Rewrite] 
# Proxy all requests through proxy.asp 
RewriteRule /members(.+) /proxy.asp\?http\://mysite.com/members$1 
Blocking inline-images (stop hot linking 

假設(shè)我們?cè)趆ttp://www.mysite.com/下有些頁(yè)面有一些內(nèi)聯(lián) GIF圖片很好，他人可以不直接協(xié)商通過(guò)盜鏈到他們的頁(yè)面上，我們不喜歡這樣因?yàn)榧哟罅朔?wù)器流量 
當(dāng)我們不能100%保護(hù)圖片，我們至少可以在瀏覽器發(fā)送一個(gè)HTTP Referer header的地方限制這種情況 
[ISAPI_Rewrite] 
RewriteCond Host: (.+) 
RewriteCond Referer: (?!http://\1.*).* 
RewriteRule .*\.(?:gif|jpg|png) /block.gif [I,O]