正则表达式

最新推荐文章于 2022-03-19 15:09:08 发布

深海打捞的喵

最新推荐文章于 2022-03-19 15:09:08 发布

阅读量218

点赞数

分类专栏： JavaScript 文章标签：正则表达式 js

本文链接：https://blog.csdn.net/weixin_45493444/article/details/115267796

版权

JavaScript 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

正则表达式

JavaScript中使用RegExp对象来封装一个正则表达式，并提供相关的方法和属性。

两种创建方法

字面量

let reg = /\bis\b/g; //g表示全文匹配
let str = "He is a boy. This is a dog. Where is she?";
console.log(str.replace(reg, "IS"));

构造函数

let reg = new RegExp("\\bis\\b", "g");
let str = "He is a boy. This is a dog. Where is she?";
console.log(str.replace(reg, "IS"));

修饰字符

字符	含义
g	global，全文搜索，若不添加，则搜索到第一个匹配即停止。
i	ignore case，忽略大小写，正则表达式是大小写敏感的。
\d	[0-9]，数字字符
\D	[^0-9]，非数字字符

字符	预定义类（用于快捷的表示一些特定的范围）
.	[^\r\n]，除了回车符和换行符之外的所有字符。
\s	[\t\n\x0B\f\r]，空白符，\f 换页符，\r 回车符，\t 水平制表符，\n 换行符，\x0b 垂直制表符
\S	[^\t\n\x0b\f\r]，非空白符
\w	[a-zA-Z_0-9]，单词字符（包括字母、数字和下划线）
\W	[^a-za-z_0-9]，非单词字符（除字母、数字和下划线之外的字符）

字符	量词
?	出现 0 次或 1 次
+	出现 1 次或多次
*	出现 0 次或多次
{}	出现 n 次
{n,m}	出现 n 到 m 次
{n,}	出现 n 次或更多次

字符	边界
^	以 xxx 开始
$	以 xxx 结束
\b	单词边界
\B	非单词边界

let str = "He is a boy. Is he?";
console.log(str.replace(/\bis\b/gi, "0"));
//He 0 a boy. 0 he?

正则表达式由两种基本字符类型组成：

原义文本字符，如：a，abc 等。

元字符，在正则表达式中有特殊意义的非字母字符。如：\b 用于匹配单词边界。

一些特殊的符号。如：* + ？ $ ^ . | \ ( ) { } [ ]

字符类

一般情况下，正则表达式一个字符对应字符串的一个字符。

 例如：表达式 ab\t 的含义是 "ab"紧接着一个 tab（制表符）。

当需要匹配一类字符时，可以使用[ ]来构造一个简单的类。

 所谓类，是指符合某些特性的对象，一个泛指，而不是特指某个字符。
 例如：表达式[abc]把字符 a、b、c 归位一类，表达式可以匹配这类字符，即匹配其中之一。

let str = "a1b2c3d4";
console.log(str.replace(/[abc]/g, "x"));
//x1x2x3d4

字符类取反

使用元字符^创建反向类（负向类），即匹配不属于该类的字符。

 例如：[^abc]表示不是字符 a、b、c 其中之一的字符。

let str = "a1b2c3d4";
console.log(str.replace(/[^abc]/g, "x"));
//axbxcxxx

范围类

需要匹配数字时，可以使用范围类。

 例如：[a-z]表示从 a 到 z 之间的任意字符，且包含 a 和 z 本身。

let str = "a1b2c3d4z0";
console.log(str.replace(/[a-z]/g, "X"));
//X1X2X3X4X0

在[ ]中可以将一些范围连续书写。

let str = "a1b2c3d4A5B6C7D8";
console.log(str.replace(/[a-zA-Z0-9]/g, "*"));
//****************
str = "2020-03-04";
console.log(str.replace(/[0-9-]/g, "0"));
//0000000000

边界

    var str="This is a boy";
    console.log(str.replace(/is/g,"0"))
    //Th0 0 a boy
    console.log(str.replace(/\bis\b/g,"0"))
    //This 0 a boy
    console.log(str.replace(/\Bis\B/g,"0"))
    //This is a boy
    str ="@123@abc@"
    console.log(str.replace(/@./g,"Q"))
    //Q23Qbc@
    console.log(str.replace(/^@./g,"Q"))
    //Q23@abc@
    console.log(str.replace(/.@/g,"Q"))
    //@12QabQ
    console.log(str.replace(/.@$/g,"Q"))
    //@123@abQ

   str =`@123
@456
@789`;
    console.log(str.replace(/^@\d/g,"X"))//以@开始，以$结束
	//X23
	//@456
	//@789
    console.log(str.replace(/@\d/gm,"X"))
	//X23
	//X56
	//X89

贪婪模式与非贪婪模式

例如：\d{3,6}匹配"12345678"的结果是什么？默认情况下，正则表达式会尽可能多的匹配，即采用 6 次来匹配。

与贪婪模式相反，即尽可能少的匹配，一旦成功匹配就不再继续尝试其他的可能性。在模式后面加上？。

{
    console.log("12345678".replace(/\d{3,6}/g,"x"));
    //x78
    console.log("12345678".replace(/\d{3,6}?/g,"x"));
    //xx78
}

分组

Byron{3}表示对 n 匹配 3 次，而不是 Byron。如果要对 Byron 匹配三次，就需要对其进行分组。

console.log("a1b2c3d4".replace(/[a-z]\d{3}/g, "X"));
//a1b2c3d4
console.log("a1b2c3d4".replace(/([a-z]\d){3}/g, "X"));
//xd4

或

使用 | 表示或，表示|左右字符二选一。

- 例如： 比较 Byron|Casper 和 Byr(on|Ca)sper。

console.log("ByronCasper".replace(/Byron|Casper/g, "X"));
//XX
console.log("ByrCasperByronsper".replace(/Byr(on|Ca)sper/g, "X"));
//XX

反向引用

使用$n的形式引用模式中分组匹配到的文本，n为索引，从1开始。

- 例如：把 2020-03-04 替换成 03/04/2020。

console.log("2020-03-04" .replace(/(\d{4})-(\d{2})-(\d{2})/g, "$2/$3/$1"));
//03/04/2020

忽略分组

当不想捕获分组时，可以使用?：

- 例如：(?:Byron).(ok)就会忽略对第一个分组的捕获。

console.log("2020-03-04".replace(/(\d{4})-(\d{2})-(?:\d{2})/g, "$2/$3/$1"));
//03/$3/2020
console.log("2020-03-04".replace(/(\d{4})-(?:\d{2})-(\d{2})/g,"$2/$3/$1"));
//04/$3/2020

前瞻

正则表达式从文本头部向尾部开始解析，文本尾部方向，称为“前”。

前瞻，在正则表达式匹配到规则的时候，向前检查是否符合断言。符合和不符合特定断言称为“肯定/正向”和“否定/负向”匹配。

正向前瞻，exp(?=assert)
负向前瞻，exp(?!assert)

exp 和 assert 都是正则表达式，匹配到 exp 时还要判断 assert 是否符合，如果符合才会被匹配。
- 例如：表达式\w(?=\d)，表示匹配到一个单词\w 时还需要向后判断是否为一个数字\d。

console.log("a2*34V8".replace(/\w(?=\d)/g,"x"))//前瞻
//x2*x4x8
console.log("a2*34V8".replace(/\w(?!\d)/g,"x"))//后瞻
//ax*3xVx

RegExp对象属性

RegExp	对象属性
global	是否全文搜索，默认 false
ignoreCase	是否忽略大小写，默认 false
multiline	是否多行搜索，默认 false
lastIndex	当前表达式匹配内容的最后一个字符的下一个位置
source	正则表达式的文本字符串

	 let reg=/\w/;
     let reg1=/\w/gim;
     console.log(reg.global);
     //false
     console.log(reg1.global);
     //true
     console.log(reg1.ignoreCase);
     //true
     console.log(reg1.multiline);
     //true
     console.log("global，ignoreCase，multiline只能可读");
     console.log(reg.lastIndex);
     //0
     console.log(reg1.exec("#$#%$aca@@"));
     //[ 'a', index: 5, input: '#$#%$aca@@', groups: undefined ]
     console.log(reg1.lastIndex);
     //6
     console.log(reg1.exec("#$#%$aca@@"));
     //[ 'c', index: 6, input: '#$#%$aca@@', groups: undefined ]
     console.log(reg1.lastIndex);
     //7

RegExp对象方法

test(str)，用于测试字符串参数中是否存在匹配正则表达式模式的字符串，返回 true 或 false。

exec(str)，使用正则表达式模式对字符串执行搜索，并将更新全部 RegExp 对象的属性以反映匹配结果。

如果没有匹配的文本则返回 null，否则会返回一个结果“数组”对象： [匹配到的文本, 与第 1 个分组相匹配的文本,与第 n 个分组相匹配的文本…]
index，声明匹配文本的第一个字符的位置
input，存放被检索的字符串 string

{
     let reg1=/\w[1,2]/g
     console.log(reg1.test("ab,cd"));
     //true
     console.log(reg1.exec("ab,cd"));//返回一个数组
     //null
     console.log(reg1.exec("ab,cd"));//返回一个数组
     // [ 'b,', index: 1, input: 'ab,cd', groups: undefined ]
     console.log(reg1.exec("ab,cd"));//返回一个数组
     //null
     console.log(reg1.exec("ab,cd"));//返回一个数组
     //[ 'b,', index: 1, input: 'ab,cd', groups: undefined ]
     console.log(reg1.source);
     //\w[1,2]
 }

字符串正则表达式相关的方法

search(reg)，用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。返回第一个匹配结果的 index，没有匹配到返回-1。不执行全局匹配。

match(reg)，检索字符串以找到一个或多个与 regexp 匹配的文本，未找到返回 null，找到后返回一个数组。与 RegExp 的 exec()方法相同。

split(reg)，利用 regexp 匹配结果作为分隔符对字符串进行分割，返回一个数组。

replace(reg, newStr)，将 regexp 的匹配结果替换成 newStr，返回一个新字符串。

    {
        let str = "<java> and <javascript> is deferent!";
        console.log(str.match(/<\S*>/g));
        //[ '<java>', '<javascript>' ]
        console.log(str.replace(/<(\S*)>/g, "<<$1>>"));
        //<<java>> and <<javascript>> is deferent!
        console.log(str.split(/[<>]/g));
        //[ '', 'java', ' and ', 'javascript', ' is deferent!' ]
    }

replace(reg, function)的用法

let s1 = "a1b23d4e5".replace(/\d/g, function(match, index, origin) {
       console.log(index);
       return parseInt(match) + 1;
 });
//1
//3
//4
//6
//8

let s2 = "a1b23d4e5".replace(/(\d)(\w)(\d)/g, 
function(match, group1, group2, group3, index, origin) {
    console.log(match);
    return group1 + group3;
});
//1b2
//3d4

深海打捞的喵

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
正则表达式

正则表达式JavaScript中使用RegExp对象来封装一个正则表达式，并提供相关的方法和属性。两种创建方法字面量let reg = /\bis\b/g; //g表示全文匹配let str = "He is a boy. This is a dog. Where is she?";console.log(str.replace(reg, "IS"));构造函数let reg = new RegExp("\\bis\\b", "g");let str = "He is a boy.
复制链接

扫一扫

专栏目录