正则表达式

正则表达式

1.正则表达式的两种创建方式

• 正则表达式字面量方式

//第一种字面量创建方式（编译时创建）
var regex = /abc/; 

• 对象方式创建

 //对象方式创建（执行时创建）
var regex1 = new RegExp('abc');

2.正则表达式的修饰符

//igm是修饰符
var r = /abc/igm;

• i修饰符

默认情况下，正则对象区分字母的大小写，加上i修饰符以后表示忽略大小写（ignorecase）。

• g修饰符

默认情况下，第一次匹配成功后，正则对象就停止向下匹配了。g修饰符表示全局匹配（global），加上它以后，正则对象将匹配全部符合条件的结果，主要用于搜索和替换。

var regex = /x/g; //有g修饰符
var ss = 'x_x_x_x_';
console.log(regex.lastIndex) //输出当前从哪一位开始检索 0
console.log(regex.test(ss)); //检索结果 true
console.log(regex.lastIndex) //输出当前从哪一位开始检索 1
console.log(regex.test(ss)); //检索结果 true
console.log(regex.lastIndex) //输出当前从哪一位开始检索 3
console.log(regex.test(ss)); //检索结果 true
console.log(regex.lastIndex) //输出当前从哪一位开始检索 5
console.log(regex.test(ss)); //检索结果 true
console.log(regex.lastIndex) //输出当前从哪一位开始检索 7
console.log(regex.test(ss)); //检索结果 false

var regex = /x/; //无g修饰符
var ss = 'x_x_x_x_';
console.log(regex.lastIndex) //输出当前从哪一位开始检索 0
console.log(regex.test(ss)); //检索结果 true
console.log(regex.lastIndex) //输出当前从哪一位开始检索 0
console.log(regex.test(ss)); //检索结果 true
console.log(regex.lastIndex) //输出当前从哪一位开始检索 0
console.log(regex.test(ss)); //检索结果 true
console.log(regex.lastIndex) //输出当前从哪一位开始检索 0
console.log(regex.test(ss)); //检索结果 true
console.log(regex.lastIndex) //输出当前从哪一位开始检索 0
console.log(regex.test(ss)); //检索结果 true

带有g修饰符时，可以通过正则对象的lastIndex属性指定开始搜索的位置。

//修饰符g下可以修改lastIndex
var regex = /x/g;
var ss = 'x_x_x_x_'
regex.lastIndex = 7;//从第七个开始寻找
console.log(regex.test(ss));//查找不到false

• m修饰符

表示多行模式（multiline），会修改^{和$的行为。默认情况下（即不加m修饰符时），}和$匹配字符串的开始处和结尾处，加上m修饰符以后，^{和$还会匹配行首和行尾，即}和$会识别换行符（\n）。

2.1 每个修饰符都对应相应的属性

regex.ignoreCase; //是否忽略大小写
regex.lastIndex // 正则对象的lastIndex属性不仅可读，还可写。一旦手动设置了lastIndex的值，就会从指定位置开始匹配。但是，这只在设置了g修饰符的情况下，才会有效。
regex.source // "abc" 返回正则表达式的字符串形式（不包括反斜杠），该属性只读。

3.常用字符

正则表达式中那些有特殊含义的字符，如果要匹配它们本身，就需要在它们前面要加上反斜杠。比如要匹配加号，就要写成\+。正则模式中，需要用斜杠转义的，一共有12个字符：^、.、[、$、(、)、|、*、+、?、{和\\。

3.1开始结束字符

位置字符用来提示字符所处的位置，主要有两个字符。

• ^ 表示字符串的开始位置
• $ 表示字符串的结束位置

// test必须出现在开始位置
/^test/.test('test123') // true
// test必须出现在结束位置
/test$/.test('new test') // true
// 从开始位置到结束位置只有
test/^test$/.test('test') // true/^test$/.test('test test') // false

3.2或关系字符

竖线符号（|）在正则表达式中表示“或关系”（OR），即cat|dog表示匹配cat或dog。

/11|22/.test('911') // true

3.3类字符[]

表示有一系列字符可供选择，只要匹配其中一个就可以了。所有可供选择的字符都放在方括号内，比如[xyz] 表示x、y、z之中任选一个匹配。 下面代码表示，字符串“hello world”不包含a、b、c这三个字母中的任一个，而字符串“apple”包含字母a。

/[^abc]/.test('hello world') // true
/[^abc]/.test('bbc') // false
[0-9.,] //表示匹配是否包含0-9或'.'或','
[0-9a-fA-F] //表示匹配是否包含0-9或a-f或A-F
[a-zA-Z0-9-] //表示匹配是否包含a-z或A-Z或0-9或'-'
[1-31] //表示匹配是否包含0-3或'1'

3.4预定义模式

预定义模式指的是某些常见模式的简写方式。

• \d 匹配0-9之间的任一数字，相当于[0-9]。
• \D 匹配所有0-9以外的字符，相当于[^0-9]。
• \w 匹配任意的字母、数字和下划线，相当于[A-Za-z0-9_]。
• \W 除所有字母、数字和下划线以外的字符，相当于[^A-Za-z0-9_]。
• \s 匹配空格（包括制表符、空格符、断行符等），相等于[\t\r\n\v\f]。
• \S 匹配非空格的字符，相当于[^\t\r\n\v\f]。
• \b 匹配词的边界。
• \B 匹配非词边界，即在词的内部。

3.5模式的精确匹配次数

模式的精确匹配次数，使用大括号（{}）表示。{n}表示恰好重复n次，{n,}表示至少重复n次，{n,m}表示重复不少于n次，不多于m次

/lo{2}k/.test('look') // true
/lo{2, 5}k/.test('looook') // true

量词符用来设定某个模式出现的次数。

• ? 问号表示某个模式出现0次或1次，等同于{0, 1}。
• * 星号表示某个模式出现0次或多次，等同于{0,}。
• + 加号表示某个模式出现1次或多次，等同于{1,}。

3.6贪婪模式与非贪婪模式

?*+三个量词符，默认情况下都是最大可能匹配，即匹配直到下一个字符不满足匹配规则为止。这被称为贪婪模式。

• 贪婪模式

下面代码中，模式是/a+/，表示匹配1个a或多个a，那么到底会匹配几个a呢？因为默认是贪婪模式，会一直匹配到字符a不出现为止，所以匹配结果是3个a。

var s = 'aaa';s.match(/a+/) // ["aaa"]

• 非贪婪模式

如果想将贪婪模式改为非贪婪模式，可以在量词符后面加一个问号。

• *?：表示某个模式出现0次或多次，匹配时采用非贪婪模式。
• +?：表示某个模式出现1次或多次，匹配时采用非贪婪模式。

//+
var s = 'aaa';s.match(/a+/) // ["aaa"]
var s = 'aaa';s.match(/a+?/) // ["a"]
//*
var s = 'aaa';s.match(/a*/) // ["aaa"]
var s = 'aaa';s.match(/a*?/) // ["a"]

3.7非捕获组

普通的()表示是一个分组，但会存在不需要返回该组匹配的内容，即匹配的结果中不计入这个括号。

• (?:x)称为非捕获组（Non-capturing group）

var m = 'abc'.match(/(.)b(.)/);// ["abc", "a" , "c"]
var m = 'abc'.match(/(?:.)b(.)/);// ["abc", "c"]

3.8先行断言与后行断言

• 先行断言

先行断言指的是，x只有在y前面才匹配，必须写成/x(?=y)/。比如，只匹配百分号之前的数字，要写成/\d+(?=%)/。”先行否定断言“指的是，x只有不在y前面才匹配，必须写成/x(?!y)/。比如，只匹配不在百分号之前的数字，要写成/\d+(?!%)/。

//整数必须在%前面才匹配
/\d+(?=%)/.exec('100%')  // ["100"]
//整数必须不在%%前面才匹配
/\d+(?!%)/.exec('100%')  // ["10"]

• 后行断言

后行断言正好与先行断言相反，x只有在y后面才匹配，必须写成/(?<=y)x/。比如，只匹配美元符号之后的数字，要写成/(?<=\$)\d+/。”后行否定断言“则与”先行否定断言“相反，x只有不在y后面才匹配，必须写成/(?。比如，只匹配不在美元符号后面的数字，要写成/(?。

//整数必须在$后面才匹配
/(?<=\$)\d+/.exec('$100') // ["100"]
//整数必须不在$后面才匹配
/(?

4.正则表达式的exec方法

exec方法可以返回匹配结果。如果发现匹配，就返回一个数组，成员是每一个匹配成功的子字符串，否则返回null。如果正则表示式包含圆括号（即含有“组匹配”），则返回的数组会包括多个成员。第一个成员是整个匹配成功的结果，后面的成员就是圆括号对应的匹配成功的组。也就是说，第二个成员对应第一个括号，第三个成员对应第二个括号，以此类推。整个数组的length属性等于组匹配的数量再加1。

• input：整个原字符串。
• index：整个模式匹配成功的开始位置（从0开始计数）。

//exec方法
//exec匹配成功后返回数组的属性g修饰符
var r = /a(b+)a/g;
var arr = r.exec('_abbba_aba_');
console.log(arr); // ["abbba", "bbb"]
console.log(arr.index); // 1
console.log(arr.input); // "_abbba_aba_"

var arr = r.exec('_abbba_aba_');
console.log(arr); // ["aba", "b"]
console.log(arr.index); // 7
console.log(arr.input); // "_abbba_aba_"

---

js String和正则表达式相关的方法

1.字符串对象的match方法

字符串对象的match方法对字符串进行正则匹配，返回匹配结果。 如果正则表达式带有g修饰符，则该方法与正则对象的exec方法行为不同，会一次性返回所有匹配成功的结果。 设置正则表达式的lastIndex属性，对match方法无效，匹配总是从字符串的第一个字符开始。

//String的match方法
var ss = 'aabbbaaabaabbbbbbbaabbaccca';
var reg = /a(b+)a/g;
var arr = ss.match(reg);
console.log(arr);//["abbba", "aba", "abbbbbbba", "abba"]

2.字符串对象的replace方法

字符串对象的replace方法可以替换匹配的值。它接受两个参数，第一个是搜索模式，第二个是替换的内容。有g修饰符会替换全部匹配的。返回值是替换后的结果。replace方法的第二个参数可以使用美元符号$，用来指代所替换的内容。（$n只有在正则中有（）时才有用，$&表示查找到的整体内容，$n表示的是查找到的内容中的（）中的子内容）

• $& 指代匹配的子字符串。
• $` 指代匹配结果前面的文本。
• $' 指代匹配结果后面的文本。
• $n 指代匹配成功的第n组内容，n是从1开始的自然数。
• $$ 指代美元符号$。

var s1 = 'hello world';
console.log(s1.replace(/(\w+)\s(\w+)/, '[$&]'));//[hello world]
var s1 = 'hello world';
console.log(s1.replace(/(\w+)\s(\w+)/, '[$1]'));//[hello]
var s1 = 'hello world';
console.log(s1.replace(/(\w+)\s(\w+)/, '[$2]'));//[world]

replace方法的第二个参数还可以是一个函数，将每一个匹配内容替换为函数返回值。g修饰符有效

console.log('3 and 5'.replace(/[0-9]+/, function (match) {
    return 2 * match;
})); //6 and 5
console.log('3 and 5'.replace(/[0-9]+/g, function (match) {
    return 2 * match;
})); //6 and 10

3.字符串对象的split方法

字符串对象的split方法按照正则规则分割字符串，返回一个由分割后的各个部分组成的数组。 该方法接受两个参数，第一个参数是分隔规则，第二个参数是返回数组的最大成员数。

// 非正则分隔
'a,  b,c, d'.split(',')// [ 'a', '  b', 'c', ' d' ]
// 正则分隔，去除多余的空格
'a,  b,c, d'.split(/, */)// [ 'a', 'b', 'c', 'd' ]
// 指定返回数组的最大成员
'a,  b,c, d'.split(/, */, 2)[ 'a', 'b' ]

如果正则表达式带有括号，则括号匹配的部分也会作为数组成员返回。

'aaa*a*'.split(/(a*)/)// [ '', 'aaa', '*', 'a', '*' ]
'aaa*a*'.split(/a*/)// [ '', '*' , '*' ]