当前位置:   article > 正文

js之正则表达式_js正则

js正则

1.什么是正则表达式

正则表达式是用于匹配字符串中字符组合的模式。在 JavaScript 中,正则表达式也是对象。这些模式被用于 RegExp 的 exec 和 test 方法,以及 String 的 match、matchAll、replace、search 和 split 方法。

2.正则表达式的特点

  • 灵活性、逻辑性和功能性非常的强。
  • 可以迅速地用极简单的方式达到字符串的复杂控制。

3.创建正则表达式

方式一:通过调用RegExp对象的构造函数创建

  1. var regexp = new RegExp(/123/);
  2. console.log(regexp);

方式二:利用字面量创建 正则表达式

var rg = /123/;

4.测试正则表达式

test() 正则对象方法,用于检测字符串是否符合该规则,该对象会返回 true 或 false,其参数是测试字符串。

  1. var rg = /123/;
  2. console.log(rg.test(123));//匹配字符中是否出现123 出现结果为true
  3. console.log(rg.test('abc'));//匹配字符中是否出现123 未出现结果为false

5.正则表达式中的特殊字符

5.1正则表达式修饰符

修饰符描述
i执行对大小写不敏感的匹配。
g执行全局匹配(查找所有匹配而非在找到第一个匹配后停止)。
m执行多行匹配。

5.2正则表达式模式

表达式描述
[abc]查找括号之间的任何字符。
[^abc]查找任何不在方括号之间的字符。
[0-9]查找任何从 0 至 9 的数字。
[^0-9]查找任何不在括号内的字符(任何非数字)。
(x|y)查找任何指定的选项。
  1. var rg = /[abc]/; // 只要包含有a 或者 包含有b 或者包含有c 都返回为true
  2. console.log(rg.test('andy'));//true
  3. console.log(rg.test('baby'));//true
  4. console.log(rg.test('color'));//true
  5. console.log(rg.test('red'));//false
  6. var rg1 = /^[abc]$/; // 三选一 只有是a 或者是 b 或者是c 这三个字母才返回 true
  7. console.log(rg1.test('aa'));//false
  8. console.log(rg1.test('a'));//true
  9. console.log(rg1.test('b'));//true
  10. console.log(rg1.test('c'));//true
  11. console.log(rg1.test('abc'));//false
  12. ----------------------------------------------------------------------------------
  13. // - 短横线 表示一个范围
  14. var reg = /^[a-z]$/ //26个英文字母任何一个字母返回 true - 表示的是a 到z 的范围
  15. console.log(reg.test('a'));//true
  16. console.log(reg.test('z'));//true
  17. console.log(reg.test('A'));//false
  18. -----------------------------------------------------------------------------------
  19. // 字符组合
  20. var reg1 = /^[a-zA-Z0-9]$/; // 26个英文字母(大写和小写都可以)任何一个字母返回 true
  21. ------------------------------------------------------------------------------------
  22. //取反 方括号内部加上 ^ 表示取反,只要包含方括号内的字符,都返回 false 。
  23. var reg2 = /^[^a-zA-Z0-9]$/;
  24. console.log(reg2.test('a'));//false
  25. console.log(reg2.test('B'));//false
  26. console.log(reg2.test(8));//false
  27. console.log(reg2.test('!'));//true

5.3元字符

元字符是具有特殊含义的字符:

元字符描述
.查找单个字符,除了换行符或行终止符。
\w查找单词字符。
\W查找非单词字符。
\d查找数字。
\D查找非数字字符。
\s查找空白字符。
\S查找非空白字符。
\b在单词的开头/结尾查找匹配项,开头如下:\bHI,结尾如下:HI\b。
\B查找匹配项,但不在单词的开头/结尾处。
\0查找 NULL 字符。
\n查找换行符。
\f查找换页符。
\r查找回车符。
\t查找制表符。
\v查找垂直制表符。
\xxx查找以八进制数 xxx 规定的字符。
\xdd查找以十六进制数 dd 规定的字符。
\uxxxx查找以十六进制数 xxxx 规定的 Unicode 字符。
  1. var rg1 = /\d/;
  2. console.log(rg1.test('123456')); //true
  3. console.log(rg1.test('abc')); //false
  4. console.log(rg1.test('123456abc')); //true
  5. var rg2 = /\D/;
  6. console.log(rg2.test('123456')); //false
  7. console.log(rg2.test('abc')); //true
  8. console.log(rg2.test('123456abc')); //true
  9. var rg3 = /\w/;
  10. console.log(rg3.test('123456')); //true
  11. console.log(rg3.test('abc')); //true
  12. console.log(rg3.test('123456abc')); //true
  13. console.log(rg3.test('123456abc_')); //true
  14. console.log(rg3.test('*')); //false
  15. var rg4 = /\W/;
  16. console.log(rg4.test('123456')); //true
  17. console.log(rg4.test('abc')); //true
  18. console.log(rg4.test('123456abc')); //true

5.4量词

量词描述
n+匹配任何包含至少一个 n 的字符串。
n*匹配任何包含零个或多个 n 的字符串。
n?匹配任何包含零个或一个 n 的字符串。
n{X}匹配包含 X 个 n 的序列的字符串。
n{X,Y}匹配包含 X 至 Y 个 n 的序列的字符串。
n{X,}匹配包含至少 X 个 n 的序列的字符串。
n$匹配任何以 n 结尾的字符串。
^n匹配任何以 n 开头的字符串。
?=n匹配任何其后紧接指定字符串 n 的字符串。
?!n匹配任何其后没有紧接指定字符串 n 的字符串。

 括号总结

  • 大括号 量词符. 里面表示重复次数
  • 中括号 字符集合。匹配方括号中的任意字符.
  • 小括号表示优先级

主要记住

量词说明
*重复0次或更多次
+重复1次或更多次
?重复0次或1次
{n}重复n次
{n,}重复n次或更多次
{n,m}重复n到m次
  1. // 量词符:用来设定某个模式出现的次数
  2. //简单理解:就是让下面的a这个字符重复多少次
  3. var reg = /^a$/;
  4. * :相当于 >=0 可以出现0次或者很多次
  5. var reg = /^a*$/;
  6. console.log(reg.test(''));
  7. console.log(reg.test('a'));
  8. console.log(reg.test('aaaa'));
  9. + :相当于 >=1 可以出现1次或者很多次
  10. var reg = /^a+$/;
  11. console.log(reg.test(''));
  12. console.log(reg.test('a'));
  13. console.log(reg.test('aaaa'));
  14. ? :相当于 1 || 0 重复1次或者0
  15. var reg = /^a?$/;
  16. console.log(reg.test(''));
  17. console.log(reg.test('a'));
  18. console.log(reg.test('aaaa'));
  19. {3} :就是重复3
  20. var reg = /^a{3}$/;
  21. console.log(reg.test(''));
  22. console.log(reg.test('a'));
  23. console.log(reg.test('aaaa'));
  24. console.log(reg.test('aaa'));
  25. {3,}: 大于等于3 >=3
  26. var reg = /^a{3,}$/;
  27. console.log(reg.test(''));
  28. console.log(reg.test('a'));
  29. console.log(reg.test('aaaa'));
  30. console.log(reg.test('aaa'));
  31. {3,16}: 等于等于3 并且 小于等于16
  32. var reg = /^a{3,16}$/;
  33. console.log(reg.test(''));
  34. console.log(reg.test('a'));
  35. console.log(reg.test('aaaa'));
  36. console.log(reg.test('aaa'));

5.5边界符

正则表达式中的边界符(位置符)用来提示字符所处的位置,主要有两个字符

边界符说明
^表示匹配行首的文本(以谁开始)
$表示匹配行尾的文本(以谁结束)

如果 ^和 $ 在一起,表示必须是精确匹配。

  1. var rg = /abc/; // 正则表达式里面不需要加引号 不管是数字型还是字符串型
  2. // /abc/ 只要包含有abc这个字符串返回的都是true
  3. console.log(rg.test('abc'));
  4. console.log(rg.test('abcd'));
  5. console.log(rg.test('aabcd'));
  6. console.log('---------------------------');
  7. var reg = /^abc/;
  8. console.log(reg.test('abc')); // true
  9. console.log(reg.test('abcd')); // true
  10. console.log(reg.test('aabcd')); // false
  11. console.log('---------------------------');
  12. var reg1 = /^abc$/; // 精确匹配 要求必须是 abc字符串才符合规范
  13. console.log(reg1.test('abc')); // true
  14. console.log(reg1.test('abcd')); // false
  15. console.log(reg1.test('aabcd')); // false
  16. console.log(reg1.test('abcabc')); // false

 使用正则修复边界

  1. // 使用 正则表达式边界修复错误字符串
  2. buggyMultiline = `tey, ihe light-greon apple
  3. tangs on ihe greon traa`;
  4. // 1) 使用 ^ 修正字符串开始处和换行后的匹配。
  5. buggyMultiline = buggyMultiline.replace(/^t/gim,'h');
  6. console.log(1, buggyMultiline); // 修复 'tey'=>'hey'(字符串开始) , 'tangs'=>'hangs'(换行后)
  7. // 2) 使用 $ 修正字符串结尾处的匹配。
  8. buggyMultiline = buggyMultiline.replace(/aa$/gim,'ee.');
  9. console.log(2, buggyMultiline); // 修复 'traa' => 'tree'.
  10. // 3) 使用 \b 修正单词和空格边界上的字符。
  11. buggyMultiline = buggyMultiline.replace(/\bi/gim,'t');
  12. console.log(3, buggyMultiline); // 修复 'ihe' => 'the' 不影响 'light'.
  13. // 4) 使用 \B 匹配实体边界内的字符。
  14. fixedMultiline = buggyMultiline.replace(/\Bo/gim,'e');
  15. console.log(4, fixedMultiline); // 修复 'greon' 不影响'on'.

6.正则表达式前瞻后顾 负前瞻和负后顾

6.1前瞻(先行断言)

(x|y)查找任何指定的选项。
?=n匹配任何其后紧接指定字符串 n 的字符串。
x(?=y)

匹配'x'仅仅当'x'后面跟着'y'.这种叫做先行断言。

例如,/Jack(?=Sprat)/会匹配到'Jack'仅当它后面跟着'Sprat'。/Jack(?=Sprat|Frost)/匹配‘Jack’仅当它后面跟着'Sprat'或者是‘Frost’。但是‘Sprat’和‘Frost’都不是匹配结果的一部分。

 首先使用括号()来提升优先级,然后使用?= ,对后面紧跟 "e" 的 "h"进行全局搜索:

  1. var str= 'hello hi world';
  2. // 前瞻 查找 e 前面的h
  3. var pe = /h(?=e)/g;
  4. var newStr = str.replace(pe,'T');
  5. console.log(newStr);

6.2后顾 (后行断言)

(x|y)查找任何指定的选项。
(?<=y)x

匹配'x'仅当'x'前面是'y'.这种叫做后行断言。

例如,/(?<=Jack)Sprat/会匹配到' Sprat '仅仅当它前面是' Jack '。/(?<=Jack|Tom)Sprat/匹配‘Sprat ’仅仅当它前面是'Jack'或者是‘Tom’。但是‘Jack’和‘Tom’都不是匹配结果的一部分。

  首先使用括号()来提升优先级,然后使用?<= ,对前面紧跟 "l" 的 "d"进行全局搜索:

  1. // 后顾 查找l后面的 d
  2. var pe = /(?<=l)d/g;
  3. var newStr = str.replace(pe,'M');
  4. console.log(newStr);

 负前瞻(先行否定断言

(x|y)查找任何指定的选项。
x(?!y)

仅仅当'x'后面不跟着'y'时匹配'x',这被称为正向否定查找。

例如,仅仅当这个数字后面没有跟小数点的时候,/\d+(?!\.)/ 匹配一个数字。正则表达式/\d+(?!\.)/.exec("3.141") 匹配‘141’而不是‘3.141’

 首先使用括号()来提升优先级,然后使用?! ,对后面不是紧跟 "e" 的 "h"进行全局搜索:

  1. // 负前瞻 查找h后面不是e的
  2. var pe = /h(?!e)/g;
  3. var newStr = str.replace(pe,'N');
  4. console.log(newStr);

负后顾(后行否定断言) 

(x|y)查找任何指定的选项。
(?<!y)x

仅仅当'x'前面不是'y'时匹配'x',这被称为反向否定查找。

例如,仅仅当这个数字前面没有负号的时候,/(?<!-)\d+/ 匹配一个数字。
/(?<!-)\d+/.exec('3') 匹配到 "3".
/(?<!-)\d+/.exec('-3') 因为这个数字前有负号,所以没有匹配到。

 首先使用括号()来提升优先级,然后使用?<! ,对前面不是紧跟 "e" 的 "l"进行全局搜索:

  1. // 负后顾 查找l前面不是e的
  2. var pe = /(?<!e)l/g;
  3. var newStr = str.replace(pe,'Q');
  4. console.log(newStr);

7.RegExp 对象属性

属性描述
constructor返回创建 RegExp 对象原型的函数。
global检查是否设置了 "g" 修饰符。
ignoreCase检查是否设置了 "i" 修饰符。
lastIndex规定开始下一个匹配的索引。
multiline检查是否设置了 "m" 修饰符。
source返回 RegExp 模式的文本。

8.RegExp 对象方法

方法描述
compile()在 1.5 版中已弃用。编译正则表达式。
exec()测试字符串中的匹配项。返回第一个匹配项。
test()测试字符串中的匹配项。返回 true 或 false。
toString()返回正则表达式的字符串值。

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

方法描述FFIE
search检索与正则表达式相匹配的值。14
match找到一个或多个正则表达式的匹配。14
replace替换与正则表达式匹配的子串。14
split把字符串分割为字符串数组。14

10.案例

10.1验证座机号码**

  1. var reg = /^\d{3}-\d{8}|\d{4}-\d{7}$/;
  2. var reg = /^\d{3,4}-\d{7,8}$/;
  3. console.log(reg.test('010-12345678'));// true

10.2表单验证案例

  1. //手机号验证:/^1[3|4|5|7|8][0-9]{9}$/;
  2. //验证通过与不通过更换元素的类名与元素中的内容
  3. if (reg.test(this.value)) {
  4. // console.log('正确的');
  5. this.nextElementSibling.className = 'success';
  6. this.nextElementSibling.innerHTML = '<i class="success_icon"></i> 恭喜您输入正确';
  7. } else {
  8. // console.log('不正确');
  9. this.nextElementSibling.className = 'error';
  10. this.nextElementSibling.innerHTML = '<i class="error_icon"></i>格式不正确,请从新输入 ';
  11. }

10.3注册页面

  1. //QQ号验证: /^[1-9]\d{4,}$/;
  2. //昵称验证:/^[\u4e00-\u9fa5]{2,8}$/
  3. //验证通过与不通过更换元素的类名与元素中的内容 ,将上一步的匹配代码进行封装,多次调用即可
  4. function regexp(ele, reg) {
  5. ele.onblur = function() {
  6. if (reg.test(this.value)) {
  7. // console.log('正确的');
  8. this.nextElementSibling.className = 'success';
  9. this.nextElementSibling.innerHTML = '<i class="success_icon"></i> 恭喜您输入正确';
  10. } else {
  11. // console.log('不正确');
  12. this.nextElementSibling.className = 'error';
  13. this.nextElementSibling.innerHTML = '<i class="error_icon"></i> 格式不正确,请从新输入 ';
  14. }
  15. }
  16. };

10.4正则替换replace

  1. var str = 'andy和red';
  2. var newStr = str.replace('andy', 'baby');
  3. console.log(newStr)//baby和red
  4. //等同于 此处的andy可以写在正则表达式内
  5. var newStr2 = str.replace(/andy/, 'baby');
  6. console.log(newStr2)//baby和red
  7. //全部替换
  8. var str = 'abcabc'
  9. var nStr = str.replace(/a/,'哈哈')
  10. console.log(nStr) //哈哈bcabc
  11. //全部替换g
  12. var nStr = str.replace(/a/g,'哈哈')
  13. console.log(nStr) //哈哈bc哈哈bc
  14. //忽略大小写i
  15. var str = 'aAbcAba';
  16. var newStr = str.replace(/a/gi,'哈哈')//"哈哈哈哈bc哈哈b哈哈"

10.5正则替换敏感词

  1. <textarea name="" id="message"></textarea> <button>提交</button>
  2. <div></div>
  3. <script>
  4. var text = document.querySelector('textarea');
  5. var btn = document.querySelector('button');
  6. var div = document.querySelector('div');
  7. btn.onclick = function() {
  8. div.innerHTML = text.value.replace(/激情|gay/g, '**');
  9. }
  10. </script>

11.详细介绍正则的特殊字符大全(来源于MDN)

下面的页面与表格列出了一个正则表达式中可以利用的特殊字符的完整列表和描述。

断言(Assertions)

表示一个匹配在某些条件下发生。断言包含先行断言、后行断言和条件表达式。

字符类(Character Classes)

区分不同类型的字符,例如区分字母和数字。

组和范围(Groups and Ranges)

表示表达式字符的分组和范围。

量词(Quantifiers)

表示匹配的字符或表达式的数量。

Unicode 属性转义(Unicode Property Escapes)

基于 unicode 字符属性区分字符。例如大写和小写字母、数学符号和标点。

正则表达式中的特殊字符
字符含义
\

依照下列规则匹配:

在非特殊字符之前的反斜杠表示下一个字符是特殊字符,不能按照字面理解。例如,前面没有 "\" 的 "b" 通常匹配小写字母 "b",即字符会被作为字面理解,无论它出现在哪里。但如果前面加了 "\",它将不再匹配任何字符,而是表示一个字符边界

在特殊字符之前的反斜杠表示下一个字符不是特殊字符,应该按照字面理解。详情请参阅下文中的 "转义(Escaping)" 部分。

如果你想将字符串传递给 RegExp 构造函数,不要忘记在字符串字面量中反斜杠是转义字符。所以为了在模式中添加一个反斜杠,你需要在字符串字面量中转义它。/[a-z]\s/i 和 new RegExp("[a-z]\\s", "i") 创建了相同的正则表达式:一个用于搜索后面紧跟着空白字符(\s 可看后文)并且在 a-z 范围内的任意字符的表达式。为了通过字符串字面量给 RegExp 构造函数创建包含反斜杠的表达式,你需要在字符串级别和正则表达式级别都对它进行转义。例如 /[a-z]:\\/i 和 new RegExp("[a-z]:\\\\","i") 会创建相同的表达式,即匹配类似 "C:\" 字符串。

^

匹配输入的开始。如果多行标志被设置为 true,那么也匹配换行符后紧跟的位置。

例如,/^A/ 并不会匹配 "an A" 中的 'A',但是会匹配 "An E" 中的 'A'。

当 '^' 作为第一个字符出现在一个字符集合模式时,它将会有不同的含义。反向字符集合 一节有详细介绍和示例。

$

匹配输入的结束。如果多行标志被设置为 true,那么也匹配换行符前的位置。

例如,/t$/ 并不会匹配 "eater" 中的 't',但是会匹配 "eat" 中的 't'。

*

匹配前一个表达式 0 次或多次。等价于 {0,}

例如,/bo*/ 会匹配 "A ghost boooooed" 中的 'booooo' 和 "A bird warbled" 中的 'b',但是在 "A goat grunted" 中不会匹配任何内容。

+

匹配前面一个表达式 1 次或者多次。等价于 {1,}

例如,/a+/ 会匹配 "candy" 中的 'a' 和 "caaaaaaandy" 中所有的 'a',但是在 "cndy" 中不会匹配任何内容。

?

匹配前面一个表达式 0 次或者 1 次。等价于 {0,1}

例如,/e?le?/ 匹配 "angel" 中的 'el'、"angle" 中的 'le' 以及 "oslo' 中的 'l'。

如果紧跟在任何量词 *、 +、? 或 {} 的后面,将会使量词变为非贪婪(匹配尽量少的字符),和缺省使用的贪婪模式(匹配尽可能多的字符)正好相反。例如,对 "123abc" 使用 /\d+/ 将会匹配 "123",而使用 /\d+?/ 则只会匹配到 "1"。

还用于先行断言中,如本表的 x(?=y) 和 x(?!y) 条目所述。

.

(小数点)默认匹配除换行符之外的任何单个字符。

例如,/.n/ 将会匹配 "nay, an apple is on the tree" 中的 'an' 和 'on',但是不会匹配 'nay'。

如果 s ("dotAll") 标志位被设为 true,它也会匹配换行符。

(x)

像下面的例子展示的那样,它会匹配 'x' 并且记住匹配项。其中括号被称为捕获括号

模式 /(foo) (bar) \1 \2/ 中的 '(foo)' 和 '(bar)' 匹配并记住字符串 "foo bar foo bar" 中前两个单词。模式中的 \1 和 \2 表示第一个和第二个被捕获括号匹配的子字符串,即 foo 和 bar,匹配了原字符串中的后两个单词。注意 \1\2、...、\n 是用在正则表达式的匹配环节,详情可以参阅后文的 \n 条目。而在正则表达式的替换环节,则要使用像 $1$2、...、$n 这样的语法,例如,'bar foo'.replace(/(...) (...)/, '$2 $1')$& 表示整个用于匹配的原字符串。

(?:x)

匹配 'x' 但是不记住匹配项。这种括号叫作非捕获括号,使得你能够定义与正则表达式运算符一起使用的子表达式。看看这个例子 /(?:foo){1,2}/。如果表达式是 /foo{1,2}/{1,2} 将只应用于 'foo' 的最后一个字符 'o'。如果使用非捕获括号,则 {1,2} 会应用于整个 'foo' 单词。更多信息,可以参阅下文的 使用括号的子字符串匹配 条目。

x(?=y)

匹配'x'仅仅当'x'后面跟着'y'.这种叫做先行断言。

例如,/Jack(?=Sprat)/会匹配到'Jack'仅当它后面跟着'Sprat'。/Jack(?=Sprat|Frost)/匹配‘Jack’仅当它后面跟着'Sprat'或者是‘Frost’。但是‘Sprat’和‘Frost’都不是匹配结果的一部分。

(?<=y)x

匹配'x'仅当'x'前面是'y'.这种叫做后行断言。

例如,/(?<=Jack)Sprat/会匹配到' Sprat '仅仅当它前面是' Jack '。/(?<=Jack|Tom)Sprat/匹配‘Sprat ’仅仅当它前面是'Jack'或者是‘Tom’。但是‘Jack’和‘Tom’都不是匹配结果的一部分。

x(?!y)

仅仅当'x'后面不跟着'y'时匹配'x',这被称为正向否定查找。

例如,仅仅当这个数字后面没有跟小数点的时候,/\d+(?!\.)/ 匹配一个数字。正则表达式/\d+(?!\.)/.exec("3.141") 匹配‘141’而不是‘3.141’

(?<!y)x

仅仅当'x'前面不是'y'时匹配'x',这被称为反向否定查找。

例如,仅仅当这个数字前面没有负号的时候,/(?<!-)\d+/ 匹配一个数字。
/(?<!-)\d+/.exec('3') 匹配到 "3".
/(?<!-)\d+/.exec('-3') 因为这个数字前有负号,所以没有匹配到。

x|y

匹配‘x’或者‘y’。

例如,/green|red/匹配“green apple”中的‘green’和“red apple”中的‘red’

{n}n 是一个正整数,匹配了前面一个字符刚好出现了 n 次。
比如, /a{2}/ 不会匹配“candy”中的'a',但是会匹配“caandy”中所有的 a,以及“caaandy”中的前两个'a'。
{n,}

n 是一个正整数,匹配前一个字符至少出现了 n 次。

例如,/a{2,}/ 匹配 "aa", "aaaa" 和 "aaaaa" 但是不匹配 "a"。

{n,m}

n 和 m 都是整数。匹配前面的字符至少 n 次,最多 m 次。如果 n 或者 m 的值是 0,这个值被忽略。

例如,/a{1, 3}/ 并不匹配“cndy”中的任意字符,匹配“candy”中的 a,匹配“caandy”中的前两个 a,也匹配“caaaaaaandy”中的前三个 a。注意,当匹配”caaaaaaandy“时,匹配的值是“aaa”,即使原始的字符串中有更多的 a。

[xyz]一个字符集合。匹配方括号中的任意字符,包括转义序列。你可以使用破折号(-)来指定一个字符范围。对于点(.)和星号(*)这样的特殊符号在一个字符集中没有特殊的意义。他们不必进行转义,不过转义也是起作用的。
例如,[abcd] 和 [a-d] 是一样的。他们都匹配"brisket"中的‘b’,也都匹配“city”中的‘c’。/[a-z.]+/ 和/[\w.]+/与字符串“test.i.ng”匹配。
[^xyz]

一个反向字符集。也就是说, 它匹配任何没有包含在方括号中的字符。你可以使用破折号(-)来指定一个字符范围。任何普通字符在这里都是起作用的。

例如,[^abc] 和 [^a-c] 是一样的。他们匹配"brisket"中的‘r’,也匹配“chop”中的‘h’。

[\b]

匹配一个退格 (U+0008)。(不要和\b混淆了。)

\b

匹配一个词的边界。一个词的边界就是一个词不被另外一个“字”字符跟随的位置或者前面跟其他“字”字符的位置,例如在字母和空格之间。注意,匹配中不包括匹配的字边界。换句话说,一个匹配的词的边界的内容的长度是 0。(不要和 [\b] 混淆了)

使用"moon"举例:
/\bm/匹配“moon”中的‘m’;
/oo\b/并不匹配"moon"中的'oo',因为'oo'被一个“字”字符'n'紧跟着。
/oon\b/匹配"moon"中的'oon',因为'oon'是这个字符串的结束部分。这样他没有被一个“字”字符紧跟着。
/\w\b\w/将不能匹配任何字符串,因为在一个单词中间的字符永远也不可能同时满足没有“字”字符跟随和有“字”字符跟随两种情况。

备注: JavaScript 的正则表达式引擎将特定的字符集定义为“字”字符。不在该集合中的任何字符都被认为是一个断词。这组字符相当有限:它只包括大写和小写的罗马字母,十进制数字和下划线字符。不幸的是,重要的字符,例如“é”或“ü”,被视为断词。

\B

匹配一个非单词边界。匹配如下几种情况:

  • 字符串第一个字符为非“字”字符
  • 字符串最后一个字符为非“字”字符
  • 两个单词字符之间
  • 两个非单词字符之间
  • 空字符串

例如,/\B../匹配"noonday"中的'oo', 而/y\B../匹配"possibly yesterday"中的’yes‘

\cX

当 X 是处于 A 到 Z 之间的字符的时候,匹配字符串中的一个控制符。

例如,/\cM/ 匹配字符串中的 control-M (U+000D)。

\d

匹配一个数字等价于 [0-9]

例如, /\d/ 或者 /[0-9]/ 匹配"B2 is the suite number."中的'2'。

\D

匹配一个非数字字符等价于 [^0-9]

例如, /\D/ 或者 /[^0-9]/ 匹配"B2 is the suite number."中的'B' 。

\f匹配一个换页符 (U+000C)。
\n匹配一个换行符 (U+000A)。
\r匹配一个回车符 (U+000D)。
\s

匹配一个空白字符,包括空格、制表符、换页符和换行符。等价于 [\f\n\r\t\v\u0020\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]

例如,/\s\w*/ 匹配"foo bar."中的' bar'。

经测试,\s不匹配"\u180e",在当前版本 Chrome(v80.0.3987.122) 和 Firefox(76.0.1) 控制台输入/\s/.test("\u180e") 均返回 false。

\S

匹配一个非空白字符。等价于 [^\f\n\r\t\v\u0020\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]

例如,/\S\w*/ 匹配"foo bar."中的'foo'。

\t匹配一个水平制表符 (U+0009)。
\v匹配一个垂直制表符 (U+000B)。
\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 个子捕获匹配的子字符串 (捕获的数目以左括号计数)。

比如 /apple(,)\sorange\1/ 匹配"apple, orange, cherry, peach."中的'apple, orange,' 。

\0匹配 NULL(U+0000)字符,不要在这后面跟其他小数,因为 \0<digits> 是一个八进制转义序列。
\xhh匹配一个两位十六进制数(\x00-\xFF)表示的字符。
\uhhhh匹配一个四位十六进制数表示的 UTF-16 代码单元。

\u{hhhh}或\u{hhhhh}

(仅当设置了 u 标志时)匹配一个十六进制数表示的 Unicode 字符。
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/在线问答5/article/detail/781584
推荐阅读
相关标签
  

闽ICP备14008679号