JavaScript 正则表达式常用规范及其符号类型

本文链接：https://blog.youkuaiyun.com/weixin_46236141/article/details/105401090

本文详细介绍了JavaScript中的正则表达式，包括基本概念、语法规范和特殊符号。讲解了元字符如d、D、w、W等的用法，以及限定符号如边界符和限定符的实例。同时讨论了正则表达式的搜索、匹配和替换等配合函数的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

基本概念

正则表达式是对字符串内容，进行格式和内容的验证
对于正则表达式，我们不用自己去写，所有常用的正则表达式，在网上都可以搜到，我们只需要能看懂，会使用
所有的计算机语言，正则表达式都是相同的，通用

基本语法

字面量(常用)
使用 // 来包裹表达式内容：
var 变量 = /正则表达式/
构造函数
var 变量 = RegExt(‘正则表达式’);

正则表达式的使用方法

验证
判断字符串内容是否符合正则表达式的规范
执行结果是布尔类型
语法：正则表达式.test(‘字符串内容’);
捕获
捕获获取字符串中符合正则表达式规范的内容
执行结果是捕获获取到的符合规范的字符串内容
语法：正则表达式.exec(‘字符串内容’)
······································································································································

正则表达式常用语法规范

注意：正则表达式中，不要随便写空格，也会作为验证格式的一部分

1. 元字符

使用一些符号，来表示规范

\d    表示数值,数字,
\D    表示非数字,

\w    表示数字,字母,下划线
\W    表示非数字,字母,下划线

\s    表示空格
\S    表示非空格

.     表示非换行
      字符串中的换行,使用 转义符 \n 表示

提示：

正则表达式和转义符，都是 \内容的形式
JavaScript会自动识别,如果是 \内容：
 		符合正则表达式,就按照正则表达式来执行
 		符合转义符,就按照转义符的形式执行
正则表达式和转义符不会冲突

\d 实例

只要有数字即可，不用都是数字

var reg1 = /\d/ ;

console.log(reg1.test('123456')) ;   // 执行结果 true
console.log(reg1.test('abcd')) ;     // 执行结果 false
console.log(reg1.test('1234abcd')) ; // 执行结果 true

\D 实例

var reg2 = /\D/;

console.log(reg2.test('123456')) ;  // 执行结果 false
console.log(reg2.test('abcd')) ;    // 执行结果 true
console.log(reg2.test('1234abcd')) ;// 执行结果 true

\w 实例

var reg3 = /\w/;

console.log( reg3.test('123avbc_') );   // 执行结果 true
console.log( reg3.test('!@#$%^') );     // 执行结果 false
console.log( reg3.test('1234!@#$%^') ); // 执行结果 true

\W 实例

var reg4 = /\W/;

console.log( reg4.test('123avbc_') );   // 执行结果 false
console.log( reg4.test('!@#$%^') );     // 执行结果 true
console.log( reg4.test('1234!@#$%^') ); // 执行结果 true

\s 实例

var reg5 = /\s/;

console.log( reg5.test('      ') );       // 执行结果 true
console.log( reg5.test('312斤kfjisa') );  // 执行结果 false
console.log( reg5.test('312斤 kfjisa') ); // 执行结果 true

\S 实例

var reg6 = /\S/;

console.log( reg6.test('      ') );       // 执行结果 false
console.log( reg6.test('312斤kfjisa') );  // 执行结果 true
console.log( reg6.test('312斤 kfjisa') ); // 执行结果 true

. 实例

var reg7 = /./;

console.log( reg7.test('\n') );   // 执行结果 false

2. 限定符号

边界符

^    表示开头
$    表示结尾

^\d 实例

以数字开头即可，之后的内容，不做限定

var reg1 = /^\d/;

console.log(reg1.test('123'));     // 执行结果 true
console.log(reg1.test('123abc'));  // 执行结果 true
console.log(reg1.test('abc123'));  // 执行结果 false

\d$ 实例

以数字结尾，就看结尾，之前有什么内容不管

var reg2 = /\d$/;

console.log(reg2.test('123'));     // 执行结果 true
console.log(reg2.test('123abc'));  // 执行结果 false
console.log(reg2.test('abc123'));  // 执行结果 true

^\d$ 实例

如果开头结尾都加上了，限定效果就不同了
只能有一个字符，并且这个字符是数字，也就是说只能有一个数字字符
字符个数，内容，不符合都不行

var reg3 = /^\d$/;
console.log(reg3.test('1'));         // 执行结果 true
console.log(reg3.test('-1'));        // 执行结果 false
console.log(reg3.test('a'));         // 执行结果 false
console.log(reg3.test('123'));       // 执行结果 false
console.log(reg3.test('123abc'));    // 执行结果 false
console.log(reg3.test('abc123'));    // 执行结果 false
console.log(reg3.test('123abc123')); // 执行结果 false

限定符

限定出现次数
一般都要和边界符配合使用，否则执行效果有问题

*      表示允许的次数是 0 至 正无穷次    有没有都行
+      表示允许的次数是 1 至 正无穷次    至少有一个
?      表示允许的次数是 0 至 1          最多有一次
{n}    表示允许的次数是 n 次 n的数值,是自定义数值
{n,}   表示允许的次数是 n 次以上,包括n次  最少是n次,多了不管
        也就是 n 至 正无穷 次
{n,m}  表示允许的次数是 n 至 m 次   包括n和m

^\d*$ 实例

只能是数字字符，字符个数没有要求

var reg4 = /^\d*$/;
console.log( reg4.test('1') );          // 执行结果 true
console.log( reg4.test('') );           // 执行结果 true
console.log( reg4.test('123') );        // 执行结果 true
console.log( reg4.test('123abc') );     // 执行结果 false
console.log( reg4.test('123abc123') );  // 执行结果 false

^\d+$ 实例

必须是数字字符，至少出现1个数字字符

var reg5 = /^\d+$/;
console.log( reg5.test('1') );          // 执行结果 true
console.log( reg5.test('') );           // 执行结果 false
console.log( reg5.test('123') );        // 执行结果 true
console.log( reg5.test('123abc') );     // 执行结果 false
console.log( reg5.test('123abc123') );  // 执行结果 false

^\d?$ 实例

必须是数字字符，最多只能有0个或者1个字符

var reg6 = /^\d?$/;
console.log( reg6.test('1') );          // 执行结果 true
console.log( reg6.test('') );           // 执行结果 true
console.log( reg6.test('123') );        // 执行结果 false
console.log( reg6.test('123abc') );     // 执行结果 false
console.log( reg6.test('123abc123') );  // 执行结果 false

^\d{3}$ 实例

只能是3个数字字符

var reg7 = /^\d{3}$/;
console.log( reg7.test('1') );          // 执行结果 false
console.log( reg7.test('') );           // 执行结果 false
console.log( reg7.test('123') );        // 执行结果 true
console.log( reg7.test('123abc') );     // 执行结果 false
console.log( reg7.test('123abc123') );  // 执行结果 false

^\d{1,}$ 实例

必须都是数字字符，并且至少有一个数字字符

var reg8 = /^\d{1,}$/;
console.log( reg8.test('1') );          // 执行结果 true
console.log( reg8.test('') );           // 执行结果 false
console.log( reg8.test('123') );        // 执行结果 true
console.log( reg8.test('123abc') );     // 执行结果 false
console.log( reg8.test('123abc123') );  // 执行结果 false

^\d{1,3}$ 实例

都是数字，1至3次

var reg9 = /^\d{1,3}$/;
console.log( reg9.test('1') );           // 执行结果 true
console.log( reg9.test('') );            // 执行结果 false
console.log( reg9.test('123') );         // 执行结果 true
console.log( reg9.test('123abc') );      // 执行结果 false
console.log( reg9.test('123abc123') );   // 执行结果 false

······································································································································

正则表达式的特殊符号

\   可以表示正则表达式的规范，或者是转义符
    设定是不冲突的,符合哪个就执行哪个

|   表示逻辑或的关系
    表示两个规范，满足哪个都可以

逻辑或：如果要表示多种内容，并且限定字符个数
公式 : (内容1|内容2|内容3…){次数限定}

()  将()中的内容作为一个整体来执行，确保执行正确

[]  在[]中设定的内容，任意满足其中一个就可以  abcd

-   表示在这个范围内的就可以 a-d

[^内容]  表示 非内容

i  忽略大小写
g  全局匹配

这两个必须写在 // 之外：/正则表达式/i /正则表达式/g
一般是与其他的函数配合使用

| 实例

数字或者数字字符下划线，并且个数只能是三个

var  reg1 = /^(\d|\w){3}$/;

// 这种写法也可以
// var reg1 = /^\d{3}$|^\w{3}$/;

console.log( reg1.test( '123' ) );      // 执行结果 true
console.log( reg1.test( 'abc' ) );      // 执行结果 true
console.log( reg1.test( '1234' ) );     // 执行结果 false
console.log( reg1.test( 'abcd' ) );     // 执行结果 false
console.log( reg1.test( '1!1' ) );     // 执行结果 false
console.log( reg1.test( 'a&b' ) );     // 执行结果 false
console.log( reg1.test( 'ab' ) );      // 执行结果 false
console.log( reg1.test( '12' ) );      // 执行结果 false
console.log( reg1.test( '12&12' ) );   // 执行结果 false
console.log( reg1.test( 'ab&ab' ) );   // 执行结果 false

[] 实例

内容只能是 a b c d 4个字符，多了不可以

var reg2 = /^[abcd]$/;

console.log( reg2.test('a') );     // 执行结果 true
console.log( reg2.test('b') );     // 执行结果 true
console.log( reg2.test('c') );     // 执行结果 true
console.log( reg2.test('d') );     // 执行结果 true
console.log( reg2.test('ab') );    // 执行结果 false
console.log( reg2.test('abc') );   // 执行结果 false
console.log( reg2.test('abcd') );  // 执行结果 false
console.log( reg2.test('bc') );   // 执行结果 false
console.log( reg2.test('bcd') );  // 执行结果 false
console.log( reg2.test('cd') );   // 执行结果 false

- 实例

a-d之间的字符，只能是一个

var reg3 = /^[a-d]$/;

console.log( reg3.test('a') );      // 执行结果 true
console.log( reg3.test('b') );      // 执行结果 true
console.log( reg3.test('c') );      // 执行结果 true
console.log( reg3.test('d') );      // 执行结果 true
console.log( reg3.test('ab') );     // 执行结果 false
console.log( reg3.test('abc') );    // 执行结果 false
console.log( reg3.test('abcd') );   // 执行结果 false
console.log( reg3.test('bc') );    // 执行结果 false
console.log( reg3.test('bcd') );   // 执行结果 false
console.log( reg3.test('cd') );    // 执行结果 false

[^内容] 实例

字符范围不在 a-d 之间，并且是一个字符

var reg4 = /^[^(a-d)]$/;

console.log( reg4.test('a') );      // 执行结果 false
console.log( reg4.test('b') );      // 执行结果 false
console.log( reg4.test('c') );      // 执行结果 false
console.log( reg4.test('d') );      // 执行结果 false
console.log( reg4.test('ab') );     // 执行结果 false
console.log( reg4.test('abc') );    // 执行结果 false
console.log( reg4.test('abcd') );   // 执行结果 false
console.log( reg4.test('bc') );    // 执行结果 false
console.log( reg4.test('bcd') );   // 执行结果 false
console.log( reg4.test('cd') );    // 执行结果 false
console.log( reg4.test('z') );     // 执行结果 true

正则表达式的其他配合函数

1. search()

字符串查找函数，在字符串中，查找是否有符合的内容，如果有，返回下标，没有返回-1
返回的是第一个符合内容的索引下标
indexOf() 也是查找，也返回索引下标，但是不支持正则表达式

实例

var str1 = 'abcdefgab';
// 默认是区分大小写的
console.log( str1.search('ab') );   // 执行结果 0
console.log( str1.search('B') );    // 执行结果 -1
// 正则表达式,不区分大小写
console.log( str1.search(/B/i) );   // 执行结果 1

console.log( str1.indexOf('b') );   // 执行结果 1
// indexOf() 不支持正则表达式
console.log( str1.indexOf(/B/i) ); // 执行结果 -1

2. match()

找到符合规范的字符串，并且返回内容
默认只会执行一次，并且返回第一次符合规范的内容

实例

var str2 = 'abcdefgabcdefg';

var arr1 = str2.match('ab');
// 正则表达式,匹配全局
var arr2 = str2.match(/ab/g);

console.log(arr1);
console.log(arr2);

3. replace()

字符串替换，默认只替换第一个符合的内容

实例

var str3 = 'abcd曹abcd曹abcd曹abcd';

// 默认值替换第一个
str3 = str3.replace('曹' , '*');

// 正则表达式,替换全局
str3 = str3.replace( /曹/g , '*');

console.log(str3);