JS 正则表达式

正则表达式

正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

创建正则表达式的两种方法

1.字面量
2.构造函数

// 两种创建方法
    // 1.字面量
    var reg = /\\bis\b/g; //g表示全文匹配
    // 2.构造函数
    var reg = new RegExp("\\bis\\b", "g");
    var str = "He is a boy. This is a dog. Where is she?";
    console.log(str.replace(reg, "IS"));

修饰符
g：global，全文搜索，若不添加，则搜索到第一个匹配即停止。
i：ignore case，忽略大小写，正则表达式是大小写敏感的。
m：multiple lines，多行搜索，搜索时识别换行符。

元字符
正则表达式由两种基本字符类型组成：
原义文本字符，如：a，abc 等。
元字符，在正则表达式中有特殊意义的非字母字符。如：\b 用于匹配单词边界。
一些特殊的符号。如：* + ？ $ ^ . | \ ( ) { } [ ]

字符类
一般情况下，正则表达式一个字符对应字符串的一个字符。
例如：表达式 ab\t 的含义是 "ab"紧接着一个 tab（制表符）。
当需要匹配一类字符时，可以使用[ ]来构造一个简单的类。
所谓类，是指符合某些特性的对象，一个泛指，而不是特指某个字符。
例如：表达式[abc]把字符 a、b、c 归位一类，表达式可以匹配这类字符，即匹配其中之一。
字符类取反
使用元字符^创建反向类（负向类），即匹配不属于该类的字符。
例如：[^abc]表示不是字符 a、b、c 其中之一的字符。

var str1 = "a1b2c3d4";
//在[]里面的字符将被匹配，而不会匹配连续的字符，^则是取反
console.log(str1.replace(/[abc]/g, "x")); // x1x2x3d4
console.log(str1.replace(/[^abc]/g, "x")); 
//^在类（[...]）里面表示取反，其余情况表示匹配开头;

范围类
需要匹配数字时，可以使用范围类。
例如：[a-z]表示从 a 到 z 之间的任意字符，且包含 a 和 z 本身。

var str2 = "a1b2c3d4z0";
console.log(str2.replace(/[a-z]/g, "X")); // X1X2X3X4X0
    
var str3 = "a1b2c3d4A5B6C7D8";
console.log(str3.replace(/[a-zA-Z0-9]/g, "*")); // ****************
// -在字母和数字之间表示范围，其余情况表示本身意思
        
var str4 = "2020-03-23";
console.log(str4.replace(/[0-9-]/g, "0")); // 0000000000
console.log(str4.replace(/[0-9]/g, "0")); // 0000-00-00

预定义类
正则表达式还提供了一些预定义类，用于快捷的表示一些特定的范围。
.(点)，[^\r\n]，除了回车符和换行符之外的所有字符。
\d，[0-9]，数字字符
\D，[^0-9]，非数字字符
\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]，非单词字符（除字母、数字和下划线之外的字符）

边界
正则表达式还提供了匹配边界的字符。
^，以 xxx 开始
$，以 xxx 结束
\b，单词边界
\B，非单词边界

量词
匹配字符连续出现 n 次的字符串。
?，出现 0 次或 1 次
+，出现 1 次或多次
*，出现 0 次或多次
{n}，出现 n 次
{n, m}，出现 n 到 m 次
{n,}，出现 n 次或更多次

var str5 = "@123@abc@";
console.log(str5.replace(/^@./g, "Q")); // Q23@abc@
console.log(str5.replace(/.@$/g, "Q")); // @123@abQ

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

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

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

// 非贪婪模式: 尽可能少的匹配 (在模式的后面加上 ？)
console.log(s1.replace(/\d{3,6}?/g, "x")); // xx78

分组
用（）将要进行的组合括起来

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

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

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

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

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

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

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 是否符合，如果符合才会被匹配。

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  reg1  =  /\w/;
let  reg2  =  /\w/gim;
console.log(reg1.global); // false
console.log(reg1.ignoreCase); // false
console.log(reg1.multiline); // false
console.log(reg2.global); // true
console.log(reg2.ignoreCase); // true
console.log(reg2.multiline); // true

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"));  // ["cd", index: 3, 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