RegExp 对象属性和方法

RegExp 对象

 

在 JavaScript 中， RegExp 是描述字符模式的对象。用于对字符串模式匹配及检索替换，是对字符串执行模式匹配的强大工具。正则表达式用好了有时候能减少大半代码量。
它提供了各种匹配与检查字符串的相关操作。
创建一个 RegExp 实例对象的方法：
  • var reg = RegExp("ab+c")
  • var reg = new RegExp("ab+c")
  • var reg = /ab+c/

 

RegExp 对象与其实例的属性和方法：

// Object.getOwnPropertyDescriptors(RegExp):
length                      : {value: 2, writable: false, enumerable: false, configurable: true}
name                        : {value: "RegExp", writable: false, enumerable: false, configurable: true}
prototype                   : {value: {…}, writable: false, enumerable: false, configurable: false}
$1                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$2                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$3                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$4                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$5                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$6                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$7                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$8                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$9                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$&                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$'                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$+                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$_                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
$`                          : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
input                       : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
lastMatch                   : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
lastParen                   : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
leftContext                 : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
rightContext                : {enumerable: false, configurable: true, get: ƒ, set: ƒ}
Symbol(Symbol.species)      : {set: undefined, enumerable: false, configurable: true, get: ƒ}

// Object.getOwnPropertyDescriptors(RegExp.prototype):
constructor                 : {writable: true, enumerable: false, configurable: true, value: ƒ}
toString                    : {writable: true, enumerable: false, configurable: true, value: ƒ}
Symbol(Symbol.match)        : {writable: true, enumerable: false, configurable: true, value: ƒ}
Symbol(Symbol.matchAll)     : {writable: true, enumerable: false, configurable: true, value: ƒ}
Symbol(Symbol.replace)      : {writable: true, enumerable: false, configurable: true, value: ƒ}
Symbol(Symbol.search)       : {writable: true, enumerable: false, configurable: true, value: ƒ}
Symbol(Symbol.split)        : {writable: true, enumerable: false, configurable: true, value: ƒ}
compile                     : {writable: true, enumerable: false, configurable: true, value: ƒ}
dotAll                      : {set: undefined, enumerable: false, configurable: true, get: ƒ}
exec                        : {writable: true, enumerable: false, configurable: true, value: ƒ}
flags                       : {set: undefined, enumerable: false, configurable: true, get: ƒ}
global                      : {set: undefined, enumerable: false, configurable: true, get: ƒ}
ignoreCase                  : {set: undefined, enumerable: false, configurable: true, get: ƒ}
multiline                   : {set: undefined, enumerable: false, configurable: true, get: ƒ}
source                      : {set: undefined, enumerable: false, configurable: true, get: ƒ}
sticky                      : {set: undefined, enumerable: false, configurable: true, get: ƒ}
test                        : {writable: true, enumerable: false, configurable: true, value: ƒ}
unicode                     : {set: undefined, enumerable: false, configurable: true, get: ƒ}

 

 

RegExp 对象属性描述

属性描述
$1-$9 正则表达式的静态和只读属性（非标准），包含圆括号子字符串匹配。
input/$_ 正则表达式的静态和只读属性（非标准），包含正则表达式所匹配的字符串。
lastMatch/$& 正则表达式的静态和只读属性（非标准），包含最后匹配到的字符串。
lastParen/$+ 正则表达式的静态和只读属性（非标准），包含匹配到的最后一个子串。
leftContext/$` 正则表达式的静态和只读属性（非标准），包含最新匹配的左侧子串。
rightContext/$' 正则表达式的静态和只读属性（非标准），包含最新匹配的右侧子串。

 

RegExp 对象常用属性

1.$1-$9：包含括号子串匹配的正则表达式的静态和只读属性，非标准不建议生产环境使用。

语法：RegExp.$1，RegExp.$2 ... RegExp.$9

示例：

var re = /(\w+)\s(\w+)/;
var str = 'John Smith';
str.replace(re, '$2, $1'); // "Smith, John"
RegExp.$1; // "John"
RegExp.$2; // "Smith"

 

2.input / $_：正则表达式静态属性，含有正则表达式所匹配的字符串，非标准不建议生产环境使用。

语法：RegExp.input / RegExp['$_'] （RegExp.input 与 RegExp['$_'] 作用相同，可视 $_ 为 input 别名）

示例：

var re = /hi/g;

re.test('hi there!');
RegExp.input;         // "hi there!"
RegExp['$_'];         // "hi there!"

re.test('foo');       // 新测试，不匹配
RegExp.input;         // "hi there!"
RegExp.$_;            // "hi there!"

re.test('hi world!'); // 新测试，匹配
RegExp.input;         // "hi world!"
RegExp.$_;            // "hi world!"

 

3.lastMatch / $&：正则表达式的静态和只读属性，含有最后匹配到的字符串，非标准不建议生产环境使用。

语法：RegExp.lastMatch / RegExp['$&'] （RegExp.lastMatch 与 RegExp['$&'] 作用相同，可视 $& 为 lastMatch 别名）

示例：

var re = /hi/g;
re.test('hi there!');
RegExp.lastMatch; // "hi"
RegExp['$&'];     // "hi"

 

4.lastParen / $+：正则表达式的静态和只读属性，包含匹配到的最后一个子串，非标准不建议生产环境使用。

语法：RegExp.lastParen / RegExp['$+'] （RegExp.lastParen 与 RegExp['$+'] 作用相同，可视 $+ 为 lastParen 别名）

示例：

var re = /(hi)/g;
re.test('hi there!');
RegExp.lastParen; // "hi"
RegExp['$+'];     // "hi"

 

5.leftContext / $`：正则表达式的静态和只读属性，含有最新匹配的左侧子串，非标准不建议生产环境使用。

语法：RegExp.leftContext / RegExp['$`'] （RegExp.leftContext 与 RegExp['$`'] 作用相同，可视 $` 为 leftContext 别名）

示例：

var re = /world/g;
re.test('hello world!');
RegExp.leftContext; // "hello "
RegExp['$`'];       // "hello "

 

6.rightContext / $'：正则表达式的静态和只读属性，含有最新匹配的右侧子串，非标准不建议生产环境使用。

语法：RegExp.rightContext / RegExp["$'"] （RegExp.rightContext 与 RegExp["$'"] 作用相同，可视 $' 为 rightContext 别名）

示例：

var re = /hello/g;
re.test('hello world!');
RegExp.rightContext; // " world!"
RegExp["$'"];       // " world!"

 

RegExp.prototype 对象方法描述

方法描述
exec() 执行一个字符串的搜索匹配。
compile() 改变和重新编译正则表达式。
test() 测试匹配的字符串参数。
toSource() 返回一个对象文字代表指定的对象;您可以使用这个值来创建一个新的对象。
toString() 返回一个字符串代表指定的对象。

 

RegExp.prototype 对象常用方法

1.compile()：（已废弃，不建议使用）

功能：在脚本执行过程中（重新）编译正则表达式。与RegExp构造函数基本一样。

语法：reg.compile(pattern, flags)

参数：

  • pattern：正则表达式的文本 。
  • flags：如果指定，标志可以具有以下值的任意组合：
    • g：全局匹配。
    • i：忽略大小写。
    • m：多行;让开始和结束字符（^ 和 $）工作在多行模式工作（例如，^ 和 $ 可以匹配字符串中每一行的开始和结束（行是由 \n 或 \r 分割的），而不只是整个输入字符串的最开始和最末尾处。
    • y：黏度; 在目标字符串中，只从正则表达式的 lastIndex 属性指定的显示位置开始匹配（并且不试图从任何之后的索引匹配）。

示例：

var reg = new RegExp("hi","gi")
reg.compile("hello","g")// /hello/g

 

2.exec()

功能：在一个指定字符串中执行一个搜索匹配。返回一个结果数组或 null。

语法：reg.exec(str)

参数：str，必须，要匹配正则表达式的字符串。

返回值：返回一个数组，其中存放匹配的结果。如果未找到匹配，则返回值为 null。

示例：

var reg = /quick\s(brown).+?(jumps)/ig;
var result = reg.exec('The Quick Brown Fox Jumps Over The Lazy Dog');

reg;             // /quick\s(brown).+?(jumps)/gi
reg.lastIndex;   // 25 （下次匹配开始的位置）
reg.ignoreCase;  // true （是否使用了i标记）
reg.global;      // true （是否使用了g标记）
reg.multiline;   // false （是否使用了m标记）
reg.source;      // "quick\s(brown).+?(jumps)" （正则匹配的字符串）

result;          // ["Quick Brown Fox Jumps", "Brown", "Jumps", index: 4, input: "The Quick Brown Fox Jumps Over The Lazy Dog", groups: undefined]
result[0];       // "Quick Brown Fox Jumps" (匹配的全部字符)
result[1];       // "Brown" （分组捕获第[1]组）
result[2];       // "Jumps" （分组捕获第[2]组）
result[3];       // undefined （reg里面，一组圆括号()为一组）
result[4];       // undefined （reg里面只有两组，所以[3]和[4]都是 undefined）
result.index;    // 4 （匹配到的字符位于原始字符串的基于0的索引值）
result.input;    // "The Quick Brown Fox Jumps Over The Lazy Dog" （原始字符串）

var matches = /(hello \S+)/.exec('This is a hello world!');
console.log(matches[1]); // hello world!

 

3.test()

功能：执行一个检索，用来查看正则表达式与指定的字符串是否匹配。返回 true 或 false。

语法：reg.test(str)

参数：str，必须，用来与正则表达式匹配的字符串。

返回值：true或者false。

注意：支持正则表达式的 String 对象的方法有：search()、match()、replace()和split()。

示例：

let str = 'hello world!';
let result = /^hello/.test(str);
console.log(result); // true

// 注意：如果正则表达式设置了全局标志，test() 的执行会改变正则表达式   lastIndex属性。
// 连续的执行test()方法，后续的执行将会从 lastIndex 处开始匹配字符串，(exec() 同样改变正则本身的 lastIndex属性值).
var regex = /foo/g;

// regex.lastIndex is at 0
regex.test('foo'); // true

// regex.lastIndex is now at 3
regex.test('foo'); // false

 

RegExp 的修饰符

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

修饰符描述
i 执行对大小写不敏感的匹配。
g 执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）。
m 执行多行匹配。 
var str = 'Is up down up down left right left right abAB , can add 30 lift ?/n no, is up up down down left right left right BABA';
var reg = /up down left right/;
var reg0 = /up up left right/;
var reg1 = /bab/;
var reg2 = /bab/i;
var reg3 = /bab/m;
var reg4 = /bab/g;
var reg5 = /bab/img;
var reg6 = /bab/mg;
var reg7 = /BAB/img;

reg.test(str)  // true
reg0.test(str) // false
reg1.test(str) // false
reg2.test(str) // true
reg3.test(str) // false
reg4.test(str) // false
reg5.test(str) // true
reg6.test(str) // false
reg7.test(str) // true

 

括号

方括号用于查找某个范围内的字符，圆括号多个匹配分组匹配，花括号匹配次数：

表达式描述
[abc] 查找方括号之间的任何字符。
[^abc] 查找任何不在方括号之间的字符。
[0-9] 查找任何从 0 至 9 的数字。
[a-z] 查找任何从小写 a 到小写 z 的字符。
[A-Z] 查找任何从大写 A 到大写 Z 的字符。
[A-z] 查找任何从大写 A 到小写 z 的字符。
(a|B|c) 查找a、B、c中出现一个或多个的字符。
(\d)(\w) 查找数字或数字字母的字符。
[abc]{2} 查找连续出现2次一个或多个abc中的字符。
\W{1,3} 查找最少出现1次最多3次非字母数字的字符。
(\w){3}(\d){2} 查找数字字母出现3次紧接数字出现2次的字符。
\w{3}\d{2} 查找数字字母出现3次数字出现2次的字符。 
console.log(/[abc]/.test('abc'))                 // true
console.log(/[abc]/.test('a'))                   // true
console.log(/[abc]/.test('A123'))                // false

console.log(/[^abc]/.test('123'))                // true
console.log(/[^abc]/.test('ae'))                 // true
console.log(/[^abc]/.test('a'))                  // false

console.log(/[0-9]/.test('10088'))               // true
console.log(/[0-9]/.test('a1b2'))                // true
console.log(/[0-9]/.test('ab'))                  // false

console.log(/[a-z]/.test('a'))                   // true
console.log(/[a-z]/.test('acAD123'))             // true
console.log(/[a-z]/.test('B123'))                // false

console.log(/[A-Z]/.test('aBc'))                 // true
console.log(/[A-Z]/.test('H'))                   // true
console.log(/[A-Z]/.test('abc'))                 // false

console.log(/[A-z]/.test('aB'))                  // true
console.log(/[A-z]/.test('a123C'))               // true
console.log(/[A-z]/.test('123'))                 // false

console.log(/[(a|B|c)]/.test('aAbBcC'))          // true
console.log(/[(a|B|c)]/.test('abc'))             // true
console.log(/[(a|B|c)]/.test('AbC'))             // false

console.log(/[(\d)(\w)]/.test('a1'))             // true
console.log(/[(\d)(\w)]/.test('2'))              // true
console.log(/[(\d)(\w)]/.test(' - '))            // false

console.log(/[abc]{2}/.test('ab'))               // true
console.log(/[abc]{2}/.test('1cba2'))            // true
console.log(/[abc]{2}/.test('a1b1c1'))           // false

console.log(/\W{1,3}/.test('ac13-'))             // true
console.log(/\W{1,3}/.test('1.a'))               // true
console.log(/\W{1,3}/.test('abc123'))            // false

console.log(/(\w){3}(\d){2}/.test('abc12'))      // true
console.log(/(\w){3}(\d){2}/.test('- new13-'))   // true
console.log(/(\w){3}(\d){2}/.test('Ab c12'))     // false

console.log(/\w{3}\d{2}/.test('Ab2c12'))         // true
console.log(/\w{3}\d{2}/.test('12a34'))          // true
console.log(/\w{3}\d{2}/.test('Ab c12'))         // false

 

元字符

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

元字符描述
. 查找单个字符，除了换行和行结束符。
\w 查找单词字符。
\W 查找非单词字符。
\d 查找数字。
\D 查找非数字字符。
\s 查找空白字符。
\S 查找非空白字符。
\b 匹配单词边界。
\B 匹配非单词边界。
\0 查找 NULL 字符。
\n 查找换行符。
\f 查找换页符。
\r 查找回车符。
\t 查找制表符。
\v 查找垂直制表符。
\xxx 查找以八进制数 xxx 规定的字符。
\xdd 查找以十六进制数 dd 规定的字符。
\uxxxx 查找以十六进制数 xxxx 规定的 Unicode 字符。

量词

量词描述
n+

匹配任何包含至少一个 n 的字符串。

 

例如，/a+/ 匹配 "candy" 中的 "a"，"caaaaaaandy" 中所有的 "a"。
n*

匹配任何包含零个或多个 n 的字符串。

例如，/bo*/ 匹配 "A ghost booooed" 中的 "boooo"，"A bird warbled" 中的 "b"，但是不匹配 "A goat grunted"。
n?

匹配任何包含零个或一个 n 的字符串。

例如，/e?le?/ 匹配 "angel" 中的 "el"，"angle" 中的 "le"。
n{X}

匹配包含 X 个 n 的序列的字符串。

例如，/a{2}/ 不匹配 "candy," 中的 "a"，但是匹配 "caandy," 中的两个 "a"，且匹配 "caaandy." 中的前两个 "a"。
n{X,}

X 是一个正整数。前面的模式 n 连续出现至少 X 次时匹配。

例如，/a{2,}/ 不匹配 "candy" 中的 "a"，但是匹配 "caandy" 和 "caaaaaaandy." 中所有的 "a"。
n{X,Y}

X 和 Y 为正整数。前面的模式 n 连续出现至少 X 次，至多 Y 次时匹配。

例如，/a{1,3}/ 不匹配 "cndy"，匹配 "candy," 中的 "a"，"caandy," 中的两个 "a"，匹配 "caaaaaaandy" 中的前面三个 "a"。注意，当匹配 "caaaaaaandy" 时，即使原始字符串拥有更多的 "a"，匹配项也是 "aaa"。
n$ 匹配任何结尾为 n 的字符串。
^n 匹配任何开头为 n 的字符串。
?=n 匹配任何其后紧接指定字符串 n 的字符串。
?!n 匹配任何其后没有紧接指定字符串 n 的字符串。

 

 

JavaScript 中的三大对象 (本地对象、内置对象、 宿主对象)

本地对象

 

内置对象

 

宿主对象

 

posted @ 2020-05-11 13:59  elfpower  阅读(921)  评论(0)  编辑  收藏  举报