【JavaScript】-- 正则表达式（二）

正则表达式分为两种重复方式：

1. 贪婪模式
2. 非贪婪模式

• 贪婪模式：

取能够匹配到的数量尽可能多的为一组进行匹配，匹配剩余字符串时还会尝试新的匹配，直到匹配不到为止。这也是默认模式。

 例：

// 对字符串"123456789"，匹配其中的数字3-6次：\d{3,6}，先匹配数字出现6次的字符串（123456），然后再从剩余字符串（789）中匹配出现数字3次的情况，剩余字符若没有出现数字3次则停止匹配.
var str = "123456789";
var reg = /\d{3,6}/g;
console.log(reg.exec(str)); //[ '123456', index: 0, input: '12345678', groups: undefined ]
console.log(reg.exec(str)); // [ '789', index: 6, input: '123456789', groups: undefined ]
console.log(reg.exec(str)); // null

• 非贪婪模式： 

数量尽可能少为一组匹配，直到匹配不到为止。

使用方法：在量词后面加上一个 ？

// 对字符串"123456789"，匹配其中的数字3-6次：\d{3,6}，先匹配数字出现3次的字符串（123），然后再从剩余字符串（456789）中匹配出现数字3次的情况，剩余字符若没有出现数字3次则停止匹配.
var str = "123456789";
var reg = /\d{3,6}?/g;
console.log(reg.exec(str)); //[ '123', index: 0, input: '123456789', groups: undefined ]
console.log(reg.exec(str)); // [ '456', index: 3, input: '123456789', groups: undefined ]
console.log(reg.exec(str)); // [ '789', index: 6, input: '123456789', groups: undefined ]

• 选择、引用、分组

• 选择

用 | 分隔可供选择的字符，一旦发现匹配项即匹配成功。

var reg = /html|css|js/
console.log(reg.exec('qweqwehtmlcss')); // html

• 分组

用小括号包裹的一个小整体成为一个分组。

/briupbriupbriup/

也可以写成：

/(briup){3}/

• 候选

在一个分组中，可以有多个候选表达式

var reg = /I Like (basketball|football|table tennis)/
console.log(reg.test('I Like basketball')); //true
console.log(reg.test('I Like football')); //true
console.log(reg.test('I Like table tennis')); //true

•  捕获与引用

被正则表达式匹配到的字符串会暂存起来。其中由分组捕获的串会从1开始编号，于是我们可以引用这些串：

var reg = /(\d{4})-(\d{2})-(\d{2})/

var date = '2022-08-16'

reg.test(date)
// 捕获之前要先test/exec
console.log(RegExp.$1); //2022
console.log(RegExp.$2); //08
console.log(RegExp.$3); //16

$1引用了第一个被捕获的串，$2是第二个，依次类推。

• 嵌套分组的捕获

规则是以左括号出现的顺序进行捕获：  

var reg = /((apple) is (a (fruit)))/
var str = "apple is a fruit"
reg.test(str) // true
RegExp.$1 // apple is a fruit
RegExp.$2 // apple
RegExp.$3 // a fruit
RegExp.$4 // fruit

• 引用

 正则表达式里也能进行引用，这称为反向引用：

\1引用了第一个被分组所捕获的串，换言之，表达式是动态决定的。

var reg = /(\w{3}) is \1/
console.log(reg.test('kid is kid')); // true
console.log(reg.test('dik is dik')); // true
console.log(reg.test('kid is dik')); // false
console.log(reg.test('dik is kid')); // false

注意，如果编号越界了，则会被当成普通的表达式：

var reg = /(\w{3}) is \6/;
reg.test( 'kid is kid' ); // false
reg.test( 'kid is \6' );  // true

.String对正则表达式的支持

• search

查找字符串中是否有匹配正则表达式的字符串，有则返回字符串第一次出现时的位置，没有就返回null（无论是否在全局模式下都不影响返回结果）

var str = 'hello world hello';
var reg = /hello/;
var reg2 = /hello/g;
console.log(str.search(reg)); //返回 0
console.log(str.search(reg2));//返回 0

• match

 查找字符串中是否有匹配正则表达式的字符串，有则返回一个数组，包括字符串内容、位置，

如果设置了全局匹配则一次性返回所有符合正则表达式的字符串数组。

如果其中添加了分组，返回符合要求的字符串以及分组的一个数组，但如果同时开启全局匹配则不会在数组中添加分组内容

var str = 'hello world hello';
var reg1 = /hello/;
var reg2 = /hello/g;
var reg3 = /(he)llo/;
var reg4 = /(he)llo/g;
// 匹配字符串中符合正则表达式的字符串，并返回该字符串的一个数组，其中包括字符串内容、位置
// [ 'hello', index: 0, input: 'hello world hello', groups: undefined ]
console.log(str.match(reg1));
// 如果正则设置全局匹配，则一次性返回所有符合正则表达式的字符串数组
// [ 'hello', 'hello' ]
console.log(str.match(reg2));
// 如果其中添加了分组，返回符合要求的字符串以及分组的一个数组
// [
//   'hello',
//   'he',
//   index: 0,
//   input: 'hello world hello',
//   groups: undefined
// ]
console.log(str.match(reg3));
// 如果同时开启全局匹配则不会在数组中添加分组内容
// [ 'hello', 'hello' ]
console.log(str.match(reg4));

• split

 以某种形式分割字符串：

// 以某种形式分割字符串 split()
var str = "terry134briup156lisi12zhangsan";
// 当数字出现一次或多次时
var reg = /\d+/;
var result = str.split(reg);
console.log(result); // [ 'terry', 'briup', 'lisi', 'zhangsan' ]

• replace

满足正则表达式的内容被替换： 

// 满足正则表达式条件的内容将被替换
var str = 'javascript'
// 如果开启全局模式 则替换所有满足条件的字符
var reg = /javascript/;
// replace(正则表达式, 要替换的内容)
var result = str.replace(reg, 'java');
console.log(result); //java
console.log(str); //javascript

前瞻表达式

在正则表达式当中有个东西叫做前瞻，有的管它叫零宽断言：

 （JS原生不支持后瞻，在此不研究后瞻）

 正向前瞻的作用：

匹配字符 H 后的字符，如果是 i 则匹配成功（指的是后面一定要匹配 ？= 后的内容）

var str = 'Hello, Hi, I am Hilary.';
// 后面一定要匹配什么
var reg = /H(?=i)/g;
var newStr = str.replace(reg, "T");
console.log(newStr);//Hello, Ti, I am Tilary.

负向前瞻的作用： 

匹配字符 H 后的字符，如果是 i 则匹配失败（指的是后面一定不要匹配 ？！ 后的内容）

在此案例中匹配到 H 字符后不为 i 的 H 并将其通过replace替换成了T，而 H 侯紧跟 i 的则不受任何影响。

 var str = 'Hello, Hi, I am Hilary.';
// 后面一定不要匹配什么
var reg = /H(?!i)/g;
var newStr = str.replace(reg, "T");
console.log(newStr);//Tello, Hi, I am Hilary.