正则表达式JS-1212

目录

新建正则表达式有两种方法。一种是使用字面量，以斜杠表示开始和结束。

	//方法1：字面量
	var reg = /xyz/;
	//方法2:构造函数 new RegExp('正则表达式对象','修饰符)
	var reg2=new RegExp("/xyz","g");
	//使用构造函数时写正则内容用到预定义模式，需要使用'\'转义\
	var reg=/\d*\;
	var reg=new RegExp('/\\d*/');

修饰符

修饰符（modifier）表示模式的附加规则，放在正则模式的最尾部。修饰符可以单个使用，也可以多个一起使用:

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

   	var regex = /b/;
   	var str = 'abba';
   	regex.test(str); // true
   	regex.test(str); // true
   	regex.test(str); // true
   	
   	var regex = /b/g;
   	var str = 'abba';
   	regex.test(str); // true
   	regex.test(str); // true
   	regex.test(str); // false
   

2. i修饰符，忽略大小写。默认情况下，正则对象区分字母的大小写。

   /abc/.test('ABC') // false
   /abc/i.test('ABC') // true
   

3. m修饰符，表示多行模式（multiline）。

实例方法

1. RegExp.prototype.test()

返回一个布尔值，表示当前模式是否能匹配参数字符串。

/cat/.test('cats and dogs') // true,判断字符串中是否有cat
//如果正则表达式带有g修饰符，则每一次test方法都从上一次结束的位置开始向后匹配。
var r = /x/g;
var s = '_x_x';

r.lastIndex // 0
r.test(s) // true

r.lastIndex // 2
r.test(s) // true

r.lastIndex // 4
r.test(s) // false

上面代码的正则表达式使用了g修饰符，表示是全局搜索，会有多个结果。接着，三次使用test方法，每一次开始搜索的位置都是上一次匹配的后一个位置。

2. RegExp.prototype.exec()

用来返回匹配结果。如果发现匹配，就返回一个数组，成员是匹配成功的子字符串，否则返回null。

var s = '_x_x';
var r1 = /x/;
var r2 = /y/;

r1.exec(s) // ["x"]
r2.exec(s) // null
//如果正则表达式加上g修饰符，则可以使用多次exec()方法，下一次搜索的位置从上一次匹配成功结束的位置开始。
var reg = /a/g;
var str = 'abc_abc_abc'

var r1 = reg.exec(str);
r1 // ["a"]
r1.index // 0
reg.lastIndex // 1

var r2 = reg.exec(str);
r2 // ["a"]
r2.index // 4
reg.lastIndex // 5

var r3 = reg.exec(str);
r3 // ["a"]
r3.index // 8
reg.lastIndex // 9

var r4 = reg.exec(str);
r4 // null
reg.lastIndex // 0

字符串实例方法

1. String.prototype.match()

与 **exec()**方法很相似，exec()方法匹配成功返回一个元素， match() 匹配成功返回一个数组，匹配失败返回null。

//默认模式
console.log(/x/.exec("_x_xy"));//['x', index: 1, input: '_x_xy', groups: undefined]
console.log('_x_xy'.match(/x/));//['x', index: 1, input: '_x_xy', groups: undefined]
// 全局模式
console.log(/x/g.exec("_x_xy"));//['x', index: 1, input: '_x_xy', groups: undefined]
console.log('_x_xy'.match(/x/g));//['x', 'x']

var str="12[ab]";
//非全局模式下，返回的数组。第一个元素就是匹配到的元素，第二个之后是匹配的分组元素。
console.log(str.match(/(\d+)\[(\w+)\]/));//['12[ab]', '12', 'ab', index: 0, input: '12[ab]', groups: undefined]
console.log(str.match(/(\d+)\[(\w+)\]/g));//['12[ab]'];

2. String.prototype.search()

字符串对象的search方法，返回第一个满足条件的匹配结果在整个字符串中的位置。如果没有任何匹配，则返回-1。

'_x_x'.search(/x/);// 1

3. String.prototype.replace()

字符串对象的replace方法可以替换匹配的值。它接受两个参数，第一个是正则表达式，表示搜索模式，第二个是替换的内容。
字符串方法中，替换的是第一个符合条件的元素；在正则表达式中，如果不加g修饰符，就替换第一个匹配成功的值，否则替换所有匹配成功的值。

console.log('aaa'.replace('a', 'b'));//只替换第一个满足条件的
console.log('aaa'.replace(/a/, 'b'));//~
console.log('aaa'.replace(/a/g, 'b'));//替换全部满足条件的值

var str="3[ab]2[cd]"; 
console.log(str.match(/(\d+)\[(\w+)\]/g));//['3[ab]','2[cd]'];
str=str.replace(/(\d+)\[(\w+)\]/g,function(t,$1,$2){
   return  $2.repeat($1);
});
console.log(str);//"abababcdcd"

4. String.prototype.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' ]

//以指定元素分割
var str="abcdef";
console.log(str.split(/b|d/));//['a', 'c', 'ef']

预定义模式

• \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]。

字符类

字符类（class）表示有一系列字符可供选择，只要匹配其中一个就可以了。所有可供选择的字符都放在方括号内，比如[xyz] 表示x、y、z之中任选一个匹配。

/[abc]/.test('hello world') // false
/[abc]/.test('apple') // true

1. 脱字符（^）

如果方括号内的第一个字符是[^]，则表示除了字符类之中的字符，其他字符都可以匹配。比如，[^xyz]表示除了x、y、z之外都可以匹配。

/[^abc]/.test('bbc news'); // true
/[^abc]/.test('bbc'); // false

如果方括号内没有其他字符，即只有[^]，就表示匹配一切字符，其中包括换行符。相比之下，点号作为元字符（.）是不包括换行符的。

注意，脱字符只有在字符类的第一个位置才有特殊含义，否则就是字面含义。

2. 连字符（-）

对于连续序列的字符，连字符（-）用来提供简写形式，表示字符的连续范围。比如，[abc]可以写成[a-c]，[0123456789]可以写成[0-9]，同理[A-Z]表示26个大写字母。

元字符

1. 点字符（.)

点字符（.）匹配除回车（\r）、换行(\n) 、行分隔符（\u2028）和段分隔符（\u2029）以外的所有字符。

2. 位置字符

1. ^：表示字符串开始的位置
2. $：表示字符串结束的位置

// test必须出现在开始位置
/^test/.test('test123') // true

// test必须出现在结束位置
/test$/.test('new test') // true

// 从开始位置到结束位置只有test
/^test$/.test('test') // true
/^test$/.test('test test') // false

3. 选择符（|）

竖线符号（|）在正则表达式中表示“或关系”（OR）.

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

重复类与量词符

1. 重复类

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

2.量词符

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

贪婪匹配与非贪婪匹配

/a+/,/a*/,a?/，贪婪匹配是指一直匹配到a不出现为止;
非贪婪匹配是指在贪婪匹配结尾后+?，即:/a+?/,/a*?/,/a??/

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

群组

正则表达式的括号表示分组匹配，括号中的模式可以用来匹配分组的内容。

/fred+/.test('fredd') // true，d+表示只重复字母d
/(fred)+/.test('fredfred') // true.重复fred这个词
//分组捕获
'abcabc'.match(/(.)b(.)/);
// ['abc', 'a', 'c']

1. 断言,按照条件查找

1.后置肯定断言:(?=n)
x(?=y) x只有在y前面才匹配 ，括号中的y是不会返回的.
2.后置否定断言:(?!n)
x(?!y) x只有不在y前面才匹配
3. 前置肯定断言:(?<=n)
(?<=y)x 只有在y后面的x才匹配
4.前置否定断言:(?<!n)
(?<!y)x 只有不在y后面的x才匹配