正規表示式中的特殊字符
- 巴扎黑原創
- 2017-03-18 10:31:581620瀏覽
1.JS正規表示式大全(上)
正規表示式中的特殊字元
字元 含意
做為轉意，即通常在""後面的字元不按原來意義解釋，如/b/匹配字元"b"，當b前面加了反斜桿後/b/，轉意為符合一個單字的邊界。
-或-
對正規表示式功能字元的還原，如"*"匹配它前面元字元0次或多次，/a*/將匹配a,aa,aaa，加了""後，/a* /將只匹配"a*"。
^ 匹配一個輸入或一行的開頭，/^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 匹配一個非空白字符，等於/[^nfrtv]/
t 匹配一個製表符
v匹配一個重直製表符
w 匹配一個可以組成單字的字符(alphanumeric，這是我的意譯，含數字)，包括下劃線，如[w]匹配"$5.98"中的5，等於[a-zA- Z0-9]
W 符合一個不可以組成單字的字符，如[W]匹配"$5.98"中的$，等於[^a-zA-Z0-9]。
2.JS正規表示式大全(下)
正規表示式是描述字元模式的物件。
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 /.但我們還沒有一種方法可以用來描述具有任意多數位的數字或是一個字串.這個串由三個字元以及跟隨在字母之後的一位數字構成.這些複雜的模式使用的正則表達式語法指定了該表達式中每個元素要重複出現的次數.
指定複製的字元總是出現在它們所作用的模式後面.由於某種複製類型相當常用.所以有一些特殊的字符專門用於表示它們.例如: +號匹配的就是複製前一模式一次或多次的模式.下面的表格列出了複製語法.先看一個例子:
/d{2, 4}/ //匹配2到4間的數字.
/w{3} d? / //符合三個單字字元和一個任意的數字.
/s+javas+/ //匹配字串"java" ,並且該字串前後可以有一個或多個空格.
/[^"] * / / /符合零個或多個非引號字元.
正規表示式的複製字元
字元意義
__________________________________________________________________
{n, m} 符合前一項至少n次,但是不能超過m次
{n, } 符合前一項n次,或多次
{n} 配對前一項恰好n次
? 配對前一項0次或1次,也就是說前一項是可選的. 等價於{0, 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 (funw*) /
對正規表示式中前一子表達式式的引用所指定的並不是那個子表達式的模式,而是與那個模式相匹配的文本.這樣,引用就不只是幫助你輸入正則表達式的重複部分的快捷方式了,它還實施了一條規約,那就是一個字串各個分離的部分包含的是完全相同的字元.例如:下面的正則表達式匹配的就是位於單引號或雙引號之內的所有字元.但是,它要求開始和結束的引號匹配(例如兩個都是雙引號或都是單引號):
/[' "] [^ ' "]*[' "]/
如果要求開始和結束的引號匹配,我們可以使用如下的引用:
/( [' "] ) [^ ' "] * 1/
1匹配的是第一個代括號的子表達式所匹配的模式.在這個例子中,它實施了一種規約,那就是開始的引號必須和結束的引號相匹配.注意,如果反斜杠後跟隨的數字比代括號的子表達式數多,那麼它就會被解析為一個十進制的轉義序列,而不是一個引用.你可以堅持使用完整的三個字符來表示轉義序列,這們就可以避免混淆了.例如,使用b 匹配的是一個詞語的邊界.簡而言之就是位於字符w 和w之間的位置(注意:[b]匹配的是退格符)
B 匹配的是非詞語的邊界的字符
_____________________________________________________________________
6.屬性
有關正規表示式的語法還有最後一個元素,那就是正規表示式的屬性,它說明的是高級模式匹配的規則.和其它正則表達式語法不同,屬性是在/ 符號之外說明的.即它們不出現在兩個斜杠之間,而是位於第二個斜杠之後.javascript 1.2支持兩個屬性.屬性i 說明模式匹配應該是大小寫不敏感的.屬性g 說明模式匹配應該是全域的.也就是說,應該找出被檢索的字串中所有的匹配.這兩種屬性聯合起來就可以執行一個全局的,大小寫不敏感的匹配.
例如: 要執行一個大小不敏感的檢索以找到詞語"java" (或者是"java" 、"JAVA"等) 的第一個具體值,我們可以使用大小不敏感的正則表達式/b javab/i .如果要在一個字符串中找到"java" 所有的特定值,我們也可以加入屬性g, 即/b java b/gi .
JS正規表示式大全【3】
以下是正規表示式的屬性:
字元意義
_________________________________________
i執行大小寫不敏感的匹配
g 執行一個全局的匹配,簡而言之,就是找到所有的匹配,而不是在找到第一個之後就停止了
_________________________________________
除屬性g 和i 之外,正則表達式就沒有其它像屬性一樣的特性了.如果將構造函數RegExp 的靜態屬性multiline 設置為true ,那麼模式匹配將以多行的模式進行.在這
種模式下,錨字符^ 和$ 匹配的不只是檢索字串的開頭和結尾,也符合檢索字串內部的一行的開頭和結尾.例如: 模式/Java$/ 符合的是"Java",但是不符合"Javanis fun" .如果我們設定了multiline屬性,那麼後者也會被配對:
RegExp.multiline = true;
在JAVASCRIPT裡面判斷一個字串是否是電子郵件的格式：
if(formname.email.value!=formname.email.value.match(/^\w +[@]\w +[.][\w.] +$/))
{
alert("您的电子邮件格式错误！");
formname.email.focus();
return false;
}
[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;
}javascript的17种正则表达式
"^\\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中的正则表达式
正则表达式对象的属性及方法
预定义的正则表达式拥有有以下静态属性：input, multiline, lastMatch, lastParen, leftContext, rightContext和$1到$9。其中input和multiline可以预设置。其他属性的值在执行过exec或test方法后被根据不同条件赋 以不同的值。许多属性同时拥有长和短(perl风格)的两个名字，并且，这两个名字指向同一个值。(JavaScript模拟perl的正则表达式)
正则表达式对象的属性
属性 含义
$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方法得到
例子
334f6305b6ca5b80c0fa1a5fd0526a69
var myReg = /(w+)s(w+)/;
var str = "John Smith";
var newstr = str.replace(myReg, "$2, $1");
document.write(newstr);
2cacc6d41bbb37262a98f745aa00fbf0
将输出"Smith, John"
JS正则表达式大全
/*********************************************************************************
* 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详述
正则表达式是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]混淆)
例如：/bnw/匹配"noonday"中的'no'，/wyb/匹配"possibly yesterday."中的'ly'。
字符B ——意義：匹配一個單字的非分界線
例如：/wBn/匹配"noonday"中的'on'，/yBw/匹配"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，換行符，等價於[ fnrtv]。
例如：/sw*/匹配"foo bar."中的' bar'。
字符S ——意義：匹配white空格符以外的一個單一的字符，等價於[^ fnrtv]。
例如：/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(,)sorange1/匹配"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方法
例子：
例１、下述示例脚本使用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".
例２、下述示例脚本中，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。
JS正则表达式大全
正则表达式regular expression详述
以下这些不是正则表达式的新增对象请参阅对应的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。
请看下例： 8cc9a834f4278df216fc1f34199a18d6 //匹配一个b接着一个或多个d，再接着一个b
//忽略大小写 myRe=/d(b+)(d)/ig; myArray = myRe.exec("cdbBdbsbz");
db271416853c42fd247a57c1a2c29eb6 下面是该脚本的返回值：对象 属性/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 属性值确定的子串中开始。例如，假定你使用下面的脚本：
8cc9a834f4278df216fc1f34199a18d6 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)
這個腳本顯示如下結果： Found abb. Next match starts at 3
Found ab. Next match starts at 9 範例：
在下面的例子中，使用者輸入一個名字，腳本根據輸入執行匹配操作。接著檢查數組看是否和其它用戶的名字匹配。
本腳本假定已註冊的使用者的姓已經存進了數組A中，或許從一個資料庫中取得。
//清除左边空格
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应用
--------------------------------------------------------------
去掉字符串头尾多余的空格
/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.php.cn"
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,'))"
用正则表达式和javascript对表单进行全面验证
代码：8108cbe1d58f0ab0b8a10168eac341c1f5a47148e367a6035fd7a2faa965022e
将对表单中的所有以下类型的域依次验证，所有验证是去除了前导和后缀空格的，要注意是区分大小写的。
2、空值验证
表单中任意域加上emptyInfo属性将对此域是否为空进行验证（可以和最大长度验证\一般验证方式同时使用）。
无此属性视为此域允许空值。
如：76fcbe9cf4728131adeaeefb1d19e404
3、最大长度验证（可以和空值验证、一般验证方式同时使用）：
7090effba10d5a8d06f390b8f397dffa
或,854d848c6aacabd3a6930a1f7cc1a264
3、一般验证方式(不对空值做验证）:
如：2777422c368dfc08ffebbfa3b9685492
4、标准验证(不与其它验证方式同时使用）：
全部通过6bfea39e2880ed1f176d4faec8788f49来实现，并且不需要name属性以免提交到服务器。
4.1、合法日期验证：
9f099c6201d78ef8ee979fbb0b7c3989注：这里也可以是9b9cce9d485fd856c764c3921a38610f18bb6ffaf0152bbe49cd8a3620346341，以下同
b4795830b8b4fd6fe33ae8fd2d234040
df4fff216f85eb215f7ab97dd263b85d
3ecb2c31af449d6373db17a47a5d0b4a
yearfieldName、monthfieldName、dayfieldName分别为年月日字段，月和日可以是两位(MM)或一位格式(M)，
此处不对每个字段分别检验(如果要检验，请在年月日三个域分别使用前面的一般验证方式），只对日期的最大值是否合法检查;
4.2、日期格式验证(请注意，此验证不对日期是否有效进行验证，还未找到从格式中得到年月日数据的方法^_^)：
e39bbdac53c9b96d654d7948d309f01f
638eebff72278424b873f6783e9246c5
其中格式仅对y、M、d、H、m、s进行支持(其它字符视为非时间的字符)
4.3、列表验证：
检验列表(checkbox、redio、select)是否至少选中了一条记录(对select主要用于多项选择)
ecea8bd3ab8f002a9c08f722f3de1b48
f82e4b74eb30432400fb7d6aad45b16a
其中validatorType可以是Checkbox、R、Select;
对于一个select表单，如果要求选择一条不能是第一条的记录，请用下列方式:
aa3674743b1815f1e225c0b86905bf0a
deb802d11e8b0cc341f68c280f65dae7==请选择==4afa15d3069109ac30911f04c56f3338
22d7eb427e1a7079cd01008d37a3299c14afa15d3069109ac30911f04c56f3338
221f08282418e2996498697df914ce4e
4.4、Email验证：
596bff45a69e9abd8468b4bbd281de7b
3742f6d40f21f1d20e29773a96316594
其中separator为可选项，表示输入多个email时的分隔符(无此选项只能是一个地址）
4.5、加入其它javascript操作：
5cd6e472395e766622bc5d31b556eb7a
function functionname(){
自定义方法
}
2cacc6d41bbb37262a98f745aa00fbf0
表单中加入3f7460748f8d32895f1ba4c9cbc19d31（此时emptyInfo等属性无效）
时将调用function属性中指定的javascript方法（要求方法返回true或false，返回false将不再验证表单，也不提交表单)。
5、在表单通过验证提交前disable一个按钮（也可将其它域disable,不能与其它验证同在一个域)，不要求按钮是表单中的最后一个
065ed6893513df288c1961d1c785b207
6、不验证表单
a18c8eb901ff34e0ea4ac896a352fbf5
当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){//其它javascript
var 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>