字符 含意
\

作爲轉意,即一般在"\"後面的字符不按原來意義解釋,如/b/匹配字符"b",當b前面加了反斜杆後/\b/,轉意爲匹配一個單詞的邊界。 
-或- 
對正則表達式功能字符的還原,如"*"匹配它前面元字符0次或屢次,/a*/將匹配a,aa,aaa,加了"\"後,/a\*/將只匹配"a*"。javascript

^ 匹配一個輸入或一行的開頭,/^a/匹配"an A",而不匹配"An a"
$ 匹配一個輸入或一行的結尾,/a$/匹配"An a",而不匹配"an A"
* 匹配前面元字符0次或屢次,/ba*/將匹配b,ba,baa,baaa
+ 匹配前面元字符1次或屢次,/ba*/將匹配ba,baa,baaa
? 匹配前面元字符0次或1次,/ba*/將匹配b,ba
(x) 匹配x保存x在名爲$1...$9的變量中
x|y 匹配x或y
{n} 精確匹配n次
{n,} 匹配n次以上
{n,m} 匹配n-m次
[xyz] 字符集(character set),匹配這個集合中的任一一個字符(或元字符)
[^xyz] 不匹配這個集合中的任何一個字符
[\b] 匹配一個退格符
\b 匹配一個單詞的邊界
\B 匹配一個單詞的非邊界
\cX 這兒,X是一個控制符,/\cM/匹配Ctrl-M
\d 匹配一個字數字符,/\d/ = /[0-9]/
\D 匹配一個非字數字符,/\D/ = /[^0-9]/
\n 匹配一個換行符
\r 匹配一個回車符
\s 匹配一個空白字符,包括\n,\r,\f,\t,\v等
\S 匹配一個非空白字符,等於/[^\n\f\r\t\v]/
\t 匹配一個製表符
\v 匹配一個重直製表符
\w 匹配一個能夠組成單詞的字符(alphanumeric,這是個人意譯,含數字),包括下劃線,如[\w]匹配"$5.98"中的5,等於[a-zA-Z0-9]
\W 匹配一個不能夠組成單詞的字符,如[\W]匹配"$5.98"中的$,等於[^a-zA-Z0-9]。

用re = new RegExp("pattern",["flags"]) 的方式比較好 
pattern : 正則表達式 
flags: g (全文查找出現的全部 pattern) 
i (忽略大小寫) 
m (多行查找)前端

vaScript動態正則表達式問題

請問正則表達式能夠動態生成嗎? 
例如JavaScript中: 
var str = "strTemp"; 
要生成: 
var re = /strTemp/; 
若是是字符鏈接: 
var re = "/" + str + "/"便可 
可是要生成表達式,能夠實現嗎?怎樣實現?java

 
     
     
[JAVA] javascript 正則表達式 
秋雨葉 發表於 2004-12-9 14:54:13

正則表達式是一個描述字符模式的對象。 
JavaScript的RegExp對象和String對象定義了使用正則表達式來執行強大的模式匹配和文本檢索與替換函數的方法. 

在JavaScript中,正則表達式是由一個RegExp對象表示的.固然,可使用一個RegExp()構造函數來建立RegExp對象, 
也能夠用JavaScript 1.2中的新添加的一個特殊語法來建立RegExp對象.就像字符串直接量被定義爲包含在引號內的字符同樣, 
正則表達式直接量也被定義爲包含在一對斜槓(/)之間的字符.因此,JavaScript可能會包含以下的代碼: 

var pattern = /s$/; 

這行代碼建立一個新的RegExp對象,並將它賦給變量parttern.這個特殊的RegExp對象和全部以字母"s"結尾的字符串都匹配.用RegExp()也能夠定義 
一個等價的正則表達式,代碼以下: 

var pattern = new RegExp("s$"); 

不管是用正則表達式直接量仍是用構造函數RegExp(),建立一個RegExp對象都是比較容易的.較爲困難的任務是用正則表達式語法來描述字符的模式. 
JavaScript採用的是Perl語言正則表達式語法的一個至關完整的子集. 

正則表達式的模式規範是由一系列字符構成的.大多數字符(包括全部字母數字字符)描述的都是按照字面意思進行匹配的字符.這樣說來,正則表達式/java/就和 
全部包含子串 "java" 的字符串相匹配.雖然正則表達式中的其它字符不是按照字面意思進行匹配的,但它們都具備特殊的意義.正則表達式 /s$/ 包含兩個字符. 
第一個特殊字符 "s" 是按照字面意思與自身相匹配.第二個字符 "$" 是一個特殊字符,它所匹配的是字符串的結尾.因此正則表達式 /s$/ 匹配的就是以字母 "s" 結尾 
的字符串. 


1.直接量字符 

咱們已經發現了,在正則表達式中全部的字母字符和數字都是按照字面意思與自身相匹配的.JavaScript的正則表達式還經過以反斜槓(\)開頭的轉義序列支持某些非 

字母字符.例如,序列 "\n" 在字符串中匹配的是一個直接量換行符.在正則表達式中,許多標點符號都有特殊的含義.下面是這些字符和它們的含義: 

正則表達式的直接量字符 

字符 匹配 
________________________________ 
字母數字字符 自身 
\ f 換頁符 
\ n 換行符 
\ r 回車 
\ t 製表符 
\ v 垂直製表符 
\ / 一個 / 直接量 
\ \ 一個 \ 直接量 
\ . 一個 . 直接量 
\ * 一個 * 直接量 
\ + 一個 + 直接量 
\ ? 一個 ? 直接量 
\ | 一個 | 直接量 
\ ( 一個 ( 直接量 
\ ) 一個 ) 直接量 
\ [ 一個 [ 直接量 
\ ] 一個 ] 直接量 
\ { 一個 { 直接量 
\ } 一個 } 直接量 
\ XXX 由十進制數 XXX 指 定的ASCII碼字符 
\ Xnn 由十六進制數 nn 指定的ASCII碼字符 
\ cX 控制字符^X. 例如, \cI等價於 \t, \cJ等價於 \n 

___________________________________________________ 

若是想在正則表達式中使用特殊的標點符號,必須在它們以前加上一個 "\" . 


2.字符類 

將單獨的直接符放進中括號內就能夠組合成字符類.一個字符類和它所包含的任何一個字符都匹配,因此正則表達式 / [abc] / 和字母 "a" , "b" , "c" 中的任何一個 
都匹配.另外還能夠定義否認字符類,這些類匹配的是除那些包含在中括號以內的字符外的全部字符.定義否認字符尖時,要將一個 ^ 符號做爲從左中括號算起的第 
一個字符.正則表達式的集合是 / [a-zA-z0-9] / . 

因爲某些字符類很是經常使用,因此JavaScript的正則表達式語法包含一些特殊字符和轉義序列來表示這些經常使用的類.例如, \s 匹配的是空格符,製表符和其它空白符, \s 
匹配的則是空白符以外的任何字符. 

正則表灰式的字符類 

字符 匹配 
____________________________________________________ 
[...] 位於括號以內的任意字符 
[^...] 不在括號之中的任意字符 
. 除了換行符以外的任意字符,等價於[^\n] 
\w 任何單字字符, 等價於[a-zA-Z0-9] 
\W 任何非單字字符,等價於[^a-zA-Z0-9] 
\s 任何空白符,等價於[\ t \ n \ r \ f \ v] 
\S 任何非空白符,等價於[^\ t \ n \ r \ f \ v] 
\d 任何數字,等價於[0-9] 
\D 除了數字以外的任何字符,等價於[^0-9] 
[\b] 一個退格直接量(特例) 
________________________________________________________________ 

3.複製 

用以上的正則表式的語法,能夠把兩位數描述成 / \ d \ d /,把四位數描述成 / \d \ d \ d \ d /.但咱們尚未一種方法能夠用來描述具備任意多數位的數字或者是一個 

字符串.這個串由三個字符以及跟隨在字母以後的一位數字構成.這些複雜的模式使用的正則表達式語法指定了該表達式中每一個元素要重複出現的次數. 

指定複製的字符老是出如今它們所做用的模式後面.因爲某種複製類型至關經常使用.因此有一些特殊的字符專門用於表示它們.例如: +號匹配的就是複製前一模式一次 

或屢次的模式.下面的表列出了複製語法.先看一個例子: 

/\d{2, 4}/ //匹配2到4間的數字. 

/\w{3} \d?/ //匹配三個單字字符和一個任意的數字. 

/\s+java\s+/ //匹配字符串"java" ,而且該串先後能夠有一個或多個空格. 

/[^"] * / //匹配零個或多個非引號字符. 


正則表達式的複製字符 

字符 含義 
__________________________________________________________________ 
{n, m} 匹配前一項至少n次,可是不能超過m次 
{n, } 匹配前一項n次,或者屢次 
{n} 匹配前一項剛好n次 
? 匹配前一項0次或1次,也就是說前一項是可選的. 等價於 {0, 1} 
+ 匹配前一項1次或屢次,等價於{1,} 
* 匹配前一項0次或屢次.等價於{0,} 
___________________________________________________________________ 


4.選擇,分組和引用 

正則表達式的語法還包括指定選擇項,對子表達式分組和引用前一子表達式的特殊字符.字符| 用於分隔供選擇的字符.例如: /ab|cd|ef/ 匹配的是字符串 "ab",或者是 

字符串 "cd",又或者 "ef". /\d{3}|[a-z]{4}/ 匹配的是要麼是一個三位數,要麼是四個小寫字母.在正則表達式中括號具備幾種做用.它的主要做用是把單獨的項目分組 

成子表達式,以即可以像處理一個獨立的單元那種用 *、+或? 來處理那些項目.例如: /java(script) ?/ 匹配的是字符串 "java",其後既能夠有 "script",也能夠沒有. / 

(ab|cd) + |ef) / 匹配的既能夠是字符串 "ef",也能夠是字符串"ab" 或者 "cd" 的一次或屢次重複. 

在正則表達式中,括號的第二個用途是在完整的模式中定義子模式。當一個正則表達式成功地和目標字符串相匹配時,能夠從目標串中抽出和括號中的子模式相匹配 

的部分.例如,假定咱們正在檢索的模式是一個或多個字母后面跟隨一位或多位數字,那麼咱們可使用模式 / [a-z] + \ d+/.可是因爲假定咱們真正關心的是每一個匹配 

尾部的數字,那麼若是咱們將模式的數字部分放在括號中 (/ [a-z] + (\d+)/) ,咱們就能夠從所檢索到的任何匹配中抽取數字了,以後咱們會對此進行解析的. 

代括號的子表達式的另外一個用途是,容許咱們在同一正則表達式的後面引用前面的子表達式.這是經過在字符串 \ 後加一位或多位數字來實現的.數字指的是代括號的 

子表達式在正則表達式中的位置.例如: \1 引用的是第一個代括號的子表達式. \3 引用的是第三個代括號的子表達式.注意,因爲子表達式能夠嵌套在其它子表達式中, 

因此它的位置是被計數的左括號的位置. 
例如:在下面的正則表達式被指定爲 \2: 
/([Jj]ava([Ss]cript)) \sis \s (fun\w*) / 


對正則表達式中前一子表達式的引用所指定的並非那個子表達式的模式,而是與那個模式相匹配的文本.這樣,引用就不僅是幫助你輸入正則表達式的重複部分的快 

捷方式了,它還實施了一條規約,那就是一個字符串各個分離的部分包含的是徹底相同的字符.例如:下面的正則表達式匹配的就是位於單引號或雙引號以內的全部字 

符.可是,它要求開始和結束的引號匹配(例如兩個都是雙引號或者都是單引號): 
/[' "] [^ ' "]*[' "]/ 


若是要求開始和結束的引號匹配,咱們可使用以下的引用: 
/( [' "] ) [^ ' "] * \1/ 


\1匹配的是第一個代括號的子表達式所匹配的模式.在這個例子中,它實施了一種規約,那就是開始的引號必須和結束的引號相匹配.注意,若是反斜槓後跟隨的數字比 

代括號的子表達式數多,那麼它就會被解析爲一個十進制的轉義序列,而不是一個引用.你能夠堅持使用完整的三個字符來表示轉義序列,這們就能夠避免混淆了.例如, 

使用 \044,而不是\44.下面是正則表達式的選擇、分組和引用字符: 

字符 含義 
____________________________________________________________________ 
| 選擇.匹配的要麼是該符號左邊的子表達式,要麼它右邊的子表達式 
(...) 分組.將幾個項目分爲一個單元.這個單元可由 *、+、?和|等符號使用,並且還能夠記住和這個組匹配的字符以供此後引 

用使用 
\n 和第n個分組所匹配的字符相匹配.分組是括號中的子表達式(多是嵌套的).分組號是從左到右計數的左括號數 
____________________________________________________________________ 



5.指定匹配的位置 

咱們已經看到了,一個正則表達式中的許多元素纔可以匹配字符串的一個字符.例如: \s 匹配的只是一個空白符.還有一些正則表達式的元素匹配的是字符之間寬度爲 

0的空間,而不是實際的字符例如: \b 匹配的是一個詞語的邊界,也就是處於一個/w字字符和一個\w非字字符之間的邊界.像\b 這樣的字符並不指定任何一個匹配了的 

字符串中的字符,它們指定的是匹配所發生的合法位置.有時咱們稱這些元素爲正則表達式的錨.由於它們將模式定位在檢索字符串中的一個特定位置.最經常使用的錨元 

素是 ^, 它使模式依賴於字符串的開頭,而錨元素$則使模式定位在字符串的末尾. 

例如:要匹配詞 "javascript" ,咱們可使用正則表達式 /^ javascript $/. 若是咱們想檢索 "java" 這個詞自身 (不像在 "javascript" 中那樣做爲前綴),那麼咱們可使 

用模式 /\s java \s /, 它要求在詞語java以前和以後都有空格.可是這樣做有兩個問題.第一: 若是 "java" 出如今一個字符的開頭或者是結尾.該模式就不會與之匹配,除 

非在開頭和結尾處有一個空格. 第二: 當這個模式找到一個與之匹配的字符時,它返回的匹配的字符串前端和後端都有空格,這並非咱們想要的.所以,咱們使用詞語 

的邊界 \b 來代替真正的空格符 \s 進行匹配. 結果表達式是 /\b java \b/. 
下面是正則表達式的錨字符: 


字符 含義 
____________________________________________________________________ 
^ 匹配的是字符的開頭,在多行檢索中,匹配的是一行的開頭 
$ 匹配的是字符的結尾,在多行檢索中,匹配的是一行的結尾 
\b 匹配的是一個詞語的邊界.簡而言之就是位於字符\w 和 \w之間的位置(注意:[\b]匹配的是退格符) 
\B 匹配的是非詞語的邊界的字符 
_____________________________________________________________________



6.屬性 

有關正則表達式的語法還有最後一個元素,那就是正則表達式的屬性,它說明的是高級模式匹配的規則.和其它正則表達式語法不一樣,屬性是在 / 符號以外說明的.即它 

們不出如今兩個斜槓之間,而是位於第二個斜槓以後.javascript 1.2支持兩個屬性.屬性 i 說明模式匹配應該是大小寫不敏感的.屬性 g 說明模式匹配應該是全局的.也 

就是說,應該找出被檢索的字符串中全部的匹配.這兩種屬性聯合起來就能夠執行一個全局的,大小寫不敏感的匹配. 

例如: 要執行一個大小不敏感的檢索以找到詞語 "java" (或者是 "java" 、"JAVA"等) 的第一個具體值,咱們可使用大小不敏感的正則表達式 /\b java\b/i .若是要在 

一個字符串中找到 "java" 全部的具體值,咱們還能夠添加屬性 g, 即 /\b java \b/gi . 

如下是正則表達式的屬性: 


字符 含義 
_________________________________________ 
i 執行大小寫不敏感的匹配 
g 執行一個全局的匹配,簡而言之,就是找到全部的匹配,而不是在找到第一個以後就中止了 
_________________________________________ 

除屬性 g 和 i 以外,正則表達式就沒有其它像屬性同樣的特性了.若是將構造函數 RegExp 的靜態屬性 multiline 設置爲 true ,那麼模式匹配將以多行的模式進行.在這 

種模式下,錨字符 ^ 和 $ 匹配的不僅是檢索字符串的開頭和結尾,還匹配檢索字符串內部的一行的開頭和結尾.例如: 模式 /Java$/ 匹配的是 "Java",可是並不匹配 

"Java\nis fun" .若是咱們設置了 multiline 屬性,那麼後者也將被匹配: 

RegExp.multiline = true;git

在JAVASCRIPT裏面判斷一個字符串是不是電子郵件的格式: 

web

if(formname.email.value!=formname.email.value.match(/^\w +[@]\w +[.][\w.] +$/)) 
{ 
alert("您的電子郵件格式錯誤!"); 
formname.email.focus(); 
return false; 
}

閱讀全文(42) | 回覆(0) | 引用(0) | [用365key收藏此日誌]  

[RED]function dateVerify(date){ 
var reg = /^(\d{4})(-)(\d{2})\2(\d{2})$/; 
var r = date.match(reg); 
if(r==null) return false; 
var d= new Date(r[1], r[3]-1,r[4]); 
var newStr=d.getFullYear()+r[2]+(d.getMonth()+1)+r[2]+d.getDate(); 
date=r[1]+r[2]+((r[3]-1)+1)+r[2]+((r[4]-1)+1); 
return newStr==date; 
}[/RED] 正則表達式

 
javascript的17種正則表達式
做者: 不祥  時間: 2004-6-9
"^\\d+$"  //非負整數(正整數 + 0) 
"^[0-9]*[1-9][0-9]*$"  //正整數 
"^((-\\d+)|(0+))$"  //非正整數(負整數 + 0) 
"^-[0-9]*[1-9][0-9]*$"  //負整數 
"^-?\\d+$"    //整數 
"^\\d+(\\.\\d+)?$"  //非負浮點數(正浮點數 + 0) 
"^(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*))$"  //正浮點數 
"^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$"  //非正浮點數(負浮點數 + 0) 
"^(-(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"  //負浮點數 
"^(-?\\d+)(\\.\\d+)?$"  //浮點數 
"^[A-Za-z]+$"  //由26個英文字母組成的字符串 
"^[A-Z]+$"  //由26個英文字母的大寫組成的字符串 
"^[a-z]+$"  //由26個英文字母的小寫組成的字符串 
"^[A-Za-z0-9]+$"  //由數字和26個英文字母組成的字符串 
"^\\w+$"  //由數字、26個英文字母或者下劃線組成的字符串 
"^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)+$"    //email地址 
"^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$"  //url 
JavaScript中的正則表達式(2)
 
 

做者 :中國論壇網收集 來源 :http://www.51one.net 加入時間 :2004-8-25  數據庫

正則表達式對象的屬性及方法 
   預約義的正則表達式擁有有如下靜態屬性:input, multiline, lastMatch, lastParen, leftContext, rightContext和$1到$9。其中input和multiline能夠預設置。其餘屬性的值在執行過exec或test方法後被根據不一樣條件賦以不一樣的值。許多屬性同時擁有長和短(perl風格)的兩個名字,而且,這兩個名字指向同一個值。(JavaScript模擬perl的正則表達式) 
正則表達式對象的屬性express

屬性 含義
$1...$9 若是它(們)存在,是匹配到的子串
$_ 參見input
$* 參見multiline
$& 參見lastMatch
$+ 參見lastParen
$` 參見leftContext
$''          參見rightContext
constructor    建立一個對象的一個特殊的函數原型
global       是否在整個串中匹配(bool型)
ignoreCase     匹配時是否忽略大小寫(bool型)
input        被匹配的串
lastIndex     最後一次匹配的索引
lastParen     最後一個括號括起來的子串
leftContext    最近一次匹配以左的子串
multiline     是否進行多行匹配(bool型)
prototype     容許附加屬性給對象
rightContext    最近一次匹配以右的子串
source       正則表達式模式
lastIndex     最後一次匹配的索引

正則表達式對象的方法 
方法 含義
compile      正則表達式比較
exec        執行查找
test        進行匹配
toSource      返回特定對象的定義(literal representing),其值可用來建立一個新的對象。重載Object.toSource方法獲得的。
toString      返回特定對象的串。重載Object.toString方法獲得的。
valueOf      返回特定對象的原始值。重載Object.valueOf方法獲得
例子 
<script language = "JavaScript"> 
var myReg = /(w+)s(w+)/; 
var str = "John Smith"; 
var newstr = str.replace(myReg, "$2, $1"); 
document.write(newstr); 
</script> 
將輸出"Smith, John"

 

 

 

javascript正則表達式檢驗編程

責任編輯:fuxing [ 網人帝國 ] 添加時間:2003-11-13 9:13:00 人氣:1169 【    

/********************************************************************************* 
* EO_JSLib.js 
* javascript正則表達式檢驗 
**********************************************************************************/ 

//校驗是否全由數字組成 
function isDigit(s) 
{ 
var patrn=/^[0-9]{1,20}$/; 
if (!patrn.exec(s)) return false 
return true 
} 

//校驗登陸名:只能輸入5-20個以字母開頭、可帶數字、「_」、「.」的字串 
function isRegisterUserName(s) 
{ 
var patrn=/^[a-zA-Z]{1}([a-zA-Z0-9]|[._]){4,19}$/; 
if (!patrn.exec(s)) return false 
return true 
} 

//校驗用戶姓名:只能輸入1-30個以字母開頭的字串 
function isTrueName(s) 
{ 
var patrn=/^[a-zA-Z]{1,30}$/; 
if (!patrn.exec(s)) return false 
return true 
} 

//校驗密碼:只能輸入6-20個字母、數字、下劃線 
function isPasswd(s) 
{ 
var patrn=/^(\w){6,20}$/; 
if (!patrn.exec(s)) return false 
return true 
} 

//校驗普通電話、傳真號碼:能夠「+」開頭,除數字外,可含有「-」 
function isTel(s) 
{ 
//var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?(\d){1,12})+$/; 
var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/; 
if (!patrn.exec(s)) return false 
return true 
} 

//校驗手機號碼:必須以數字開頭,除數字外,可含有「-」 
function isMobil(s) 
{ 
var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/; 
if (!patrn.exec(s)) return false 
return true 
} 

//校驗郵政編碼 
function isPostalCode(s) 
{ 
//var patrn=/^[a-zA-Z0-9]{3,12}$/; 
var patrn=/^[a-zA-Z0-9 ]{3,12}$/; 
if (!patrn.exec(s)) return false 
return true 
} 

//校驗搜索關鍵字 
function isSearch(s) 
{ 
var patrn=/^[^`~!@#$%^&*()+=|\\\][\]\{\}:;'\,.<>/?]{1}[^`~!@$%^&()+=|\\\][\]\{\}:;'\,.<>?]{0,19}$/; 
if (!patrn.exec(s)) return false 
return true 
} 

function isIP(s) //by zergling 
{ 
var patrn=/^[0-9.]{1,20}$/; 
if (!patrn.exec(s)) return false 
return true 
}後端

 

 

正則表達式regular expression詳述(一) 
http://www.kymita.com/888.asp 2002-12-15 藍箭工做室


正則表達式是regular expression,看來英文比中文要好理解多了,就是檢查表達式符 
不符合規定!!正則表達式有一個功能十分強大而又十分複雜的對象RegExp,在JavaScript1.2 版本以 
上提供。 
下面咱們看看有關正則表達式的介紹: 
正則表達式對象用來規範一個規範的表達式(也就是表達式符不符合特定的要求,好比是否是Email 
地址格式等),它具備用來檢查給出的字符串是否符合規則的屬性和方法。 
除此以外,你用RegExp構造器創建的個別正則表達式對象的屬性,就已經預先定義好了正則表達式 
對象的靜態屬性,你能夠隨時使用它們。 
核心對象: 
在JavaScript 1.2, NES 3.0以上版本提供。 
在JavaScript 1.3之後版本增長了toSource方法。 
創建方法: 
文字格式或RegExp構造器函數。 
文字創建格式使用如下格式: 
/pattern/flags即/模式/標記

構造器函數方法使用方法以下: 
new RegExp("pattern"[, "flags"])即new RegExp("模式"[,"標記"])

參數: 
pattern(模式) 
表示正則表達式的文本

flags(標記) 
若是指定此項,flags能夠是下面值之一: 
g: global match(全定匹配) 
i: ignore case(忽略大小寫) 
gi: both global match and ignore case(匹配全部可能的值,也忽略大小寫)

注意:文本格式中的參數不要使用引號標記,而構造器函數的參數則要使用引號標記。因此下面的 
表達式創建一樣的正則表達式: 
/ab+c/i 
   new RegExp("ab+c", "i")

描述: 
當使用構造函數的時候,必須使用正常的字符串避開規則(在字符串中加入前導字符\ )是必須的。 
例如,下面的兩條語句是等價的: 
re = new RegExp("\\w+") 
re = /\w+/

下面的提供了在正則表達式中可以使用的完整對特殊字符的一個完整的列表和描述。

表1.3:正則表達式中的特殊字符:

字符\ 
意義:對於字符,一般表示按字面意義,指出接着的字符爲特殊字符,\不做解釋。 
例如:/b/匹配字符'b',經過在b 前面加一個反斜槓\,也就是/\b/,則該字符變成特殊字符,表示 
匹配一個單詞的分界線。 
或者: 
對於幾個字符,一般說明是特殊的,指出緊接着的字符不是特殊的,而應該按字面解釋。 
例如:*是一個特殊字符,匹配任意個字符(包括0個字符);例如:/a*/意味匹配0個或多個a。 
爲了匹配字面上的*,在a前面加一個反斜槓;例如:/a\*/匹配'a*'。

字符^ 
意義:表示匹配的字符必須在最前邊。 
例如:/^A/不匹配"an A,"中的'A',但匹配"An A."中最前面的'A'。

字符$ 
意義:與^相似,匹配最末的字符。 
例如:/t$/不匹配"eater"中的't',但匹配"eat"中的't'。

字符* 
意義:匹配*前面的字符0次或n次。 
例如:/bo*/匹配"A ghost booooed"中的'boooo'或"A bird warbled"中的'b',但不匹配"A goat g 
runted"中的任何字符。

字符+ 
意義:匹配+號前面的字符1次或n次。等價於{1,}。 
例如:/a+/匹配"candy"中的'a'和"caaaaaaandy."中的全部'a'。

字符? 
意義:匹配?前面的字符0次或1次。 
例如:/e?le?/匹配"angel"中的'el'和"angle."中的'le'。

字符. 
意義:(小數點)匹配除換行符外的全部單個的字符。 
例如:/.n/匹配"nay, an apple is on the tree"中的'an'和'on',但不匹配'nay'。


字符(x) 
意義:匹配'x'並記錄匹配的值。 
例如:/(foo)/匹配和記錄"foo bar."中的'foo'。匹配子串能被結果數組中的素[1], ..., [n] 返
回,或被RegExp對象的屬性$1, ..., $9返回。

字符x|y 
意義:匹配'x'或者'y'。 
例如:/green|red/匹配"green apple"中的'green'和"red apple."中的'red'。

字符{n} 
意義:這裏的n是一個正整數。匹配前面的n個字符。 
例如:/a{2}/不匹配"candy,"中的'a',但匹配"caandy," 中的全部'a'和"caaandy."中前面的兩個 
'a'。

字符{n,} 
意義:這裏的n是一個正整數。匹配至少n個前面的字符。 
例如:/a{2,}不匹配"candy"中的'a',但匹配"caandy"中的全部'a'和"caaaaaaandy."中的全部'a'

字符{n,m} 
意義:這裏的n和m都是正整數。匹配至少n個最多m個前面的字符。 
例如:/a{1,3}/不匹配"cndy"中的任何字符,但匹配 "candy,"中的'a',"caandy," 中的前面兩個 
'a'和"caaaaaaandy"中前面的三個'a',注意:即便"caaaaaaandy" 中有不少個'a',但只匹配前面的三 
個'a'即"aaa"。

字符[xyz] 
意義:一字符列表,匹配列出中的任一字符。你能夠經過連字符-指出一個字符範圍。 
例如:[abcd]跟[a-c]同樣。它們匹配"brisket"中的'b'和"ache"中的'c'。

字符[^xyz] 
意義:一字符補集,也就是說,它匹配除了列出的字符外的全部東西。 你可使用連字符-指出一 
字符範圍。 
例如:[^abc]和[^a-c]等價,它們最先匹配"brisket"中的'r'和"chop."中的'h'。

字符[\b] 
意義:匹配一個空格(不要與\b混淆)

字符\b 
意義:匹配一個單詞的分界線,好比一個空格(不要與[\b]混淆) 
例如:/\bn\w/匹配"noonday"中的'no',/\wy\b/匹配"possibly yesterday."中的'ly'。

字符\B 
意義:匹配一個單詞的非分界線 
例如:/\w\Bn/匹配"noonday"中的'on',/y\B\w/匹配"possibly yesterday."中的'ye'。

字符\cX 
意義:這裏的X是一個控制字符。匹配一個字符串的控制字符。 
例如:/\cM/匹配一個字符串中的control-M。

字符\d 
意義:匹配一個數字,等價於[0-9]。 
例如:/\d/或/[0-9]/匹配"B2 is the suite number."中的'2'。

字符\D 
意義:匹配任何的非數字,等價於[^0-9]。 
例如:/\D/或/[^0-9]/匹配"B2 is the suite number."中的'B'。

字符\f 
意義:匹配一個表單符

字符\n 
意義:匹配一個換行符

字符\r 
意義:匹配一個回車符

字符\s 
意義:匹配一個單個white空格符,包括空格,tab,form feed,換行符,等價於[ \f\n\r\t\v]。 
例如:/\s\w*/匹配"foo bar."中的' bar'。

字符\S 
意義:匹配除white空格符之外的一個單個的字符,等價於[^ \f\n\r\t\v]。 
例如:/\S/\w*匹配"foo bar."中的'foo'。

字符\t 
意義:匹配一個製表符

字符\v 
意義:匹配一個頂頭製表符

字符\w 
意義:匹配全部的數字和字母以及下劃線,等價於[A-Za-z0-9_]。 
例如:/\w/匹配"apple,"中的'a',"$5.28,"中的'5'和"3D."中的'3'。

字符\W 
意義:匹配除數字、字母外及下劃線外的其它字符,等價於[^A-Za-z0-9_]。 
例如:/\W/或者/[^$A-Za-z0-9_]/匹配"50%."中的'%'。

字符\n 
意義:這裏的n是一個正整數。匹配一個正則表達式的最後一個子串的n的值(計數左圓括號)。

例如:/apple(,)\sorange\1/匹配"apple, orange, cherry, peach."中的'apple, orange',下面 
有一個更加完整的例子。 
注意:若是左圓括號中的數字比\n指定的數字還小,則\n取下一行的八進制escape做爲描述。

字符\ooctal和\xhex 
意義:這裏的\ooctal是一個八進制的escape值,而\xhex是一個十六進制的escape值,容許在一個 
正則表達式中嵌入ASCII碼。


當表達式被檢查的時候,文字符號提供了編輯正則表達式的方法。利用文字符號可使到正則表達 
式保持爲常數。例如,若是你在一個循環中使用文字符號來構造一個正則表達式,正則表達式不需進行 
反覆編譯。 
正則表達式對象構造器,例如,new RegExp("ab+c"),提供正則表達式的運行時編譯。當你知道正 
則表達式的模式會變化的時候,應該使用構造函數,或者你不知道正則表達式的模式,而它們是從另外 
的源得到的時候,好比由用戶輸入時。一旦你定義好了正則表達式,該正則表達式可在任何地方使用, 
而且能夠改變,你可使用編譯方法來編譯一個新的正則表達式以便從新使用。 
一個分離預先定義的RegExp對象能夠在每一個窗口中使用;也就是說,每一個分離的JavaScript線程運 
行以得到本身的RegExp對象。由於每一個腳本在一個線程中是不可中斷的,這就確保了不一樣的腳本不會覆 
蓋RegExp對象的值。 
預約義的RegExp對象包含的靜態屬性:input, multiline, lastMatch,lastParen, leftContext, 
rightContext, 以及從$1到$9。input和multiline屬性能被預設。其它靜態屬性的值是在執行個別正則 
表達式對象的exec和test方法後,且在執行字符串的match和replace方法後設置的。

屬性 
注意RegExp對象的幾個屬性既有長名字又有短名字(象Perl)。這些名字都是指向相同的值。Perl是 
一種編程語言,而JavaScript模仿了它的正則表達式。

屬性$1, ..., $9 
取得匹配的子串,若是有的話

屬性$_ 
參考input

屬性$* 
參考multiline

屬性$& 
參考lastMatch

屬性$+ 
參考lastParen

屬性$` 
參考leftContext

屬性$' 
參考rightContext

屬性constructor 
指定用來創建對象原型函

屬性global 
決定是否測試正則表達式是否不能匹配全部的字符串,或者只是與最早的衝突。

屬性ignoreCase 
決定試圖匹配字符串的時候是否忽略大小寫

屬性input 
當正則表達式被匹配的時候,爲相反的字符串。

屬性lastIndex 
決定下一次匹配從那裏開始

屬性lastMatch 
最後一個匹配的字符

屬性lastParen 
子串匹配的時候,最後一個parenthesized,若是有的話。

屬性leftContext 
最近一次匹配前的子串。

屬性multiline 
是否在串的多行中搜索。

屬性prototype 
容許附加屬性到全部的對象

屬性rightContext 
最近一次匹配後的的子串。

屬性source 
模式文本

 


方法 
compile方法 
編譯一個正則表達式對象

exec方法 
運行正則表達式匹配

test方法 
測試正則達式匹配

toSource方法 
返回一個對象的文字描述指定的對象;你可使用這個值來創建一個新的對象。不考慮Object.toS 
ource方法。

toString方法 
返回一個字符串描述指定的對象,不考慮Object.toString對象。

valueOf方法 
返回指定對角的原始值。不考慮Object.valueOf方法。

 另外,這個對象繼承了對象的watch和unwatch方法


   例子: 
   例1、下述示例腳本使用replace方法來轉換串中的單詞。在替換的文本中,腳本使用全局 RegExp 
對象的$1和$2屬性的值。注意,在做爲第二個參數傳遞給replace方法的時候,RegExp對象的$屬性的名 
稱。 
<SCRIPT LANGUAGE="JavaScript1.2"> 
re = /(\w+)\s(\w+)/; 
str = "John Smith"; 
newstr=str.replace(re,"$2, $1"); 
document.write(newstr) 
</SCRIPT> 
顯示結果:"Smith, John".

  例2、下述示例腳本中,RegExp.input由Change事件處理句柄設置。在getInfo函數中,exec 方法 
使用RegExp.input的值做爲它的參數,注意RegExp預置了$屬性。


<SCRIPT LANGUAGE="JavaScript1.2"> 
function getInfo(abc) 
{ 
re = /(\w+)\s(\d+)/; 
re.exec(abc.value); 
window.alert(RegExp.$1 + ", your age is " + RegExp.$2); 
} 
</SCRIPT>

  請輸入你的姓和年齡,輸入完後按回車鍵。 
   <FORM><INPUT TYPE="TEXT" NAME="NameAge" onChange="getInfo(this);"></FORM> 
   </HTML>


$1, ..., $9屬性 
用圓括號括着的匹配子串,若是有的話。 
是RegExp的屬性 
靜態,只讀

在JavaScript 1.2, NES 3.0以上版本提供 
描述:由於input是靜態屬性,不是個別正則表達式對象的屬性。你可使用RegExp.input 訪問該 
屬性。

能加上圓括號的子串的數量不受限制,但正則表達式對象只能保留最後9 條。若是你要訪問全部的 
圓括號內的匹配字串,你可使用返回的數組。

這些屬性能用在RegExp.replace方法替換後的字符串(輸出結果)。當使用這種方式的時候,不用預 
先考慮RegExp對象。下面給出例子。當正則表達式中沒有包含圓括號的時候,該腳本解釋成$n的字面意 
義。(這裏的n是一個正整數)。


例如: 
下例腳本使用replace 方法來交換串中單詞的位置。在替換後的文本字串中,腳本使用正則表達式 
RegExp對象的$1和$2屬性的值。注意:當它們向replace方法傳遞參數的時候,這裏沒有考慮 $ 屬性的 
RegExp對象的名稱。 
<SCRIPT LANGUAGE="JavaScript1.2"> 
re = /(\w+)\s(\w+)/; 
str = "John Smith"; 
newstr=str.replace(re,"$2, $1"); 
document.write(newstr) 
</SCRIPT> 
顯示的輸出結果爲:Smith, John。 

 

正則表達式regular expression詳述(二) 
http://www.kymita.com/888.asp 2002-12-15 藍箭工做室


正則表達式詳述(二)

如下這些不是正則表達式的新增對象請參閱對應的JavaScript對象的屬性 $_屬性 參考input $*屬性 
參考multiline $&屬性 參考lastMatch $+屬性 參考lastParen $`屬性 
參考leftContext $'屬性 參考rightContext compile方法 在腳本運行期間編譯正則表達式對象 
屬於RegExp的方法 在JavaScript 1.2, NES 3.0以上版本提供 語法: 
regexp.compile(pattern[, flags]) 以數: regexp 正則表達式的名稱,能夠是變量名或文字串。 
pattern 正則表達式的定義文本。 flags 若是指定的話,能夠是下面其中的一個: "g": 匹配全部可能的字串 
"i": 忽略大小寫 "gi": 匹配全部可能的字串及忽略大小寫 描述: 
使用compile方法來編譯一個正則表達式 created with the RegExp constructor function。這樣 
就強制正則表達式只編譯一次,而不是每次遇到正則表達式的時候都編譯一次。當你確認正則表達式能 
保持不變的時候可以使用compile 方法來編譯它(在得到它的匹配模式後),這樣就能夠在腳本中重複屢次使用它。 
你亦可使用compile 方法來改變在運行期間改變正則表達式。例如,假如正則表達式發生變化, 
你可使用compile方法來從新編譯該對象來提升使用效率。 
使用該方法將改變正則表達式的source, global和ignoreCasesource屬性的值。 constructor 
指出創建對象原型的function。注意這個屬性的值由函數自己提供,而不是一個字串包含RegExp的name.Property提供。 
在JavaScript 1.1, NES 2.0以上版本提供 ECMA版本ECMA-262 描述:參考Object.constructor. 
exec方法 在指定的字符串運行匹配搜索。返回一個結果數組。 是RegExp的方法 
在JavaScript 1.2, NES 3.0以上版本提供 語法: regexp.exec([str])regexp([str]) 
參數: regexp,正則表達式的名稱,能夠是一個變量名或文字定義串。 
str,要匹配正則表達式的字符串,若是省略,將使用RegExp.input的值。 
描述:就如在語法描述中的同樣,正則表達工的exec方法可以被直接調用(使用regexp.exec(str))或者間接調用(使用regexp(str))。 
假如你只是運行以找出是否匹配,可使用String搜索方法。 
假如匹配成功,exec方法返回一個數組而且更新正則表達式對象屬性的值和預先定義的正則表達式對象、RegExp。若是匹配失敗,exec方法返回null。 
請看下例: <SCRIPT LANGUAGE="JavaScript1.2"> //匹配一個b接着一個或多個d,再接着一個b 
//忽略大小寫 myRe=/d(b+)(d)/ig; myArray = myRe.exec("cdbBdbsbz"); 
</SCRIPT> 下面是該腳本的返回值:對象 屬性/Index 描述 例子 
myArray

myArray的內容 ["dbBd", "bB", "d"] 
index 
基於0的匹配index 1 
input 
原始字符串 cdbBdbsbz 
[0] 
最後匹配的字符 dbBd 
[1], ...[n] 
用圓括號括住的匹配字符串,若是有的話。不限制括號的個數。 [1] = bB 
[2] = d 
myRe 
lastIndex 
開始下次匹配操做的index值 5 
ignoreCase 
指出"i"是否使用以忽略大小寫 true 
global 
指出是否使用"g"標記來進行匹配全部可能的字串 true 
source 
定義模式的文本字符串 d(b+)(d) 
RegExp 
lastMatch$& 
最後匹配的字符 dbBd 
leftContext$\Q 
最新匹配前面的子串 c 
rightContext$' 
最新匹配後面的子串 bsbz 
$1, ...$9 
圓括號內的匹配子串,若是有的話。圓括號的個數不受限制,但RegExp只能保留最後9個 $1 = bB 
$2 = d 
lastParen $+ 
最後一個加上圓括號的匹配子串,若是有的話 d

假如你的正則表達式使用了"g"標記,你能夠屢次使用exec 方法來連續匹配相同的串。當你這樣作 
的時候,新的匹配將從由正則表達式的lastIndex 屬性值肯定的子串中開始。例如,假定你使用下面的腳本: 
<SCRIPT LANGUAGE="JavaScript1.2"> myRe=/ab*/g;str = "abbcdefabh" 
myArray = myRe.exec(str); 
document.writeln("Found "+myArray[0]+". Next match starts at "+myRe.lastIndex) 
mySecondArray = myRe.exec(str); 
document.writeln("Found "+mySecondArray[0]+". Next match starts at "+myRe.lastIndex) 
</SCRIPT> 這個腳本顯示以下結果: Found abb. Next match starts at 3 
Found ab. Next match starts at 9 例子: 
在下面的例子中,用戶輸入一個名字,腳本根據輸入執行匹配操做。接着檢查數組看是否和其它用戶的名字匹配。 
本腳本假定已註冊的用戶的姓已經存進了數組A中,或許從一個數據庫中取得。 <HTML> 
<SCRIPT LANGUAGE="JavaScript1.2"> A = ["zhao","qian","sun","li","liang"] 
function lookup() { firstName = /\w+/i(); if (!firstName) 
window.alert (RegExp.input + "非法輸入"); else { count=0; 
for (i=0;i 輸入你的姓而後按回車鍵。 
<FORM><INPUT TYPE:"TEXT" NAME="FirstName" onChange="lookup(this);"></FORM> 
</HTML> global屬性 正則表達式中是否使用了"g"標記。 RegExp屬性,只讀 
在JavaScript 1.2, NES 3.0以上版本提供 描述: global是一個個別正則表達式對象的屬性 
若是使用了"g"標記,global的值爲true;不然爲 false。"g"標記指定正則表達式測試全部可能的匹配。 
你不能直接改變該屬性的值,但能夠調用compile方法來改變它。 ignoreCase 檢查正則表達式是否使用了"i"標記 
RegExp屬性,只讀 在JavaScript 1.2, NES 3.0以上版本提供 描述: 
ignoreCase是個別正則表達式對象的一個屬性。 
若是使用了"i"標記,則返回true,不然返回false。"i"標記指示在進行匹配的時候忽略大小寫。
你不能直接改變該屬性的值,但能夠經過調用compile方法來改變它 input 指出正則表達式要測試那個字串。$_是這個屬性的另外一個名字。 
RegExp的屬性,靜態 在JavaScript 1.2, NES 3.0以上版本提供 
描述:由於input是靜態的,不是某個個別的正則表達式對象的屬性。你也可使用 RegExp.input來表示。 
若是沒有給正則表達式的exec或test方法提供字符串,而且RegExp.input中有值,則使用它的值來調用該方法。 
腳本或瀏覽器可以預置input屬性。若是被預置了值且調用exec或 test方法的時候沒有提供字符串 
則調用exec或test的時候使用input的值。input能夠被瀏覽器如下面的方式設置: 
當text表單域處理句柄被調用的時候,input被設置爲該text輸入的字串。 
當textarea表單域處理句柄被調用的時候,input被設置爲textarea域內輸入的字串。注意multili 
ne亦被設置成true從而能匹配多行文本。 當select表單域處理句柄被調用的時候,input被設置成selected text的值。 
當連接對象的處理句柄被調用的時候,input被設置成<A HREF=...>和</A>之間的字符串。 
事件理現句柄處理完畢後,input屬性的值被清除。 lastIndex 可讀/可寫的一個整數屬性,指出下一次匹配從哪裏開始。 
RegExp的屬性 在JavaScript 1.2, NES 3.0以上版本提供 
描述:lastIndex 是個別的正則表達式對象的屬性。 這個屬性只有當正則表達式的"g"標記被使用以進行全串匹配的時候才被設置。實行如下規則: 
若是lastIndex大小字符串的長度,regexp.test和regexp.exec失敗,且lastIndex被設爲0。 
若是lastIndex等於字串的長度且正則表達式匹配空字符串,則正則表達式從lastIndex的位置開始匹配。 
若是lastIndex等於字符串的長度且正則表達式不匹配空字符串,則正則表達式不匹配input,且lastIndex被置爲0。 
不然,lastIndex被設置成最近一次匹配的下一點。 例如,按下面的順序執行腳本: re = /(hi)?/g 匹配空字符串 
re("hi") 返回["hi", "hi"],lastIndex置爲2 
re("hi") 返回[""],一個空數組,它的下標爲0的元素就是匹配字符串。在這種狀況下,返回空
串是由於lastIndex等於2(且仍然是2),而且"hi"的長度也是2。 lastMatch 最後一次匹配字符串,$&是一樣的意思。 
RegExp的屬性,靜態,只讀 在JavaScript 1.2, NES 3.0以上版本提供 
描述:由於lastMatch是靜態的,因此它不是個別指定正則表達式的屬性。你也可使用RegExp.lastMatch。 lastParen 
最後一次加上括號的匹配字符串,若是有的話。$+是一樣的意思。 RegExp屬性,靜態,只讀
在JavaScript 1.2, NES 3.0以上版本提供 
描述:由於lastParen是靜態的,它不是某個個別正則式的屬性,你可使用RegExp.lastParen 表達一樣的意思。 
leftContext 最近一次匹配前面的子串,$`具備相同的意思。 RegExp的屬性,靜態,只讀 
在JavaScript 1.2, NES 3.0以上版本提供 
描述:由於leftContext是靜態的,不是某一個正則表達式的屬性,因此可使用RegExp.leftContext來表達想同的意思。 
multiline 反映是否匹配多行文本,$*是相同的意思。 RegExp的屬性,靜態 
在JavaScript 1.2, NES 3.0以上版本提供 
描述:由於multiline是靜態的,而不是某個個別正則表達式的屬性,因此可以用RegExp.multiline表達相同的意思。 
若是容許匹配多行文本,則multiline爲true,若是搜索必須在換行時中止,則爲false。 
腳本或瀏覽器可以設置multiline屬性。當一個textarea的事件處理句柄被調用的時候,multiline 
被置爲true。在事件處理句柄處理完畢後,multiline屬性值被清除。也就是說,若是你設置了multili 
ne爲true,則執行任何的事件處理句柄後,multiline被置爲false。 prototype 
描繪類的原型。你能夠根據要求使用prototype來增長類的屬性或方法。爲了得到prototypes 的資 
料,請參閱RegExp的Function.prototype.Property屬性。 從JavaScript 1.1, NES 2.0版本開始提供 
ECMA版本ECMA-262 rightContext 最後一次匹配的右邊的字符串,$'是一樣的效果。 
RegExp的屬性,靜態,只讀 從 JavaScript 1.2, NES 3.0以上版本開始提供 
描述:由於rightContext是靜態的,不是某個個別正則表達工的屬性,可使用RegExp.rightContext來達到相同的效果。 
source 一個只讀屬性,包含正則表達式定義的模式,不包僑forward slashes和"g"或"i"標記。 RegExp的屬性,只讀 
從JavaScript 1.2, NES 3.0以上版本開始提供 
描述:source是個別正則表達式對象的屬性,你不能直接改變它的值,但能夠經過調用compile 方法來改變它。 test 
執行指定字符串的正則表達式匹配搜索,返回true或false。 RegExp的方法 
從JavaScript 1.2, NES 3.0以上版本開始提供 語法:regexp.test([str]) 
參數:regexp,正則表達式的名稱,能夠是變量名或正則表達式定義文字串 
str,要匹配的字符串,若是省略,將使用RegExp.input的值爲做參數 
描述:當你須要知道一個字符串可否匹配某個正則表達工,可使用test方法(與String.search方 
法相似); 爲了得到更多的信息(但速度將變慢),可使用exec方法(與String.match方法相似)。 例子:下面的例子顯示test是否成功的提示: 
function testinput(re, str){ 
if (re.test(str)) midstring = " contains "; 
else midstring = " does not contain "; 
document.write (str + midstring + re.source); } toSource 
返回一個字符串象徵對象的源碼 RegExp的方法 從JavaScript 1.3以上版本開始提供 語法:toSource() 
參數:沒有 描述:toSource方法返回下述的值: 對於內置的RegExp對象,toSource返回下面的字符象徵源碼不可用: 
function Boolean(){ [native code] } 
在RegExp場合中, toSource返回象徵源碼的字符串,一般這個方法是由JavaScript內部自動調用而不是不代碼中顯式調用。 
更多請看Object.toSource toString 返回描繪指定對象的字符串。 RegExp的方法 
從JavaScript 1.1, NES 2.0開始提供 ECMA版本ECMA-262 語法:toString() 參數:無 
描述:RegExp對象不考慮Object對象的toString方法;它不繼承Object.toString,對於RegExp 對 
象,toString方法返回一個表明該對象的字符串。 例如:下面的例子顯示象徵RegExp對象的字符串 
myExp = new RegExp("a+b+c"); alert(myExp.toString()) 
displays "/a+b+c/" 更多請看:Object.toString valueOf 返回一個RegExp對象的原始值 
RegExp的方法 從JavaScript 1.1版本開始提供 ECMA版本:ECMA-262 語法:valueOf() 
參數:無 描述:RegExp的valueOf方法以字符串形式返回RegExp對象的原始值,這個值與RegExp.toString相等。 
該方法一般由JavaScript內部自動調用而不是顯式調用 例子: myExp = new RegExp("a+b+c"); 
alert(myExp.valueOf()) displays "/a+b+c/" 

 

 

正則表達式在javascript中的幾個實例1(轉)

! 去除字符串兩端空格的處理 

若是採用傳統的方式,就要可能就要採用下面的方式了 
//清除左邊空格 
function js_ltrim(deststr) 
{ 
if(deststr==null)return ""; 
var pos=0; 
var retStr=new String(deststr); 
if (retStr.lenght==0) return retStr; 
while (retStr.substring(pos,pos+1)==" ") pos++; 
retStr=retStr.substring(pos); 
return(retStr); 
} 
//清除右邊空格 
function js_rtrim(deststr) 
{ 
if(deststr==null)return ""; 
var retStr=new String(deststr); 
var pos=retStr.length; 
if (pos==0) return retStr; 
while (pos && retStr.substring(pos-1,pos)==" " ) pos--; 
retStr=retStr.substring(0,pos); 
return(retStr); 
} 
//清除左邊和右邊空格 
function js_trim(deststr) 
{ 
if(deststr==null)return ""; 
var retStr=new String(deststr); 
var pos=retStr.length; 
if (pos==0) return retStr; 
retStr=js_ltrim(retStr); 
retStr=js_rtrim(retStr); 
return retStr; 
} 

採用正則表達式,來去除兩邊的空格,只需如下代碼 
String.prototype.trim = function() 
{ 
return this.replace(/(^\s*)|(\s*$)/g, ""); 
} 

一句就搞定了, 
可見正則表達式爲咱們節省了至關的編寫代碼量 


! 移動手機號的校驗 

若是採用傳統的校驗方式至少就要完成下面三步的校驗, 
(1). 是不是數字 
(2).是不是11位 
(3).數字的第三位是不是5,6,7,8,9 
若是採用正則表達式校驗,只需如下代碼 
function checkMobile1(form) 
{ 
if (form.mobile.value > "") 
{ 
var reg=/13[5,6,7,8,9]\d{8}/; 
if ( form.mobile.value.match(reg)== null) 
{ 
alert("請輸入正確的移動手機號碼!"); 
form.mobile.focus(); return false; 
} 
} 
return true; 
} 

從上面的代碼能夠看出校驗移動手機號只需定義一個var reg=/13[5,6,7,8,9]\d{8}/;模式匹配串就能夠完成合法性校驗了 

! URL的校驗, 
條件:必須以http:// 或 https:// 開頭, 端口號必須爲在1-65535 之間, 如下代碼完成了合法性校驗 

//obj:數據對象 
//dispStr :失敗提示內容顯示字符串 
function checkUrlValid( obj, dispStr) 
{ 
if(obj == null) 
{ 
alert("傳入對象爲空"); 
return false; 
} 
var str = obj.value; 

var urlpatern0 = /^https?:\/\/.+$/i; 
if(!urlpatern0.test(str)) 
{ 
alert(dispStr+"不合法:必須以'http:\/\/'或'https:\/\/'開頭!"); 
obj.focus(); 
return false; 
} 

var urlpatern2= /^https?:\/\/(([a-zA-Z0-9_-])+(\.)?)*(:\d+)?.+$/i; 
if(!urlpatern2.test(str)) 
{ 
alert(dispStr+"端口號必須爲數字且應在1-65535之間!"); 
obj.focus(); 
return false; 
} 


var urlpatern1 =/^https?:\/\/(([a-zA-Z0-9_-])+(\.)?)*(:\d+)?(\/((\.)?(\?)?=?&?[a-zA-Z0-9_-](\?)?)*)*$/i; 

if(!urlpatern1.test(str)) 
{ 
alert(dispStr+"不合法,請檢查!"); 
obj.focus(); 
return false; 
} 

var s = "0"; 
var t =0; 
var re = new RegExp(":\\d+","ig"); 
while((arr = re.exec(str))!=null) 
{ 
s = str.substring(RegExp.index+1,RegExp.lastIndex); 

if(s.substring(0,1)=="0") 
{ 
alert(dispStr+"端口號不能以0開頭!"); 
obj.focus(); 
return false; 
} 

t = parseInt(s); 
if(t<1 || t >65535) 
{ 
alert(dispStr+"端口號必須爲數字且應在1-65535之間!"); 
obj.focus(); 
return false; 
} 
} 
return true; 
} 

對url的校驗,看上去有不少的代碼,這是由於要給予出錯提示, 不然只需var urlpatern1 =/^https?:\/\/(([a-zA-Z0-9_-])+(\.)?)*(:\d+)?(\/((\.)?(\?)?=?&?[a-zA-Z0-9_-](\?)?)*)*$/i; 一句就能夠校驗出url合法性了

 

 

 

 
正則表達式在JavaScript應用
 
時間戳: 2004-11-30 15:29:30 人氣: 23
做者: AnyRock 來源:www.mending.cn
 
-------------------------------------------------------------- 
去掉字符串頭尾多餘的空格 
/g是全文查找全部匹配 

function String.prototype.Trim(){return this.replace(/(^\s*)|(\s*$)/g, "");} 

function String.prototype.LTrim(){return this.replace(/(^\s*)/g, "");} 

function String.prototype.RTrim(){return this.replace(/(\s*$)/g, "");} 

-------------------------------------------------------------- 
應用:計算字符串的長度(一個雙字節字符長度計2,ASCII字符計1) 

String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;} 

-------------------------------------------------------------- 
應用:javascript中沒有像vbscript那樣的trim函數,咱們就能夠利用這個表達式來實現,以下: 

String.prototype.trim = function() 
{ 
return this.replace(/(^\s*)|(\s*$)/g, ""); 
} 
得用正則表達式從URL地址中提取文件名的javascript程序,以下結果爲page1 

s="http://www.9499.net/page1.htm" 
s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2") 
alert(s) 

##利用正則表達式限制網頁表單裏的文本框輸入內容: 

-------------------------------------------------------------- 
用正則表達式限制只能輸入中文:onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,'))" 

-------------------------------------------------------------- 
用正則表達式限制只能輸入全角字符: onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,'))" 

-------------------------------------------------------------- 
用正則表達式限制只能輸入數字:onkeyup="value=value.replace(/[^\d]/g,') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,'))"

-------------------------------------------------------------- 
用正則表達式限制只能輸入數字和英文:onkeyup="value=value.replace(/[\W]/g,') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,'))"
 
最近更新: AnyRock 2004-11-30 15:38:2 返回頁首
 

 

用正則表達式和javascript對錶單進行全面驗證

代碼:<!-- 
使用時請將下面的javascript代碼存到一個單一的js文件中。 
一、表單要求 
<form name="formname" onSubmit="return validateForm(this)"></form> 
將對錶單中的全部如下類型的域依次驗證,全部驗證是去除了前導和後綴空格的,要注意是區分大小寫的。 
二、空值驗證 
表單中任意域加上emptyInfo屬性將對此域是否爲空進行驗證(能夠和最大長度驗證\通常驗證方式同時使用)。 
無此屬性視爲此域容許空值。 
   如:<input type="text" name="fieldNamename" emptyInfo="字段不能爲空!"> 
三、最大長度驗證(能夠和空值驗證、通常驗證方式同時使用): 
<input type="text" name="fieldNamename" maxlength="20" lengthInfo="最大長度不能超過20!"> 
或,<textarea maxlength="2000" lengthInfo="最大長度不能超過2000!"> 
三、通常驗證方式(不對空值作驗證): 
   如:<input type="text" validator="^(19|20)[0-9]{2}$" errorInfo="不正確的年份!" > 
四、標準驗證(不與其它驗證方式同時使用): 
所有經過<input type="hidden">來實現,而且不須要name屬性以避免提交到服務器。 
   4.一、合法日期驗證: 
<input type="text" name="yearfieldName" value="2004">注:這裏也能夠是<select name="yearfieldName"></select>,如下同 
<input type="text" name="monthfieldName" value="02"> 
<input type="text" name="dayfieldName" value="03"> 
<input type="hidden" validatorType="DateGroup" year="yearfieldName" month="monthfieldName" day="dayfieldName" errorInfo="不正確的日期!"> 
yearfieldName、monthfieldName、dayfieldName分別爲年月日字段,月和日能夠是兩位(MM)或一位格式(M), 
此處不對每一個字段分別檢驗(若是要檢驗,請在年月日三個域分別使用前面的通常驗證方式),只對日期的最大值是否合法檢查; 
4.二、日期格式驗證(請注意,此驗證不對日期是否有效進行驗證,還未找到從格式中獲得年月日數據的方法^_^): 
<input type="text" name="datefieldName" value="2003-01-03 21:31:00"> 
<input type="hidden" validatorType="Date" fieldName="datefieldName"; format="yyyy-MM-dd HH:mm:ss" errorInfo="不正確的日期!"> 
其中格式僅對y、M、d、H、m、s進行支持(其它字符視爲非時間的字符) 
4.三、列表驗證: 
檢驗列表(checkbox、redio、select)是否至少選中了一條記錄(對select主要用於多項選擇) 
<input type="checkbox" name="checkbox1"> 
<input type="hidden" validatorType="Checkbox" fieldName="checkbox1" errorInfo="請至少選中一條記錄!"> 
其中validatorType能夠是Checkbox、R、Select; 
對於一個select表單,若是要求選擇一條不能是第一條的記錄,請用下列方式: 
<select name="select1" emptyInfo="請選擇一個選項!"> 
<option value="">==請選擇==</option> 
<option value="1">1</option> 
<select> 
4.四、Email驗證: 
<input type="text" name="email"> 
<input type="hidden" fieldName="email" validatorType="Email" separator="," errorInfo="不正確的Email!"> 
其中separator爲可選項,表示輸入多個email時的分隔符(無此選項只能是一個地址) 
4.五、加入其它javascript操做: 
<script type="text/javascript"> 
function functionname(){ 
自定義方法 
} 
</script> 
表單中加入<input type="hidden" validatorType="javascript" functionName="functionname">(此時emptyInfo等屬性無效) 
時將調用function屬性中指定的javascript方法(要求方法返回true或false,返回false將再也不驗證表單,也不提交表單)。 
五、在表單經過驗證提交前disable一個按鈕(也可將其它域disable,不能與其它驗證同在一個域),不要求按鈕是表單中的最後一個 
<input type="button" name="提交" validatorType="disable"> 
六、不驗證表單 
   <input type="hidden" name="validate" value="0" functionName="functionname"> 
當validator域值爲0時不對錶單進行驗證,直接提交表單或執行指定function並返回true後提交表單 
functionName爲可選

--> 
<script type="text/javascript"> 
function getStringLength(str){ 
var endvalue=0; 
var sourcestr=new String(str); 
var tempstr; 
for (var strposition = 0; strposition < sourcestr.length; strposition ++) { 
tempstr=sourcestr.charAt(strposition); 
if (tempstr.charCodeAt(0)>255 || tempstr.charCodeAt(0)<0) { 
endvalue=endvalue+2; 
} else { 
endvalue=endvalue+1; 
} 
} 
return(endvalue); 
} 
function trim(str){ 
if(str==null) return ""; 
if(str.length==0) return ""; 
var i=0,j=str.length-1,c; 
for(;i<str.length;i++){ 
c=str.charAt(i); 
if(c!=' ') break; 
} 
for(;j>-1;j--){ 
c=str.charAt(j); 
if(c!=' ') break; 
} 
if(i>j) return ""; 
return str.substring(i,j+1); 
} 
function validateDate(date,format,alt){ 
var time=trim(date.value); 
if(time=="") return; 
var reg=format; 
var reg=reg.replace(/yyyy/,"[0-9]{4}"); 
var reg=reg.replace(/yy/,"[0-9]{2}"); 
var reg=reg.replace(/MM/,"((0[1-9])|1[0-2])"); 
var reg=reg.replace(/M/,"(([1-9])|1[0-2])"); 
var reg=reg.replace(/dd/,"((0[1-9])|([1-2][0-9])|30|31)"); 
var reg=reg.replace(/d/,"([1-9]|[1-2][0-9]|30|31))"); 
var reg=reg.replace(/HH/,"(([0-1][0-9])|20|21|22|23)"); 
var reg=reg.replace(/H/,"([0-9]|1[0-9]|20|21|22|23)"); 
var reg=reg.replace(/mm/,"([0-5][0-9])"); 
var reg=reg.replace(/m/,"([0-9]|([1-5][0-9]))"); 
var reg=reg.replace(/ss/,"([0-5][0-9])"); 
var reg=reg.replace(/s/,"([0-9]|([1-5][0-9]))"); 
reg=new RegExp("^"+reg+"$"); 
if(reg.test(time)==false){//驗證格式是否合法 
alert(alt); 
date.focus(); 
return false; 
} 
return true; 
} 
function validateDateGroup(year,month,day,alt){ 
var array=new Array(31,28,31,30,31,30,31,31,30,31,30,31); 
var y=parseInt(year.value); 
var m=parseInt(month.value); 
var d=parseInt(day.value); 
var maxday=array[m-1]; 
if(m==2){ 
if((y%4==0&&y%100!=0)||y%400==0){ 
maxday=29; 
} 
} 
if(d>maxday){ 
alert(alt); 
return false; 
} 
return true; 
} 
function validateCheckbox(obj,alt){ 
var rs=false; 
if(obj!=null){ 
if(obj.length==null){ 
return obj.checked; 
} 
for(i=0;i<obj.length;i++){ 
if(obj[i].checked==true){ 
return true; 
} 
} 
} 
alert(alt); 
return rs; 
} 
function validateRadio(obj,alt){ 
var rs=false; 
if(obj!=null){ 
if(obj.length==null){ 
return obj.checked; 
} 
for(i=0;i<obj.length;i++){ 
if(obj[i].checked==true){ 
return true; 
} 
} 
} 
alert(alt); 
return rs; 
} 
function validateSelect(obj,alt){ 
var rs=false; 
if(obj!=null){ 
for(i=0;i<obj.options.length;i++){ 
if(obj.options[i].selected==true){ 
return true; 
} 
} 
} 
alert(alt); 
return rs; 
} 
function validateEmail(email,alt,separator){ 
var mail=trim(email.value); 
if(mail=="") return; 
var em; 
var myReg = /^[_a-z0-9]+@([_a-z0-9]+\.)+[a-z0-9]{2,3}$/; 
if(separator==null){ 
if(myReg.test(email.value)==false){ 
alert(alt); 
email.focus(); 
return false; 
} 
} 
else{ 
em=email.value.split(separator); 
for(i=0;i<em.length;i++){ 
em[i]=em[i].trim(); 
if(em[i].length>0&&myReg.test(em[i])==false){ 
alert(alt); 
email.focus(); 
return false; 
} 
} 
} 
return true; 
} 
function validateForm(theForm){// 若驗證經過則返回true 
var disableList=new Array(); 
var field = theForm.elements; // 將表單中的全部元素放入數組 
for(var i = 0; i < field.length; i++){ 
var vali=theForm.validate; 
if(vali!=null){ 
if(vali.value=="0"){ 
var fun=vali.functionName; 
if(fun!=null){ 
return eval(fun+"()"); 
} 
else{ 
return true; 
} 
} 
}

var empty=false; 
var value=trim(field[i].value); 
if(value.length==0){//是否空值 
empty=true; 
} 
var emptyInfo=field[i].emptyInfo;//空值驗證 
if(emptyInfo!=null&&empty==true){ 
alert(emptyInfo); 
field[i].focus(); 
return false; 
} 
var lengthInfo=field[i].lengthInfo;//最大長度驗證 
if(lengthInfo!=null&&getStringLength(value)>field[i].maxLength){ 
alert(lengthInfo); 
field[i].focus(); 
return false; 
}

var validatorType=field[i].validatorType;if(validatorType!=null){//其它javascriptvar rs=true;if(validatorType=="javascript"){eval("rs="+field[i].functionName+"()");if(rs==false){return false;}else{continue;}}else if(validatorType=="disable"){//提交表單前disable的按鈕disableList.length++;disableList[disableList.length-1]=field[i];continue;}else if(validatorType=="Date"){rs=validateDate(theForm.elements(field[i].fieldName),field[i].format,field[i].errorInfo);}else if(validatorType=="DateGroup"){rs=validateDateGroup(theForm.elements(field[i].year),theForm.elements(field[i].month),theForm.elements(field[i].day),field[i].errorInfo);}else if(validatorType=="Checkbox"){rs=validateCheckbox(theForm.elements(field[i].fieldName),field[i].errorInfo);}else if(validatorType=="Radio"){rs=validateRadio(theForm.elements(field[i].fieldName),field[i].errorInfo);}else if(validatorType=="Select"){rs=validateSelect(theForm.elements(field[i].fieldName),field[i].errorInfo);}else if(validatorType=="Email"){rs=validateEmail(theForm.elements(field[i].fieldName),field[i].errorInfo);}else{alert("驗證類型不被支持, fieldName: "+field[i].name);return false;}if(rs==false){return false;}}else{//通常驗證if(empty==false){var v = field[i].validator; // 獲取其validator屬性if(!v) continue; // 若是該屬性不存在,忽略當前元素var reg=new RegExp(v);if(reg.test(field[i].value)==false){alert(field[i].errorInfo);field[i].focus();return false;}}}}for(i=0;i<disableList.length;i++){disableList[i].disabled=true;}return true;}</script>