JavaScript RegExp 正则表达式对象详细说明
RegExp 对象表示正则表达式，它是对字符串执行模式匹配的强大工具。<br /><strong>直接量语法 </strong><br />
<br />
/pattern/attributes <br />
<br />
创建 RegExp 对象的语法： <br />
var obj=new RegExp(pattern,attributes); <br />
<br />
<strong>事例1： </strong><br />
var pattern=/a/; <br />
document.write(pattern.exec("asdas")); <br />
<br />
<strong>事例2：</strong> <br />
var obj=new RegExp("a"); <br />
document.write(obj.exec("asdas")); <br />
<br />
<br />
事例1和事例2的执行结果是相同的； <br />
<strong>参数 </strong><br />
参数 pattern 是一个字符串，指定了正则表达式的模式或其他正则表达式。 <br />
<br />
参数 attributes 是一个可选的字符串，包含属性 "g"(执行全局匹配查找所有匹配而非在找到第一个匹配后停止。)、"i":执行对大小写不敏感的匹配。 和 "m":执行多行匹配。，分别用于指定全局匹配、区分大小写的匹配和多行匹配。ECMAScript 标准化之前，不支持 m 属性。如果 pattern 是正则表达式，而不是字符串，则必须省略该参数。 <br />
<br />
<strong>返回值 </strong><br />
一个新的 RegExp 对象，具有指定的模式和标志。如果参数 pattern 是正则表达式而不是字符串，那么 RegExp() 构造函数将用与指定的 RegExp 相同的模式和标志创建一个新的 RegExp 对象。 <br />
<br />
如果不用 new 运算符，而将 RegExp() 作为函数调用，那么它的行为与用 new 运算符调用时一样，只是当pattern 是正则表达式时，它只返回 pattern，而不再创建一个新的 RegExp 对象。 <br />
<br />
<strong>抛出 </strong><br />
SyntaxError - 如果 pattern 不是合法的正则表达式，或 attributes 含有 "g"、"i" 和 "m" 之外的字符，抛出该异常。 <br />
<br />
TypeError - 如果 pattern 是 RegExp 对象，但没有省略 attributes 参数，抛出该异常。<br />
<br />
<strong>RegExp 对象方法: </strong><br />
1、test():检索字符串中指定的值。返回 true 或 false。 <br />
var patt1=new RegExp("e"); <br />
document.write(patt1.test("The best things in life are free")); <br />
<br />
2、exec():检索字符串中指定的值。返回找到的值，并确定其位置。 <br />
方法检索字符串中的指定值。返回值是被找到的值。如果没有发现匹配，则返回 null。<br />
<br />
3、compile():既可以改变检索模式，也可以添加或删除第二个参数。 <br />
var patt1=new RegExp("e"); <br />
document.write(patt1.test("The best things in life are free")); <br />
patt1.compile("d"); <br />
document.write(patt1.test("The best things in life are free")); <br />
<br />
修饰符: <br />
<br />
1、g:执行全局匹配查找所有匹配而非在找到第一个匹配后停止; <br />
在使用 "g" 参数时，exec() 的工作原理如下： <br />
找到第一个 "e"，并存储其位置 <br />
如果再次运行 exec()，则从存储的位置开始检索，并找到下一个 "e"，并存储其位置 <br />
var patt1=new RegExp("e","g"); <br />
do <br />
{ <br />
result=patt1.exec("The best things in life are free"); <br />
document.write(result); <br />
} <br />
while (result!=null) <br />
<br />
<strong>RegExp 对象属性 </strong><br />
1:global:RegExp 对象是否具有标志 g。 <br />
2:ignoreCase:RegExp 对象是否具有标志 i。 <br />
3:lastIndex:一个整数，标示开始下一次匹配的字符起始位置。 <br />
4:multiline:RegExp 对象是否具有标志 m; <br />
5:source:正则表达式的源文本。 <br />
<br />
var obj=new RegExp(/s/); <br />
document.write(obj.source); <br />
<br />
<strong>支持正则表达式的 String 对象的方法 </strong><br />
1：search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。 <br />
忽略大小写事例： <br />
<script type="text/javascript"> <br />
var str="Visit W3School!" <br />
document.write(str.search(/w3school/i)) <br />
</script> <br />
<h3>返回值</h3>
<p>stringObject 中第一个与 regexp 相匹配的子串的起始位置。</p>
<p>注释：如果没有找到任何匹配的子串，则返回 -1。</p>
<h3>说明</h3>
<p>search() 方法不执行全局匹配，它将忽略标志 g。它同时忽略 regexp 的 lastIndex 属性，并且总是从字符串的开始进行检索，这意味着它总是返回 stringObject 的第一个匹配的位置。</p>
<p>2：match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。该方法类似 indexOf() 和 lastIndexOf()，但是它返回指定的值，而不是字符串的位置。</p>
<h3>返回值</h3>
<p>存放匹配结果的数组。该数组的内容依赖于 regexp 是否具有全局标志 g。</p>
<h3>说明</h3>
<p>match() 方法将检索字符串 stringObject，以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g。</p>
<p>如果 regexp 没有标志 g，那么 match() 方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本， match() 将返回 null。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。该数组的第 0 个元素存放的是匹配文本，而其余的元素存放的是与正则表达式的子表达式匹配的文本。除了这些常规的数组元素之外，返回的数组还含有两个对象属性。index 属性声明的是匹配文本的起始字符在 stringObject 中的位置，input 属性声明的是对 stringObject 的引用。</p>
<p>如果 regexp 具有标志 g，则 match() 方法将执行全局检索，找到 stringObject 中的所有匹配子字符串。若没有找到任何匹配的子串，则返回 null。如果找到了一个或多个匹配子串，则返回一个数组。不过全局匹配返回的数组的内容与前者大不相同，它的数组元素中存放的是 stringObject 中所有的匹配子串，而且也没有 index 属性或 input 属性。</p>
<p>注意：在全局检索模式下，match() 即不提供与子表达式匹配的文本的信息，也不声明每个匹配子串的位置。如果您需要这些全局检索的信息，可以使用 RegExp.exec()。</p>
<p>参数为字符串的事例：</p>
var str="Hello world!" <br />
document.write(str.match("world") + "<br />") <br />
<br />
参数为正则表达式的事例： <br />
var str="1 plus 2 equal 3" <br />
document.write(str.match(/\d+/g)) <br />
<br />
3：replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。
<p> </p>
<pre>
stringObject.replace(<em>regexp/substr</em>,<em>replacement</em>) </pre>
<table border="1">
<tbody>
<tr>
<th>参数</th>
<th>描述</th>
</tr>
<tr>
<td>regexp/substr</td>
<td>
<p>必需。规定子字符串或要替换的模式的 RegExp 对象。</p>
<p>请注意，如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象。</p>
</td>
</tr>
<tr>
<td>replacement</td>
<td>必需。一个字符串值。规定了替换文本或生成替换文本的函数。</td>
</tr>
</tbody>
</table>
<h3>返回值</h3>
<p>一个新的字符串，是用 <em>replacement</em> 替换了 regexp 的第一次匹配或所有匹配之后得到的。</p>
<h3>说明</h3>
<p>字符串 stringObject 的 replace() 方法执行的是查找并替换的操作。它将在 stringObject 中查找与 regexp 相匹配的子字符串，然后用 <em>replacement</em> 来替换这些子串。如果 regexp 具有全局标志 g，那么 replace() 方法将替换所有匹配的子串。否则，它只替换第一个匹配子串。</p>
<p><em>replacement</em> 可以是字符串，也可以是函数。如果它是字符串，那么每个匹配都将由字符串替换。但是 replacement 中的 $ 字符具有特定的含义。如下表所示，它说明从模式匹配得到的字符串将用于替换。</p>
<table border="1">
<tbody>
<tr>
<th>字符</th>
<th>替换文本</th>
</tr>
<tr>
<td>$1、$2、...、$99</td>
<td>与 regexp 中的第 1 到第 99 个子表达式相匹配的文本。</td>
</tr>
<tr>
<td>$&</td>
<td>与 regexp 相匹配的子串。</td>
</tr>
<tr>
<td>$`</td>
<td>位于匹配子串左侧的文本。</td>
</tr>
<tr>
<td>$'</td>
<td>位于匹配子串右侧的文本。</td>
</tr>
<tr>
<td>$$</td>
<td>直接量符号。</td>
</tr>
</tbody>
</table>
<p>注意：ECMAScript v3 规定，replace() 方法的参数 replacement 可以是函数而不是字符串。在这种情况下，每个匹配都调用该函数，它返回的字符串将作为替换文本使用。该函数的第一个参数是匹配模式的字符串。接下来的参数是与模式中的子表达式匹配的字符串，可以有 0 个或多个这样的参数。接下来的参数是一个整数，声明了匹配在 stringObject 中出现的位置。最后一个参数是 stringObject 本身。</p>
字符串替换：<br />
var str="Visit Microsoft!"<br />
document.write(str.replace(/Microsoft/, "W3School"))<br />
<br />
全局替换：<br />
var str="Welcome to Microsoft! "<br />
str=str + "We are proud to announce that Microsoft has "<br />
str=str + "one of the largest Web Developers sites in the world."<br />
document.write(str.replace(/Microsoft/g, "W3School"))<br />
<br />
返回的结果：Welcome to W3School! We are proud to announce that W3Schoolhas one of the largest Web Developers sites in the world.使用正则表达式：<br />
name = '"a", "b"';<br />
name.replace(/"([^"]*)"/g, "'$1'");<br />
<br />
使用函数：<br />
name = 'aaa bbb ccc';<br />
uw=name.replace(/\b\w+\b/g, function(word){<br />
return word.substring(0,1).toUpperCase()+word.substring(1);}<br />
);<br />
<br />
<strong>4：split() 方法用于把一个字符串分割成字符串数组。</strong>
<h3>语法</h3>
<pre>
stringObject.split(<em>separator</em>,<em>howmany</em>)</pre>
<table border="1" style="width:100%">
<tbody>
<tr>
<th>参数</th>
<th>描述</th>
</tr>
<tr>
<td>separator</td>
<td>必需。字符串或正则表达式，从该参数指定的地方分割 stringObject。</td>
</tr>
<tr>
<td>howmany</td>
<td>可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。</td>
</tr>
</tbody>
</table>
<h3>返回值</h3>
<p>一个字符串数组。该数组是通过在 <em>separator</em> 指定的边界处将字符串 stringObject 分割成子串创建的。返回的数组中的字串不包括 <em>separator</em> 自身。</p>
<p>但是，如果 <em>separator</em> 是包含子表达式的正则表达式，那么返回的数组中包括与这些子表达式匹配的字串（但不包括与整个正则表达式匹配的文本）。</p>
<br />
<h2>提示和注释</h2>
<p>注释：如果把空字符串 ("") 用作 <em>separator</em>，那么 stringObject 中的每个字符之间都会被分割。</p>
<p>注释：String.split() 执行的操作与 Array.join 执行的操作是相反的。</p>
<h2>修饰符</h2>
<table border="1" style="width:100%">
<tbody>
<tr>
<th>修饰符</th>
<th>描述</th>
</tr>
<tr>
<td>i</td>
<td>执行对大小写不敏感的匹配。</td>
</tr>
<tr>
<td>g</td>
<td>执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）。</td>
</tr>
<tr>
<td>m</td>
<td>执行多行匹配。</td>
</tr>
</tbody>
</table>
<br />
<br />
<h2>方括号</h2>
<p>方括号用于查找某个范围内的字符：</p>
<table border="1" style="width:100%">
<tbody>
<tr>
<th>表达式</th>
<th>描述</th>
</tr>
<tr>
<td></td>
<td>查找方括号之间的任何字符。</td>
</tr>
<tr>
<td>[^abc]</td>
<td>查找任何不在方括号之间的字符。</td>
</tr>
<tr>
<td></td>
<td>查找任何从 0 至 9 的数字。</td>
</tr>
<tr>
<td></td>
<td>查找任何从小写 a 到小写 z 的字符。</td>
</tr>
<tr>
<td></td>
<td>查找任何从大写 A 到大写 Z 的字符。</td>
</tr>
<tr>
<td></td>
<td>查找任何从小写 a 到大写 Z 的字符。</td>
</tr>
<tr>
<td></td>
<td>查找给定集合内的任何字符。</td>
</tr>
<tr>
<td>[^adgk]</td>
<td>查找给定集合外的任何字符。</td>
</tr>
<tr>
<td></td>
<td>查找任何指定的选项。</td>
</tr>
</tbody>
</table>
<br />
<br />
<h2>元字符</h2>
<p>元字符（Metacharacter）是拥有特殊含义的字符：</p>
<table border="1" style="width:100%">
<tbody>
<tr>
<th>元字符</th>
<th>描述</th>
</tr>
<tr>
<td>.</td>
<td>查找单个字符，除了换行和行结束符。</td>
</tr>
<tr>
<td>\w</td>
<td>查找单词字符。</td>
</tr>
<tr>
<td>\W</td>
<td>查找非单词字符。</td>
</tr>
<tr>
<td>\d</td>
<td>查找数字。</td>
</tr>
<tr>
<td>\D</td>
<td>查找非数字字符。</td>
</tr>
<tr>
<td>\s</td>
<td>查找空白字符。</td>
</tr>
<tr>
<td>\S</td>
<td>查找非空白字符。</td>
</tr>
<tr>
<td>\b</td>
<td>查找位于单词的开头或结尾的匹配。</td>
</tr>
<tr>
<td>\B</td>
<td>查找不处在单词的开头或结尾的匹配。</td>
</tr>
<tr>
<td>\0</td>
<td>查找 NUL 字符。</td>
</tr>
<tr>
<td>\n</td>
<td>查找换行符。</td>
</tr>
<tr>
<td>\f</td>
<td>查找换页符。</td>
</tr>
<tr>
<td>\r</td>
<td>查找回车符。</td>
</tr>
<tr>
<td>\t</td>
<td>查找制表符。</td>
</tr>
<tr>
<td>\v</td>
<td>查找垂直制表符。</td>
</tr>
<tr>
<td>\xxx</td>
<td>查找以八进制数 xxx 规定的字符。</td>
</tr>
<tr>
<td>\xdd</td>
<td>查找以十六进制数 dd 规定的字符。</td>
</tr>
<tr>
<td>\uxxxx</td>
<td>查找以十六进制数 xxxx 规定的 Unicode 字符。</td>
</tr>
</tbody>
</table>
<br />
<br />
<h2>量词</h2>
<table border="1" style="width:100%">
<tbody>
<tr>
<th>量词</th>
<th>描述</th>
</tr>
<tr>
<td>n+</td>
<td>匹配任何包含至少一个 n 的字符串。</td>
</tr>
<tr>
<td>n*</td>
<td>匹配任何包含零个或多个 n 的字符串。</td>
</tr>
<tr>
<td>n?</td>
<td>匹配任何包含零个或一个 n 的字符串。</td>
</tr>
<tr>
<td>n{X}</td>
<td>匹配包含 X 个 n 的序列的字符串。</td>
</tr>
<tr>
<td>n{X,Y}</td>
<td>匹配包含 X 或 Y 个 n 的序列的字符串。</td>
</tr>
<tr>
<td>n{X,}</td>
<td>匹配包含至少 X 个 n 的序列的字符串。</td>
</tr>
<tr>
<td>n$</td>
<td>匹配任何结尾为 n 的字符串。</td>
</tr>
<tr>
<td>^n</td>
<td>匹配任何开头为 n 的字符串。</td>
</tr>
<tr>
<td>?=n</td>
<td>匹配任何其后紧接指定字符串 n 的字符串。</td>
</tr>
<tr>
<td>?!n</td>
<td>匹配任何其后没有紧接指定字符串 n 的字符串。</td>
</tr>
</tbody>
</table>
<p><br />
<a href="https://www.jb51.net/w3school/js/jsref_obj_regexp.htm" target="_blank">JavaScript RegExp 对象参考手册</a></p>
<p> </p>
<p>源文地址：https://www.jb51.net/article/25611.htm</p>
页:
[1]