正規表現内の特殊文字

1.JS正規表現コレクション(on)

正規表現の特殊文字
文字の意味
は転置として使用されます。つまり、通常、「」の後の文字は元の意味に従って解釈されません。たとえば、b の場合、/b/ は文字「b」と一致します。バックスラッシュが前にあります。 語幹 /b/ の後は、単語の境界に一致するように意味が変更されます。
-または-
正規表現の関数文字の削減。たとえば、「*」がその前のメタキャラクターに 0 回以上一致する場合、/a*/ は a、aa、aaa に一致し、「" を追加した後は /a* / のみに一致します」抹茶*"。
^ は入力または行の先頭に一致します。 /^a/ は「an A」に一致しますが、「An a」には一致しません。
$ は入力または行の末尾に一致します。 /a$/ は「An a」に一致します"、ただし、"an A" には一致しません
* は、先行するメタキャラクターに 0 回以上一致します。/ba*/ は、b、ba、baa、baaa に一致します。
+ は、先行するメタキャラクターに 1 回以上一致します。/ba*/ は、 match 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] 文字セット (文字セット)、このセット内の任意の文字 (または要素) と一致します
[^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 は、アンダースコアを含む、単語 (英数字、これは数字を含む私の意訳です) を形成できる文字と一致します。たとえば、[w] は、「$5.98」の 5 と一致します。これは、[ と等しくなります。 a-zA- Z0-9]
W は単語を構成できない文字に一致します。たとえば、[W] は「$5.98」の $ に一致します。これは [^a-zA-Z0-9] に相当します。

2.JS正規表現集(その2)
正規表現とは、文字パターンを記述するオブジェクトです。
JavaScript の RegExp オブジェクトと String オブジェクトは、正規表現を使用して強力なパターン マッチング、テキストの取得および置換機能を実行するためのメソッドを定義します。
JavaScript では、正規表現は RegExp() コンストラクターで表現できます。 RegExp オブジェクトを作成する場合は、JavaScript 1.2 で追加された特別な構文を使用して RegExp オブジェクトを作成します。 (/) したがって、JavaScript には次のコードが含まれる可能性があります:
var pattern = /s$/;
このコード行は、新しい RegExp オブジェクトを作成し、それを変数パターンに割り当てます。 RegExp() を使用して同等の正規表現を定義することもできます。コードは次のとおりです。
var pattern = new RegExp ("s$"); 正規表現リテラルを使用するか、コンストラクター RegExp() を使用します。 )、RegExp オブジェクトを作成するのは比較的簡単ですが、より難しい作業は、正規表現構文を使用して文字のパターンを記述することです。
JavaScript は、Perl 言語の正規表現構文のかなり完全なサブセットを使用します。正規表現は一連の文字で構成されます。ほとんどの文字 (すべての英数字を含む) は、一致することを意味する文字として記述されます。このように、正規表現 /java/ は、他の文字を含むすべての文字列に一致します。正規表現の /s$/ には、文字通り一致するものではなく、特別な意味があります。
最初の特殊文字「s」は、文字通り一致する特殊文字です。したがって、正規表現 /s$/ は、文字「s」で終わる文字列と一致します。
正規表現内のすべての文字と数字が一致することがわかりました。文字通り、JavaScript の正規表現は、バックスラッシュ () で始まるエスケープ シーケンスを通じて特定の非アルファベット文字もサポートします。たとえば、文字列内のシーケンス "n" はリテラルの改行文字です。正規表現では、多くの句読点文字が特別な意味を持ちます。これらの文字とその意味は次のとおりです:
正規表現のリテラル文字
文字一致 ____________________________ 英数字自体
f 改行文字
n 改行文字
r キャリッジリターン
t タブ文字
v 垂直タブ文字
/ a / 直接数量
直接数量
. a. 直接量
* a * 直接量
? a ? 直接量
( a (直接量
) a ) 直接量
| ] リテラル
{ a { リテラル
} a } リテラル
10 進数 XXX で指定された XXX ASCII コード文字
t に相当、cJ は n に相当
______________________________________________
正規表現で特殊な句読点を使用したい場合は、次のようにする必要があります前に "" を追加します。

2. 文字クラス

直接文字を入力します。 文字クラスは角かっこで囲むことができるため、正規表現 / [abc] / は任意の文字に一致します。文字 "a"、"b"、"c" すべてに一致します。 さらに、これらのクラスは、角括弧内に含まれる文字を除くすべての文字に一致します。の最初の文字は /[a-zA-z0-9]/ です。特定の文字クラスが非常によく使用されるため、JavaScript の正規表現構文には次のものが含まれます。いくつかの特殊文字とエスケープ シーケンスを表すこれらの一般的に使用されるクラス。たとえば、 s はスペース、タブ、その他の空白文字に一致し、 s は空白文字を除く任意の文字に一致します。
文字の一致 __________________________________________________ [ .. .] 括弧内の任意の文字
[^...] 括弧内にない任意の文字
. [^n] と同等の改行を除く任意の文字
w 任意の 1 単語文字など [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. 上記の正規表現を使用してコピーします。式の構文では、2 桁の数値は / d d /、4 桁の数値は / d d d / と記述できますが、それを使用する方法はまだありません。任意の数の数値または文字列を記述します。これらの複雑なパターンは、式の各要素を指定する正規表現構文を使用します。
コピーするように指定された文字は、常にパターンの後に表示されます。特定のコピー タイプは非常に一般的に使用されるため、それらを表すために特別に使用される特殊文字がいくつかあります。 以下の表にコピー構文を示します。最初に例を示します:
/d{2, 4}/ //2 から 4 までの数字に一致します。
/w{3} d? //3 つの単一文字と任意の数字に一致します。
/s+javas+/ //文字列「java」と一致します。文字列の前後に 1 つ以上のスペースがあっても構いません
/[^"] * / / / 0 個以上の非引用文字と一致します。 正規表現の文字をコピーします

文字意味
_________________________________________________________________
{n, m} は前の項目に少なくとも n 回一致しますが、m 回以下です
{n, } は前の項目に n 回、または複数回一致します
{n} は前の項目に正確に n 回一致します
? 前の項目と 0 回または 1 回一致します。つまり、前の項目はオプションです。 * は、前の項目と 0 回以上一致します。 ____________________________________________________________

4. 、グループ化と参照

正規表現の構文には、選択項目の指定、部分式のグループ化、および前の部分式を参照する特殊文字も含まれます。たとえば、/ab|cd|ef/ は、文字を区切るために使用されます。文字列 "ab"、文字列 "cd"、または "ef "。/d{3}|[a-z]{4}/ は、3 桁の数字または 4 つの小文字のいずれかに一致します。正規表現には括弧がいくつかの機能があります。その主な機能は、項目を部分式にグループ化して、*、+、または ? を使用して独立した単位として処理できるようにすることです。たとえば、/java(script) ?/ は文字列「java」に一致します。両方 "script" がある場合とない場合があります。 / (ab|cd) + |ef) / 文字列 "ef" または文字列 "ab" または "cd" の 1 つ以上の繰り返しに一致します。正規表現における括弧の 2 番目の使用法は、完全なパターン内のサブパターンを定義することです。正規表現がターゲット文字列に一致すると、括弧内のサブパターンに一致するターゲット文字列の部分を抽出できます。たとえば、取得するパターンが 1 つ以上の文字とそれに続く 1 桁の数字であると仮定します。の場合、パターン /[a-z]+d+/ を使用できます。ただし、各一致の末尾の数字を実際に気にしていると想定されているため、パターンの数値部分を括弧で囲みます (/[a-z) ] + (d+)/) を使用すると、取得した一致から数値を抽出できます。後で解析します。
括弧で囲まれた部分式のもう 1 つの使用法は、同じ正規表現で使用できるようにすることです。式の後ろは前の式を参照します。これは、文字列の後に 1 つ以上の数字を追加することによって実現されます。例: 1 参照は、最初の括弧の部分式を指します。部分式は他の部分式内にネストできるため、その位置がカウントされることに注意してください。
例: 次の正規表現では、
/([Jj]ava([Ss]) cript)) sis s (funw*) /
正規表現の前の部分式の場合 式の参照は、部分式のパターンを指定するのではなく、そのパターンに一致するテキストを指定するだけではありません。正規表現の繰り返し部分を入力するのに役立つショートカットです。また、規則も実装されています。つまり、文字列の各部分にはまったく同じ文字が含まれています。たとえば、次の正規表現は、single または double 内にあるすべての文字と一致します。ただし、開始引用符と終了引用符が一致する必要があります (たとえば、両方が二重引用符であるか、両方が単一引用符である):
/[' "] [^ ' "]*[' "]/
開始引用符と終了引用符が一致する場合一致する必要がある場合は、次の引用符を使用できます:
/( [' "] ) [^ ' "] * 1/
1 は、最初の括弧で囲まれた部分式によって一致するパターンと一致します。この例では、規則を実装しています。 is start 引用符は終了引用符と一致する必要があります。バックスラッシュの後に括弧内の部分式の数よりも多くの数字が続く場合、引用符ではなく 10 進数のエスケープ シーケンスとして解析されることに注意してください。エスケープ シーケンスを表すには完全な 3 文字を使用します。これにより、混乱を避けることができます。たとえば、次のように使用します。b は単語の境界に一致します。つまり、文字 w と w の間の位置です (注: [b] はバックスペース文字に一致します)
B は単語の境界ではない文字に一致します
___________________________________________________________________________
6 . 属性
正規表現構文には最後の要素があり、これは高度なパターン マッチングのルールを説明するもので、図示されているように、属性は / 記号の外側にあります。 2 つのスラッシュの間には表示されませんが、JavaScript 1.2 は 2 つの属性をサポートします。属性 g はパターン マッチングがグローバルであることを示します。これら 2 つのプロパティを組み合わせて、大文字と小文字を区別しないグローバルな一致を実行できます。 例: 異なるサイズの一致を実行して、単語「java」の最初の特定の値を検索します。 (または「java」、「JAVA」など)、文字列内の最初の特定の値を見つけたい場合は、サイズに依存しない正規表現 /b javab/i を使用できます。 "java" には、属性 g、つまり /b java b/gi を追加することもできます。
JS 正規表現コレクション [3]
正規表現の属性は次のとおりです:
文字の意味
__________________________________________
i ケースを実行します。鈍感なマッチング
g グローバルマッチングを実行します。つまり、最初の一致を見つけた後に停止するのではなく、すべての一致を検索します。
_______________________________________________
属性 g と i を除き、正規表現 この式には、静的属性の複数行の属性のような他のプロパティはありません。コンストラクター RegExp が true に設定されている場合、パターン マッチングは複数行モードで実行されます。このモードでは、アンカー文字 ^ と $ は一致しません。文字列の先頭と末尾のみが検索されますが、先頭と末尾も一致します。例: パターン /Java$/ は「Java」に一致しますが、「Javanis fun」には一致しません。複数行属性を設定すると、後者も一致します:
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=/^[^`~!@#$%^&*()+=|\\\][\]\{\}:;&#39;\,.<>/?]{1}[^`~!@$%^&()+=|\\\][\]\{\}:;&#39;\,.<>?]{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.」の最初の 2 つの
'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」の最初の 2 つの
「a」と「caaaaaaandy」には一致します。 「caaaaaaandy」の最初の 3 つの「a」に注意してください。「caaaaaaandy」に多くの「a」がある場合でも、一致するのは最初の 3 つの「a」、つまり「aaa」のみです。
Character [xyz] - 意味: リスト内の任意の文字と一致する文字のリスト。ハイフン - を使用して文字の範囲を指定できます。
例: [abcd] は [a-c] と同じです。これらは、「brisket」の「b」と「ache」の「c」に一致します。
Character[^xyz]——意味: 1 文字の補数。つまり、リストされている文字を除くすべての文字と一致します。 ハイフンを使用して文字範囲を示すことができます。
例: [^abc] と [^a-c] は同等で、最初に「brisket」の「r」と「chop.」の「h」に一致します。
文字 [b] ——意味: スペースと一致します (b と混同しないでください)
文字 b —— 意味: スペースなどの単語の分割線と一致します ([b] と混同しないでください)
例: /bnw/ は「noonday」の「no」に一致し、/wyb/ は「possibly Yesterday.」の「ly」に一致します。
文字 B—— 意味: 単語の非改行行と一致します。
例: /wBn/ は「正午」の「on」と一致し、/yBw/ は「おそらく昨日」の「ye」と一致します。
文字 cX - 意味: ここの X は制御文字です。制御文字の文字列と一致します。
例: /cM/ は文字列内の control-M と一致します。
文字 d - 意味: [0-9] に相当する数値と一致します。
例: /d/ または /[0-9]/ は、「B2 はスイート番号です。」の「2」と一致します。
文字 D - 意味: [^0-9] に相当する任意の非数値と一致します。
例: /D/ または /[^0-9]/ は、「B2 はスイート番号です。」の「B」と一致します。
文字 f ——意味: フォーム文字と一致
文字 n ——意味: 改行文字と一致
文字 r ——意味: 復帰文字と一致
文字 s ——意味: スペースを含む単一の空白文字と一致、タブ、フォームフィード、改行文字、[fnrtv]に相当します。
例: /sw*/ は、「foo bar.」の「bar」と一致します。
文字 S - 意味: [^ fnrtv] に相当する、空白を除く 1 つの文字と一致します。
例: /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 は次の行の 8 進エスケープを説明として受け取ります。
文字 oooctal および xhex - 意味: ここでの oooctal は 8 進数のエスケープ値、xhex は 16 進数のエスケープ値で、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]+". 次の一致は "+myRe.lastIndex" から始まります)
db271416853c42fd247a57c1a2c29eb6 このスクリプトは次の結果を表示します。 . 次の一致は 3 から始まります
見つかった次の一致は 9 から始まります 例:
次の例では、ユーザーが名前を入力し、スクリプトが入力に基づいて一致操作を実行します。次に、配列がチェックされて、他のユーザーの名前と一致するかどうかが確認されます。
このスクリプトは、登録ユーザーの姓が配列 A に格納されており、おそらくデータベースから取得されていることを前提としています。 6a74014ee44f5deb5894267f99b68016
50950bf35e67c33484f0159171ae2eae A = ["zhao","qian","sun","li","liang"]
関数 lookup() { firstName = /w+ /i(); if (!firstName)
window.alert (RegExp.input + "不正な入力"); else { count=0;i 姓を入力して Enter を押してください。 FORM>6d0ed6c2a76bf254c5cafd3877ac0c6467c47c2f4e2e39e829bbcfb43fc3cadb
6eac519e8537e4205ddd37e30a7b548a グローバル属性の正規表現「タグ」で「g」が使用されているかどうかRegExp 属性、読み取り専用
JavaScript 1.2、NES 3.0 以降で提供される説明: global は、個々の正規表現オブジェクトのプロパティです
「g」タグが使用されている場合、global の値は true です。 false。「g」タグは、正規表現がすべての一致をテストすることを指定します。
この属性の値を直接変更することはできませんが、ignoreCase は正規表現で「i」が使用されているかどうかを確認します。タグ
RegExp 属性、読み取り専用 JavaScript 1.2、NES 3.0 以降で提供される説明:
ignoreCase は、個々の正規表現オブジェクトのプロパティです。
「i」タグが使用されている場合は true を返し、それ以外の場合は Ignore を返します。
この属性の値を直接変更することはできませんが、compile メソッドを呼び出すことで変更できます。
RegExp の属性は JavaScript 1.2、NES 3.0 以降で提供されます。 : input は静的であり、個々の正規表現オブジェクトのプロパティではないため、exec または正規表現がない場合、および値がある場合は、RegExp.input を使用して表すこともできます。 RegExp.input では、その値を使用してメソッドを呼び出します。
スクリプトまたはブラウザーは、入力属性が事前に設定されており、exec メソッドまたは test メソッドを呼び出すときに値がない場合は、その値を使用します。 exec または test を呼び出します。入力はブラウザで次の方法で設定できます:
テキストフォームフィールドハンドラーが呼び出されるとき、入力はテキストによって入力された文字列に設定されます。
textarea フォーム フィールド ハンドラーが呼び出されるとき、input は textarea フィールドに入力された文字列に設定されます。複数行のテキストに一致するように、multili
ne も true に設定されていることに注意してください。 選択フォーム フィールド ハンドラーが呼び出されると、入力は選択されたテキストの値に設定されます。
リンク オブジェクトのハンドラーが呼び出されるとき、入力は 6a2b3936541eb5c40626a82687b7bf27 と 63505a6f727f70c8bd4066f3066dcb9d の間の文字列に設定されます。
イベントハンドラーが処理された後、入力属性の値はクリアされます。 lastIndex 次の一致がどこから始まるかを示す読み取り/書き込み整数プロパティ。
RegExp のプロパティ JavaScript 1.2、NES 3.0 以降で使用可能
説明: lastIndex は、個々の正規表現オブジェクトのプロパティです。 この属性は、正規表現の「g」フラグが完全な文字列一致に使用される場合にのみ設定されます。次のルールが適用されます:
lastIndex が文字列の長さの場合、regexp.test と regexp.exec は失敗し、lastIndex は 0 に設定されます。
lastIndex が文字列の長さと等しく、正規表現が空の文字列と一致する場合、正規表現は lastIndex の位置から一致を開始します。
lastIndex が文字列の長さと等しく、正規表現が空の文字列と一致しない場合、正規表現は入力と一致せず、lastIndex は 0 に設定されます。
それ以外の場合、lastIndex は最新の一致の次のポイントに設定されます。 たとえば、次の順序でスクリプトを実行します。 re = /(hi)?/g は空の文字列と一致します
re("hi") returns ["hi", "hi"]、lastIndex を 2 に設定します
re( "hi" ) は、インデックス 0 の要素が一致する文字列である空の配列 [""] を返します。この場合、lastIndex が 2 に等しく (そして 2 のまま)、「hi」の長さも 2 であるため、空の
文字列が返されます。 lastMatch は最後の文字列と一致します。$& は同じ意味です。
RegExp 属性、静的、読み取り専用 JavaScript 1.2、NES 3.0 以降で使用可能
説明: lastMatch は静的であるため、個々の正規表現を指定する属性ではありません。 RegExp.lastMatch を使用することもできます。ラストパレン
括弧で囲まれた最後の文字列の一致 (存在する場合)。 $+ も同じ意味です。 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 です。
スクリプトまたはブラウザで複数行属性を設定できます。 textarea イベント ハンドラーが呼び出されると、multiline
が true に設定されます。イベント ハンドラーが処理された後、複数行の属性値はクリアされます。つまり、multiline を true に設定すると、イベント ハンドラーの実行後に multiline は false に設定されます。プロトタイプ
クラスのプロトタイプを説明します。プロトタイプを使用して、要件に応じてクラスのプロパティまたはメソッドを追加できます。プロトタイプの詳細については、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 スラッシュと「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 の値がパラメータとして使用されます
説明: 文字列が特定の正規表現に一致するかどうかを知る必要がある場合は、テスト メソッド (String と同様) を使用できます。 .search メソッド
); より多くの情報を取得するには (ただし速度は遅くなります)、exec メソッド (String.match メソッドと同様) を使用できます。 例: 次の例は、テストが成功したかどうかを示します:
function testinput(re, str){
if (re.test(str)) midring = " contains ";
else midring = " doesn't contain "; write (str + midring + re.source); } toSource
RegExp メソッドは、JavaScript 1.3 以降の構文を提供します: toSource()
パラメーター: 説明なし: toSource メソッドは、次の値: 組み込み RegExp オブジェクトの場合、toSource は、ソース コードが利用できないことを示す次の文字を返します:
function Boolean(){ [ネイティブ コード] }
RegExp の場合、toSource は、通常、このメソッドはコード内で明示的に呼び出すのではなく、JavaScript によって自動的に実行されます。
詳細については、「Object.toSource」を参照してください。 toString は、指定されたオブジェクトを説明する文字列を返します。 RegExp のメソッド
ECMA バージョン ECMA-262 は JavaScript 1.1、NES 2.0 から提供されています 構文: 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()) は "/a+b+c/" を表示します
JS正则表达式大全 
正则表达式在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应用 
-------------------------------------------------------------- 
去掉字符串头尾多余的空格 
/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!=&#39; &#39;) break; 
} 
for(;j>-1;j--){ 
c=str.charAt(j); 
if(c!=&#39; &#39;) 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>