JavaScript RegExp 对象

ゝ一世哀愁。 2023-10-06 22:44 42阅读 0赞

#### 阅读目录 ####

*  RegExp 对象
 *   *  修饰符
     *   *  JavaScript RegExp i 修饰符
         *  JavaScript RegExp g 修饰符
     *  方括号
     *   *  JavaScript RegExp \[abc\] 表达式
         *  JavaScript RegExp \[^abc\] 表达式
     *  元字符
     *   *  JavaScript RegExp . 元字符
         *  JavaScript RegExp \\w 元字符
         *  JavaScript RegExp \\W 元字符
         *  JavaScript RegExp \\d 元字符
         *  JavaScript RegExp \\D 元字符
         *  JavaScript RegExp \\s 元字符
         *  JavaScript RegExp \\S 元字符
         *  JavaScript RegExp \\b 元字符
         *  JavaScript RegExp \\B 元字符
         *  JavaScript RegExp \\n 元字符
         *  JavaScript RegExp \\xxx 元字符
         *  JavaScript RegExp \\xdd 元字符
         *  JavaScript RegExp \\uxxxx 元字符
     *  量词
     *   *  JavaScript RegExp + 量词
         *  JavaScript RegExp \* 量词
         *  JavaScript RegExp ? 量词
         *  JavaScript RegExp \{X\} 量词
         *  JavaScript RegExp \{X,\} 量词
         *  JavaScript RegExp \{X,Y\} 量词
         *  JavaScript RegExp $ 量词
         *  JavaScript RegExp ^ 量词
         *  JavaScript RegExp ?= 量词
         *  JavaScript RegExp ?! 量词
     *  RegExp 对象方法
     *   *  JavaScript RegExp toString() 方法
     *  支持正则表达式的 String 对象的方法
     *   *  JavaScript RegExp search() 方法
         *  JavaScript RegExp match() 方法
         *  JavaScript RegExp replace() 方法
         *  JavaScript RegExp split() 方法
     *  RegExp 对象属性
     *   *  JavaScript RegExp constructor 属性
         *  JavaScript RegExp global 属性
         *  JavaScript RegExp ignoreCase 属性
         *  JavaScript RegExp lastIndex 属性
         *  JavaScript RegExp multiline 属性
         *  JavaScript RegExp source 属性

## RegExp 对象 ##

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

正则表达式用于对字符串模式匹配及检索替换，是对字符串执行模式匹配的强大工具。

语法

var patt=new RegExp(pattern,modifiers);
    
    或者更简单的方式:
    
    var patt=/pattern/modifiers;

pattern（模式） 描述了表达式的模式  
modifiers(修饰符) 用于指定全局匹配、区分大小写的匹配和多行匹配

注意：当使用构造函数创造正则对象时，需要常规的字符转义规则（在前面加反斜杠 `\`）。

比如，以下是等价的：

var re = new RegExp("\\w+");
    var re = /\w+/;

### 修饰符 ###

修饰符用于执行区分大小写和全局匹配:

<table> 
 <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>

#### JavaScript RegExp i 修饰符 ####

定义和用法  
`i` 修饰符用于执行对大小写不敏感的匹配。

语法

new RegExp("regexp","i")
    
    或者更简单方式：
    
    /regexp/i

浏览器支持  
所有主要浏览器都支持 `i` 修饰符。

实例  
对字符串中的 `“WillEm”` 进行不分大小写的搜索：

#### JavaScript RegExp g 修饰符 ####

定义和用法  
`g` 修饰符用于执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）。

语法

new RegExp("regexp","g")
    
    或者更简单方式：
    
    /regexp/g

浏览器支持  
所有主要浏览器都支持 `g` 修饰符

实例 1  
对 `“is”` 进行全局搜索：

实例 2  
对 `“is”` 进行全局且大小写不敏感的搜索：

### 方括号 ###

方括号用于查找某个范围内的字符：

<table> 
 <tbody> 
  <tr> 
   <th>表达式</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td> [abc] </td> 
   <td>查找方括号之间的任何字符。</td> 
  </tr> 
  <tr> 
   <td> [^abc] </td> 
   <td>查找任何不在方括号之间的字符。</td> 
  </tr> 
  <tr> 
   <td>[0-9]</td> 
   <td>查找任何从 0 至 9 的数字。</td> 
  </tr> 
  <tr> 
   <td>[a-z]</td> 
   <td>查找任何从小写 a 到小写 z 的字符。</td> 
  </tr> 
  <tr> 
   <td>[A-Z]</td> 
   <td>查找任何从大写 A 到大写 Z 的字符。</td> 
  </tr> 
  <tr> 
   <td>[A-z]</td> 
   <td>查找任何从大写 A 到小写 z 的字符。</td> 
  </tr> 
  <tr> 
   <td>[adgk]</td> 
   <td>查找给定集合内的任何字符。</td> 
  </tr> 
  <tr> 
   <td>[^adgk]</td> 
   <td>查找给定集合外的任何字符。</td> 
  </tr> 
  <tr> 
   <td>(red|blue|green)</td> 
   <td>查找任何指定的选项。</td> 
  </tr> 
 </tbody> 
</table>

#### JavaScript RegExp \[abc\] 表达式 ####

定义和用法  
`[abc]` 表达式用于查找方括号之间的任何字符。

方括号内的字符可以是任何字符或字符范围。

语法

new RegExp("[abc]")
    
    或者更简单方式：
    
    /[abc]/

实例  
在字符串中对字符范围 `[a-h]` 进行全局搜索：

#### JavaScript RegExp \[^abc\] 表达式 ####

定义和用法  
`[^abc]` 表达式用于查找任何不在方括号之间的字符。

方括号内的字符可以是任何字符或字符范围。

语法

new RegExp("[^xyz]")
    
    或者更简单方式：
    
    /[^xyz]/

实例  
对不在字符范围 `[^a-h]` 内的字符进行全局搜索：

### 元字符 ###

元字符（Metacharacter）是拥有特殊含义的字符：

<table> 
 <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>查找 NULL 字符。</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>

#### JavaScript RegExp . 元字符 ####

定义和用法  
`.` 元字符用于查找单个字符，除了换行和行结束符。

语法

new RegExp("regexp.")
    
    或者更简单方式：
    
    /regexp./

实例  
对字符串中的 `“h.t”` 进行全局搜索：

#### JavaScript RegExp \\w 元字符 ####

定义和用法  
`\w` 元字符用于查找单词字符。

单词字符包括：`a-z、A-Z、0-9`，以及下划线, 包含 \_ (下划线) 字符。

语法

new RegExp("\w")
    
    或者更简单方式：
    
    /\w/

实例  
对字符串中的单词字符进行全局搜索：

#### JavaScript RegExp \\W 元字符 ####

定义和用法  
`\W` 元字符用于查找非单词字符。

单词字符包括：`a-z、A-Z、0-9`，以及下划线。

语法

new RegExp("\W")
    
    或者更简单方式：
    
    /\W/

实例  
对字符串中的非单词字符进行全局搜索：

#### JavaScript RegExp \\d 元字符 ####

定义和用法  
`\d` 元字符用于查找数字字符。

语法

new RegExp("\\d")
    
    或者更简单方式：
    
    /\d/

使用修饰符：

new RegExp("\\d", "g")
    
    或者更简单方式：
    
    /\d/g

实例  
对数字进行全局搜索：

#### JavaScript RegExp \\D 元字符 ####

定义和用法  
`\D` 元字符用于查找非数字字符。

语法

new RegExp("\D")
    
    或者更简单方式：
    
    /\D/

实例  
对字符串中的非数字字符进行全局搜索：

#### JavaScript RegExp \\s 元字符 ####

定义和用法  
`\s` 元字符用于查找空白字符。

空白字符可以是：

空格符 (space character)
    制表符 (tab character)
    回车符 (carriage return character)
    换行符 (new line character)
    垂直换行符 (vertical tab character)
    换页符 (form feed character)

语法

new RegExp("\s")
    
    或者更简单方式：
    
    /\s/

实例  
对字符串中的空白字符进行全局搜索：

#### JavaScript RegExp \\S 元字符 ####

定义和用法  
`\S` 元字符用于查找非空白字符。

空白字符可以是：

语法

new RegExp("\S")
    
    或者更简单方式：
    
    /\S/

实例  
对字符串中的非空白字符进行全局搜索：

#### JavaScript RegExp \\b 元字符 ####

定义和用法

`\b` 元字符匹配单词边界。  
`\b` 元字符通常用于查找位于单词的开头或结尾的匹配。

语法

new RegExp("\bregexp")
    
    或者更简单方式：
    
    /\bregexp/

实例  
对字符串中的单词的开头或结尾进行 `“My”` 的全局搜索：

#### JavaScript RegExp \\B 元字符 ####

定义和用法

`\B` 元字符匹配非单词边界。  
匹配位置的上一个和下一个字符的类型是相同的：  
即必须同时是单词，或必须同时是非单词字符。字符串的开头和结尾处被视为非单词字符。

如果未找到匹配，则返回 `null`。

语法

new RegExp(" \Bregexp")
    
    或者更简单方式：
    
    /\Bregexp/

实例  
对字符串中不位于单词开头或结尾的 `“ybj”` 进行全局搜索：

#### JavaScript RegExp \\n 元字符 ####

定义和用法

`\n` 元字符用于查找换行符。  
`\n` 返回换行符被找到的位置。如果未找到匹配，则返回 `-1`。

语法

new RegExp("\n")
    
    或者更简单方式：
    
    /\n/

实例  
搜索字符串中的换行字符：

#### JavaScript RegExp \\xxx 元字符 ####

定义和用法

`\xxx` 元字符用于查找以八进制数 xxx 规定的字符。  
如果未找到匹配，则返回 `null`。

语法

new RegExp("\xxx")
    
    或者更简单方式：
    
    /\xxx/

实例  
对字符串中的八进制 `127 (W)` 进行全局搜索：

#### JavaScript RegExp \\xdd 元字符 ####

定义和用法

`\xdd` 元字符查找以十六进制数 dd 规定的字符。  
如果未找到匹配，则返回 `null`。

语法

new RegExp("\xdd")
    
    或者更简单方式：
    
    /\xdd/

实例  
对字符串中的十六进制 `57 (W)` 进行全局搜索：

#### JavaScript RegExp \\uxxxx 元字符 ####

定义和用法

`\uxxxx` 元字符用于查找以十六进制数 xxxx 规定的 Unicode 字符。

如果未找到匹配，则返回 `null`。

实例  
对字符串中的十六进制 `0057 (W)` 进行全局搜索：

### 量词 ###

<table> 
 <tbody> 
  <tr> 
   <th>量词</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td> n+ </td> 
   <td>匹配任何包含至少一个 n 的字符串。 <p></p> <p>&nbsp;</p> <p>例如，/a+/ 匹配 “candy” 中的 “a”，”caaaaaaandy” 中所有的 “a”。</p> </td> 
  </tr> 
  <tr> 
   <td> n* </td> 
   <td>匹配任何包含零个或多个 n 的字符串。 <p></p> <p>例如，/bo*/ 匹配 “A ghost booooed” 中的 “boooo”，”A bird warbled” 中的 “b”，但是不匹配 “A goat grunted”。</p> </td> 
  </tr> 
  <tr> 
   <td> n? </td> 
   <td>匹配任何包含零个或一个 n 的字符串。 <p></p> <p>例如，/e?le?/ 匹配 “angel” 中的 “el”，”angle” 中的 “le”。</p> </td> 
  </tr> 
  <tr> 
   <td> n{X} </td> 
   <td>匹配包含 X 个 n 的序列的字符串。 <p></p> <p>例如，/a{2}/ 不匹配 “candy,” 中的 “a”，但是匹配 “caandy,” 中的两个 “a”，且匹配 “caaandy.” 中的前两个 “a”。</p> </td> 
  </tr> 
  <tr> 
   <td> n{X,} </td> 
   <td>X 是一个正整数。前面的模式 n 连续出现至少 X 次时匹配。 <p></p> <p>例如，/a{2,}/ 不匹配 “candy” 中的 “a”，但是匹配 “caandy” 和 “caaaaaaandy.” 中所有的 “a”。</p> </td> 
  </tr> 
  <tr> 
   <td> n{X,Y} </td> 
   <td>X 和 Y 为正整数。前面的模式 n 连续出现至少 X 次，至多 Y 次时匹配。 <p></p> <p>例如，/a{1,3}/ 不匹配 “cndy”，匹配 “candy,” 中的 “a”，”caandy,” 中的两个 “a”，匹配 “caaaaaaandy” 中的前面三个 “a”。注意，当匹配 “caaaaaaandy” 时，即使原始字符串拥有更多的 “a”，匹配项也是 “aaa”。</p> </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>

#### JavaScript RegExp + 量词 ####

定义和用法  
`n+` 量词匹配包含至少一个 n 的任何字符串。

语法

new RegExp("n+")
    
    或者更简单方式：
    
    /n+/

实例 1  
对至少一个 `“o”` 进行全局搜索：

#### JavaScript RegExp \* 量词 ####

定义和用法  
`n*` 量词匹配包含零个或多个 n 的任何字符串。

语法

new RegExp("n*")
    
    或者更简单方式：
    
    /n*/

实例 1  
对 `“l”` 进行全局搜索，包括其后紧跟的一个或多个 `“o”：`

实例 2  
对 `“1”` 进行全局搜索，包括其后紧跟的一个或多个 `“0”：`

#### JavaScript RegExp ? 量词 ####

定义和用法  
`n?` 量词匹配任何包含零个或一个 n 的字符串。

语法

new RegExp("n?")
    
    或者更简单方式：
    
    /n?/

实例  
对 `“1”` 进行全局搜索，包括其后紧跟的零个或一个 `“0”：`

#### JavaScript RegExp \{X\} 量词 ####

定义和用法  
`n{X}` 量词匹配包含 X 个 n 的序列的字符串。

X 必须是数字。

语法

new RegExp("n{X}")
    
    或者更简单方式：
    
    /n{
        X}/

实例  
对包含四位数字序列的子串进行全局搜索：

#### JavaScript RegExp \{X,\} 量词 ####

定义和用法  
`n{X,}` 量词匹配包含至少 X 个 n 的序列的字符串。

X 必须是数字。

语法

new RegExp("n{X,}")
    
    或者更简单方式：
    
    /n{
        X,}/

实例  
对包含至少三位数字序列的子串进行全局搜索：

#### JavaScript RegExp \{X,Y\} 量词 ####

定义和用法  
`n{X,Y}` 量词匹配包含至少 X 最多Y 个 n 的序列的字符串，X 和 Y 必须是数字。

语法

new RegExp("n{X,Y}")
    
    或者更简单方式：
    
    /n{
        X,Y}/

实例  
对包含三位或四位数字序列的子串进行全局搜索：

#### JavaScript RegExp $ 量词 ####

定义和用法  
`n$` 量词匹配任何结尾为 n 的字符串。

语法

new RegExp("n$")
    
    或者
    
    /n$/

实例  
对字符串结尾的 `“is”` 进行全局搜索：:

#### JavaScript RegExp ^ 量词 ####

定义和用法  
`^n` 量词匹配任何开头为 n 的字符串。

语法

new RegExp("^n")
    
    或者
    
    /^n/

实例  
对字符串开头的 `“Is”` 进行全局搜索：

#### JavaScript RegExp ?= 量词 ####

定义和用法  
`?=n` 量词匹配任何其后紧接指定字符串 n 的字符串。

语法

new RegExp("regexp(?=n)")
    
    或者
    
    /regexp(?=n)/

实例  
对其后紧跟 `“all”` 的 `“is”` 进行全局搜索：

#### JavaScript RegExp ?! 量词 ####

定义和用法  
`?!n` 量词匹配其后没有紧接指定字符串 n 的任何字符串。

语法

new RegExp("regexp(?!n)")
    
    或者
    
    /regexp(?!n)/

实例  
对其后没有紧跟 `“all”` 的 `“is”` 进行全局搜索：

### RegExp 对象方法 ###

<table> 
 <tbody> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td> compile </td> 
   <td> <span>在 1.5 版本中已废弃。</span>&nbsp;编译正则表达式。</td> 
  </tr> 
  <tr> 
   <td> exec </td> 
   <td>检索字符串中指定的值。返回找到的值，并确定其位置。</td> 
  </tr> 
  <tr> 
   <td>test</td> 
   <td>检索字符串中指定的值。返回 true 或 false。</td> 
  </tr> 
  <tr> 
   <td> toString </td> 
   <td>返回正则表达式的字符串。</td> 
  </tr> 
 </tbody> 
</table>

#### JavaScript RegExp toString() 方法 ####

定义和用法  
`toString()` 方法返回正则表达式的字符串值。

语法

RegExpObject.toString()

实例  
返回正则表达式的字符串值：

<button onclick="myFunction()">点我</button>
    <p id="demo"></p>
    	
    <script>
    function myFunction() {
        
        var patt = new RegExp("WILLEM", "g");
        var res = patt.toString();
        document.getElementById("demo").innerHTML = res; // /WILLEM/g
    }
    </script>

### 支持正则表达式的 String 对象的方法 ###

<table> 
 <tbody> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
   <th>FF</th> 
   <th>IE</th> 
  </tr> 
  <tr> 
   <td> search </td> 
   <td>检索与正则表达式相匹配的值。</td> 
   <td>1</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td> match </td> 
   <td>找到一个或多个正则表达式的匹配。</td> 
   <td>1</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td> replace </td> 
   <td>替换与正则表达式匹配的子串。</td> 
   <td>1</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td> split </td> 
   <td>把字符串分割为字符串数组。</td> 
   <td>1</td> 
   <td>4</td> 
  </tr> 
 </tbody> 
</table>

#### JavaScript RegExp search() 方法 ####

定义和用法  
`search()` 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。

如果没有找到任何匹配的子串，则返回 `-1`。

语法

string.search(searchvalue)

参数值

<table> 
 <tbody> 
  <tr> 
   <th align="left">参数</th> 
   <th align="left">描述</th> 
  </tr> 
  <tr> 
   <td><em>searchvalue</em></td> 
   <td>必须。查找的字符串或者正则表达式。</td> 
  </tr> 
 </tbody> 
</table>

返回值

<table> 
 <tbody> 
  <tr> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>Number</td> 
   <td>与指定查找的字符串或者正则表达式相匹配的 String 对象起始位置。</td> 
  </tr> 
 </tbody> 
</table>

实例1  
执行一次对大小写敏感的查找:

<p id="demo">单击显示查找的位置</p>
    <button onclick="myFunction()">点我</button>
    
    <script>
    function myFunction(){
        
        var str="Mr. Blue has a blue house"
        var n=str.search("blue");
        document.getElementById("demo").innerHTML=n; // 15
    }
    </script>

实例2  
执行一次忽略大小写的检索:

<p id="demo">单击显示查找的位置</p>
    <button onclick="myFunction()">点我</button>
    
    <script>
    function myFunction(){
        
        var str="Mr. Blue has a blue house"
        var n=str.search(/blue/i);
        document.getElementById("demo").innerHTML=n; // 4
    }
    </script>

#### JavaScript RegExp match() 方法 ####

定义和用法  
`match()` 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。

注意：

`match()`方法将检索字符串 String Object，以找到一个或多个与 regexp 匹配的文本。  
这个方法的行为在很大程度上有赖于 regexp 是否具有标志 `g`。

如果 regexp 没有标志 `g`，那么 `match()` 方法就只能在 `stringObject` 中执行一次匹配。

如果没有找到任何匹配的文本， `match()` 将返回 `null`。  
否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。

语法

string.match(regexp)

参数值

<table> 
 <tbody> 
  <tr> 
   <th align="left">参数</th> 
   <th align="left">描述</th> 
  </tr> 
  <tr> 
   <td>regexp</td> 
   <td>必需。规定要匹配的模式的 RegExp 对象。如果该参数不是 RegExp 对象，则需要首先把它传递给 RegExp 构造函数，将其转换为 RegExp 对象。</td> 
  </tr> 
 </tbody> 
</table>

返回值

<table> 
 <tbody> 
  <tr> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>Array</td> 
   <td>存放匹配结果的数组。该数组的内容依赖于 regexp 是否具有全局标志 g。 如果没找到匹配结果返回&nbsp;null&nbsp;。</td> 
  </tr> 
 </tbody> 
</table>

实例1  
全局查找字符串 `“ain”`，且不区分大小写:

<p id="demo">单击按钮显示matches。</p>
    <button onclick="myFunction()">点我</button>
    
    <script>
    function myFunction(){
        
        var str = "The rain in SPAIN stays mainly in the plain"; 
        var n=str.match(/ain/gi);
        
        // ain,AIN,ain,ain
        document.getElementById("demo").innerHTML=n;
    }
    </script>

实例2  
判断是否微信浏览器:

#### JavaScript RegExp replace() 方法 ####

定义和用法

`replace()` 方法用于在字符串中用一些字符替换另一些字符，  
或替换一个与正则表达式匹配的子串。

该方法不会改变原始字符串。

语法

string.replace(searchvalue,newvalue)

参数值

<table> 
 <tbody> 
  <tr> 
   <th align="left">参数</th> 
   <th align="left">描述</th> 
  </tr> 
  <tr> 
   <td><em>searchvalue</em></td> 
   <td>必须。规定子字符串或要替换的模式的 RegExp 对象。<br> 请注意，如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象。</td> 
  </tr> 
  <tr> 
   <td><em>newvalue</em></td> 
   <td>必需。一个字符串值。规定了替换文本或生成替换文本的函数。</td> 
  </tr> 
 </tbody> 
</table>

返回值

<table> 
 <tbody> 
  <tr> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>一个新的字符串，是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的。</td> 
  </tr> 
 </tbody> 
</table>

实例1  
在本例中，我们将执行一次替换，当第一个 `“Microsoft”` 被找到，它就被替换为 “Willem”：

<p>单击按钮将段落中的第一个 Microsoft 替换成 Willem：</p>
    <p id="demo">Visit Microsoft!Visit Microsoft!</p>
    <button onclick="myFunction()">点我</button>
    
    <script>
        function myFunction() {
        
            var str = document.getElementById("demo").innerHTML;
            var n = str.replace("Microsoft", "Willem");
            document.getElementById("demo").innerHTML = n;
        }
    </script>

![在这里插入图片描述][b9a28e58dc31452dad582340f9088379.png]  
实例2  
执行一个全局替换, 忽略大小写:

<p>单击按钮将段落中的“blue”替换成“red”。</p>
    <p id="demo">Mr Blue has a blue house and a blue car.</p>
    <button onclick="myFunction()">点我</button>
    
    <script>
    function myFunction(){
        
        var str=document.getElementById("demo").innerHTML; 
        var n=str.replace(/blue/gi,"red");
    
    	// Mr red has a red house and a red car.
        document.getElementById("demo").innerHTML=n;
    }
    </script>

实例3  
在本例中，我们通过 `prototype` 为 JavaScript 的 `String` 对象添加方法，来实现将所有 `“Microsoft”` 替换为 `“Willem”`：

<p>单击按钮将段落中所有“Microsoft”替换成“Willem”：</p>
    <p id="demo">Visit Microsoft!Visit Microsoft!Visit Microsoft!</p>
    <button onclick="myFunction()">点我</button>
    
    <script>
    String.prototype.replaceAll = function(search, replacement) {
        
        var target = this;
        return target.replace(new RegExp(search, 'g'), replacement);
    };
    function myFunction() {
        
        var str=document.getElementById("demo").innerHTML;
        var n=str.replaceAll("Microsoft","Willem");
        document.getElementById("demo").innerHTML=n;
    }
    </script>

![在这里插入图片描述][5971fd63585d41f78873cc455896dcab.png]

#### JavaScript RegExp split() 方法 ####

定义和用法

`split()` 方法用于把一个字符串分割成字符串数组。

提示：  
如果把空字符串 `("")` 用作 separator，那么 stringObject 中的每个字符之间都会被分割。

注意： `split()` 方法不改变原始字符串。

语法

string.split(separator,limit)

参数值

<table> 
 <tbody> 
  <tr> 
   <th align="left">参数</th> 
   <th align="left">描述</th> 
  </tr> 
  <tr> 
   <td><em>separator</em></td> 
   <td>可选。字符串或正则表达式，从该参数指定的地方分割 string Object。</td> 
  </tr> 
  <tr> 
   <td><em>limit</em></td> 
   <td>可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。</td> 
  </tr> 
 </tbody> 
</table>

返回值

<table> 
 <tbody> 
  <tr> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>Array</td> 
   <td>一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 string Object 分割成子串创建的。返回的数组中的字串不包括 separator 自身。</td> 
  </tr> 
 </tbody> 
</table>

实例1  
省略分割参数：

<p id="demo">单击按钮显示分割后的数组</p>
    <button onclick="myFunction()">点我</button>
    
    <script>
    function myFunction(){
        
        var str="How are you doing today?";
        var n=str.split();
    
    	// How are you doing today?
        document.getElementById("demo").innerHTML=n;
    }
    </script>

实例2  
分割每个字符，包括空格:

<p id="demo">单击按钮显示分割后的数组</p>
    <button onclick="myFunction()">点我</button>
    
    <script>
    function myFunction(){
        
        var str="How are you doing today?";
        var n=str.split("");
    
    	// H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,?
        document.getElementById("demo").innerHTML=n;
    }
    </script>

实例3  
使用 limit 参数:

<p id="demo">单击按钮显示分割后的数组</p>
    <button onclick="myFunction()">点我</button>
    
    <script>
    function myFunction(){
        
        var str="How are you doing today?";
        var n=str.split(" ",3);
    
    	// How,are,you
        document.getElementById("demo").innerHTML=n;
    }
    </script>

实例4  
使用一个字符作为分隔符:

<p id="demo">单击按钮显示分割后的数组</p>
    <button onclick="myFunction()">点我</button>
    
    <script>
    function myFunction(){
        
        var str="How are you doing today?";
        var n=str.split("o");
    
    	// H,w are y,u d,ing t,day?
        document.getElementById("demo").innerHTML=n;
    }
    </script>

### RegExp 对象属性 ###

<table> 
 <tbody> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td> constructor </td> 
   <td>返回一个函数，该函数是一个创建 RegExp 对象的原型。</td> 
  </tr> 
  <tr> 
   <td> global </td> 
   <td>判断是否设置了 “g” 修饰符</td> 
  </tr> 
  <tr> 
   <td> ignoreCase </td> 
   <td>判断是否设置了 “i” 修饰符</td> 
  </tr> 
  <tr> 
   <td> lastIndex </td> 
   <td>用于规定下次匹配的起始位置</td> 
  </tr> 
  <tr> 
   <td> multiline </td> 
   <td>判断是否设置了 “m” 修饰符</td> 
  </tr> 
  <tr> 
   <td> source </td> 
   <td>返回正则表达式的匹配模式</td> 
  </tr> 
 </tbody> 
</table>

#### JavaScript RegExp constructor 属性 ####

定义和用法  
在 JavaScript 中, constructor 属性返回对象的构造函数。

返回值是函数的引用，不是函数名：

JavaScript 正则表达式 constructor 属性返回 `function RegExp() { [native code] }`  
JavaScript 数组 constructor 属性返回 `function Array() { [native code] }`  
JavaScript 数字 constructor 属性返回 `function Number() { [native code] }`  
JavaScript 字符串 constructor 属性返回 `returns function String() { [native code] }`

如果一个变量是数组你可以使用 constructor 属性来定义。

语法

RegExpObject.constructor

实例  
返回正则表达式原型的函数：

<p>点击按钮返回一个函数，该函数是创建对象的原型。 </p>
    <button onclick="myFunction()">点我</button>
    <p id="demo"></p>
    
    <script>
    function myFunction() {
        
        var patt = new RegExp("MYBJ", "g");
        var res = patt.constructor;
        document.getElementById("demo").innerHTML = res;
    }
    </script>

程序运行结果：

function RegExp() { [native code] }

#### JavaScript RegExp global 属性 ####

定义和用法：`global` 属性用于返回正则表达式是否具有 `“g”`。

如果 `g` 标志被设置，则该属性为 `true`，否则为 `false`。

语法

RegExpObject.global

实例  
查看正则表达式是否具有标志 `g`：

var str="Visit WILLEM!";
    var patt1=/WILL/g;
    
    if(patt1.global)
    {
        
        document.write("g 模式有设置!");
    }
    else
    {
        
        document.write("g 模式没有设置!");
    }

程序运行结果：

g 模式有设置!

#### JavaScript RegExp ignoreCase 属性 ####

定义和用法：`ignoreCase` 属性规定是否设置 `“i”` 标志。

如果设置了 `“i”` 标志，则返回 `true`，否则返回 `false`。

语法

RegExpObject.ignoreCase

实例  
查看是否设置了 `“i”` 标志:

var str="Visit WILLEM!";
    var patt1=/WILL/i;
    
    if(patt1.ignoreCase)
    {
        
        document.write("i 模式有设置!");
    }
    else
    {
        
        document.write("i 模式没有设置!");
    }

程序运行结果：

i 模式有设置!

#### JavaScript RegExp lastIndex 属性 ####

定义和用法：`lastIndex` 属性用于规定下次匹配的起始位置。

注意： 该属性只有设置标志 `g` 才能使用。

上次匹配的结果是由方法 `RegExp.exec() 和 RegExp.test()` 找到的，  
它们都以 `lastIndex` 属性所指的位置作为下次检索的起始点。  
这样，就可以通过反复调用这两个方法来遍历一个字符串中的所有匹配文本。

注意：该属性是可读可写的。只要目标字符串的下一次搜索开始，就可以对它进行设置。当方法 exec() 或 test() 再也找不到可以匹配的文本时，它们会自动把 lastIndex 属性重置为 `0`。

语法

RegExpObject.lastIndex

实例  
在字符串中全局试试子字符串 `“ain”` , 并输出匹配完成之后的 `lastIndex` 属性：

var str="The rain in Spain stays mainly in the plain";
    var patt1=/ain/g;
    
    while (patt1.test(str)==true) {
        
        document.write("'ain' found. Index now at: "+patt1.lastIndex);
        document.write("");
    }

程序运行结果：

'ain' found. Index now at: 8
    'ain' found. Index now at: 17
    'ain' found. Index now at: 28
    'ain' found. Index now at: 43

#### JavaScript RegExp multiline 属性 ####

定义和用法：`multiline` 属性用于返回正则表达式是否具有标志 `m`。

如果 m 标志被设置，则该属性为 true，否则为 false。

语法

RegExpObject.multiline

实例  
查找是否具有标志 `m`:

var str="Visit WILLEM!";
    var patt1=/WILL/gi;
    
    if(patt1.multiline)
    {
        
        document.write("m 模式有设置!");
    }
    else
    {
        
        document.write("m 模式没有设置!");
    }

程序运行结果：

m 模式没有设置!

#### JavaScript RegExp source 属性 ####

定义和用法：`source` 属性用于返回模式匹配所用的文本。

语法

RegExpObject.source

实例：返回与正则模式匹配的文本：

var str="Visit WILLEM";
    var patt1=/WILL/g;
    document.write("The text of the RegExp is: "+patt1.source);

程序运行结果：

The text of the RegExp is: WILL

[b9a28e58dc31452dad582340f9088379.png]: https://img-blog.csdnimg.cn/b9a28e58dc31452dad582340f9088379.png
[5971fd63585d41f78873cc455896dcab.png]: https://img-blog.csdnimg.cn/5971fd63585d41f78873cc455896dcab.png