正则表达式（来着马士兵老师的资料）

太过爱你忘了你带给我的痛 2024-02-17 21:03 5阅读 0赞

## JavaScript中的正则表达式解析 ##

http://www.webjx.com 更新日期：2005-10-22 07:20 出处： 作者：

正则表达式是一个描述字符模式的对象。

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;

正则表达式(regular expression)对象包含一个正则表达式模式(pattern)。它具有用正则表达式模式去匹配或代替一个串(string)中特定字符(或字符集 合)的属性(properties)和方法(methods)。要为一个单独的正则表达式添加属性,可以使用正则表达式构造函数(constructor function)，无论何时被调用的预设置的正则表达式拥有静态的属性(the predefined RegExp object has static properties that are set whenever any regular expression is used, 我不知道我翻得对不对，将原文列出，请自行翻译)。

*  创建：  
    一个文本格式或正则表达式构造函数  
    文本格式： /pattern/flags  
    正则表达式构造函数： new RegExp("pattern"\[,"flags"\]);
 *  参数说明：  
    pattern -- 一个正则表达式文本  
    flags -- 如果存在，将是以下值：  
    g: 全局匹配  
    i: 忽略大小写  
    gi: 以上组合

\[注意\] *文本格式的参数不用引号，而在用构造函数时的参数需要引号。如：/ab+c/i new RegExp("ab+c","i")是实现一样的功能。在构造函数中，一些特殊字符需要进行转意(在特殊字符前加"\\")。如：re = new RegExp("\\\\w+")*

正则表达式中的特殊字符

<table> 
 <tbody> 
  <tr> 
   <td> 
    <table> 
     <tbody> 
      <tr> 
       <td align="center">字符</td> 
       <td>含意</td> 
      </tr> 
      <tr> 
       <td>\</td> 
       <td> <p>做为转意，即通常在"\"后面的字符不按原来意义解释，如/b/匹配字符"b"，当b前面加了反斜杆后/\b/，转意为匹配一个单词的边界。<br> -或-<br> 对正则表达式功能字符的还原，如"*"匹配它前面元字符0次或多次，/a*/将匹配a,aa,aaa，加了"\"后，/a\*/将只匹配"a*"。</p> </td> 
      </tr> 
      <tr> 
       <td>^</td> 
       <td>匹配一个输入或一行的开头，/^a/匹配"an A"，而不匹配"An a"</td> 
      </tr> 
      <tr> 
       <td>$</td> 
       <td>匹配一个输入或一行的结尾，/a$/匹配"An a"，而不匹配"an A"</td> 
      </tr> 
      <tr> 
       <td>*</td> 
       <td>匹配前面元字符0次或多次，/ba*/将匹配b,ba,baa,baaa</td> 
      </tr> 
      <tr> 
       <td>+</td> 
       <td>匹配前面元字符1次或多次，/ba*/将匹配ba,baa,baaa</td> 
      </tr> 
      <tr> 
       <td>?</td> 
       <td>匹配前面元字符0次或1次，/ba*/将匹配b,ba</td> 
      </tr> 
      <tr> 
       <td>(x)</td> 
       <td>匹配x保存x在名为$1...$9的变量中</td> 
      </tr> 
      <tr> 
       <td>x|y</td> 
       <td>匹配x或y</td> 
      </tr> 
      <tr> 
       <td>{n}</td> 
       <td>精确匹配n次</td> 
      </tr> 
      <tr> 
       <td>{n,}</td> 
       <td>匹配n次以上</td> 
      </tr> 
      <tr> 
       <td>{n,m}</td> 
       <td>匹配n-m次</td> 
      </tr> 
      <tr> 
       <td>[xyz]</td> 
       <td>字符集(character set)，匹配这个集合中的任一一个字符(或元字符)</td> 
      </tr> 
      <tr> 
       <td>[^xyz]</td> 
       <td>不匹配这个集合中的任何一个字符</td> 
      </tr> 
      <tr> 
       <td>[\b]</td> 
       <td>匹配一个退格符</td> 
      </tr> 
      <tr> 
       <td>\b</td> 
       <td>匹配一个单词的边界</td> 
      </tr> 
      <tr> 
       <td>\B</td> 
       <td>匹配一个单词的非边界</td> 
      </tr> 
      <tr> 
       <td>\cX</td> 
       <td>这儿，X是一个控制符，/\cM/匹配Ctrl-M</td> 
      </tr> 
      <tr> 
       <td>\d</td> 
       <td>匹配一个字数字符，/\d/ = /[0-9]/</td> 
      </tr> 
      <tr> 
       <td>\D</td> 
       <td>匹配一个非字数字符，/\D/ = /[^0-9]/</td> 
      </tr> 
      <tr> 
       <td>\n</td> 
       <td>匹配一个换行符</td> 
      </tr> 
      <tr> 
       <td>\r</td> 
       <td>匹配一个回车符</td> 
      </tr> 
      <tr> 
       <td>\s</td> 
       <td>匹配一个空白字符，包括\n,\r,\f,\t,\v等</td> 
      </tr> 
      <tr> 
       <td>\S</td> 
       <td>匹配一个非空白字符，等于/[^\n\f\r\t\v]/</td> 
      </tr> 
      <tr> 
       <td>\t</td> 
       <td>匹配一个制表符</td> 
      </tr> 
      <tr> 
       <td>\v</td> 
       <td>匹配一个重直制表符</td> 
      </tr> 
      <tr> 
       <td>\w</td> 
       <td>匹配一个可以组成单词的字符(alphanumeric，这是我的意译，含数字)，包括下划线，如[\w]匹配"$5.98"中的5，等于[a-zA-Z0-9]</td> 
      </tr> 
      <tr> 
       <td>\W</td> 
       <td>匹配一个不可以组成单词的字符，如[\W]匹配"$5.98"中的$，等于[^a-zA-Z0-9]。</td> 
      </tr> 
     </tbody> 
    </table> </td> 
  </tr> 
 </tbody> 
</table>

说了这么多了，我们来看一些正则表达式的实际应用的例子：

> E-mail地址验证:  
> function test\_email(strEmail) \{  
> var myReg = /^\[\_a-z0-9\]+@(\[\_a-z0-9\]+\\.)+\[a-z0-9\]\{2,3\}$/;  
> if(myReg.test(strEmail)) return true;  
> return false;  
> \}  
> HTML代码的屏蔽  
> function mask\_HTMLCode(strInput) \{  
> var myReg = /<(\\w+)>/;  
> return strInput.replace(myReg, "<$1>");  
> \}
> 
> **正则表达式对象的属性及方法**  
> 　 　预定义的正则表达式拥有有以下静态属性：input, multiline, lastMatch, lastParen, leftContext, rightContext和$1到$9。其中input和multiline可以预设置。其他属性的值在执行过exec或test方法后被根据不同条件赋 以不同的值。许多属性同时拥有长和短(perl风格)的两个名字，并且，这两个名字指向同一个值。(JavaScript模拟perl的正则表达式)  
> 正则表达式对象的属性
> 
> <table> 
>  <tbody> 
>   <tr> 
>    <td> 
>     <table> 
>      <tbody> 
>       <tr> 
>        <td align="center">属性</td> 
>        <td>含义</td> 
>       </tr> 
>       <tr> 
>        <td>$1...$9</td> 
>        <td>如果它(们)存在，是匹配到的子串</td> 
>       </tr> 
>       <tr> 
>        <td>$_</td> 
>        <td>参见input</td> 
>       </tr> 
>       <tr> 
>        <td>$*</td> 
>        <td>参见multiline</td> 
>       </tr> 
>       <tr> 
>        <td>$&amp;</td> 
>        <td>参见lastMatch</td> 
>       </tr> 
>       <tr> 
>        <td>$+</td> 
>        <td>参见lastParen</td> 
>       </tr> 
>       <tr> 
>        <td>$`</td> 
>        <td>参见leftContext</td> 
>       </tr> 
>       <tr> 
>        <td>$’</td> 
>        <td>参见rightContext</td> 
>       </tr> 
>       <tr> 
>        <td>constructor</td> 
>        <td>创建一个对象的一个特殊的函数原型</td> 
>       </tr> 
>       <tr> 
>        <td>global</td> 
>        <td>是否在整个串中匹配(bool型)</td> 
>       </tr> 
>       <tr> 
>        <td>ignoreCase</td> 
>        <td>匹配时是否忽略大小写(bool型)</td> 
>       </tr> 
>       <tr> 
>        <td>input</td> 
>        <td>被匹配的串</td> 
>       </tr> 
>       <tr> 
>        <td>lastIndex</td> 
>        <td>最后一次匹配的索引</td> 
>       </tr> 
>       <tr> 
>        <td>lastParen</td> 
>        <td>最后一个括号括起来的子串</td> 
>       </tr> 
>       <tr> 
>        <td>leftContext</td> 
>        <td>最近一次匹配以左的子串</td> 
>       </tr> 
>       <tr> 
>        <td>multiline</td> 
>        <td>是否进行多行匹配(bool型)</td> 
>       </tr> 
>       <tr> 
>        <td>prototype</td> 
>        <td>允许附加属性给对象</td> 
>       </tr> 
>       <tr> 
>        <td>rightContext</td> 
>        <td>最近一次匹配以右的子串</td> 
>       </tr> 
>       <tr> 
>        <td>source</td> 
>        <td>正则表达式模式</td> 
>       </tr> 
>       <tr> 
>        <td>lastIndex</td> 
>        <td>最后一次匹配的索引</td> 
>       </tr> 
>      </tbody> 
>     </table> </td> 
>   </tr> 
>  </tbody> 
> </table>
> 
>   
> **正则表达式对象的方法**  
> 
> 
> <table> 
>  <tbody> 
>   <tr> 
>    <td> 
>     <table> 
>      <tbody> 
>       <tr> 
>        <td align="center">方法</td> 
>        <td>含义</td> 
>       </tr> 
>       <tr> 
>        <td>compile</td> 
>        <td>正则表达式比较</td> 
>       </tr> 
>       <tr> 
>        <td>exec</td> 
>        <td>执行查找</td> 
>       </tr> 
>       <tr> 
>        <td>test</td> 
>        <td>进行匹配</td> 
>       </tr> 
>       <tr> 
>        <td>toSource</td> 
>        <td>返回特定对象的定义(literal representing)，其值可用来创建一个新的对象。重载Object.toSource方法得到的。</td> 
>       </tr> 
>       <tr> 
>        <td>toString</td> 
>        <td>返回特定对象的串。重载Object.toString方法得到的。</td> 
>       </tr> 
>       <tr> 
>        <td>valueOf</td> 
>        <td>返回特定对象的原始值。重载Object.valueOf方法得到</td> 
>       </tr> 
>      </tbody> 
>     </table> </td> 
>   </tr> 
>  </tbody> 
> </table>
> 
> 例子  
> <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"