正则表达式的基本使用

一.表达式创建与属性

var reg = new RegExp("表达式","属性");
var reg = /表达式/属性;
属性:   
	i-->忽视大小写
	m -->多行匹配
	g--> 全局匹配
例：
	1. 基本使用
	var reg = /(\w)1(\w)2/img;
	
	2. 属性i
	var reg = /aBc/i;  // 正则表达式abc(不区分大小写)
	var str = 'abcd';
	reg.test(str);  // true 判断str中是否有连着的abc片段,然后返回布尔值

	3. 属性g
	var reg = /a/;
	var str = 'abc';
	str.match(reg); // 结果：["a"] --> 返回第一个匹配到的字符串
	var reg1 = /a/g;
	str,match(reg1); // 结果：["a","a"] --> 全部匹配出来

	4. 属性m
	var reg = /a/g;
	var str = 'abc\na'; // \n为换行
	str.match(reg); -->['a'] // 他还会认为这是一行
	var reg = /a/gm;
	str.match(reg); -->['a','a']   

二. 常用方法

match(x)： 把字符串中符合x的语句单独提出来,x可以是正则表达式
replace("x","y")：把x替换成y,y必须是字符串,x可以是正则表达式,y可以是方法,但必须返回字符串,没有访问全局的权利,也就是说只会改变遇见的第一个字符,但x是有正则表达式的全局g就可以
exec(): 检查字符串的值,并返回该值与该值坐标
test(): 检查字符串中的值,返回true和false
例1：把aabb换成bbaa
	var str = 'aabb';
	var reg = /(\w)\1(\w)\2/g;
	// 只有表达式中是子表达式时,$1代表第一个子表达式,$2代表第二个子表达式,依此类推
	str.replace(reg,"$2$2$1$1");
	// 函数会自动接收一个系统传来的值,用一个变量来接收,而后的变量用你第一个变量的名字来做后面传来
	// 的变量的第一个名字的开头,reg匹配出多少个就会执行多少次,如果你要换成"$",那么就写成"$$"
	str.repalce(reg,function($,$1,$2){
		return $2+$2+$1+$1;
	});
	
例2：获取匹配的值并获取该值的坐标
	var str = 'abcabc';
	var reg = /abc/g;
	 // 当你检测匹配时,光标会从0开始检测,遇到合格的值会打印出并打印位置,加入全局g后依次匹配,光标会
	 // 一直往后走,直到全部匹配完后,又会从头开始匹配,你可以利用lastIndex来改变光标位置
	console.log(reg.lastIndex);  // 0
	console.log(reg.lastIndex);  // 3
	console.log(reg.exec(str)); // ["abc",index:0]
	console.log(reg.lastIndex);  // ["abc",index:3]

三.元字符、量词、符号

小操作：
	因为存在 \ 把后面值的强制转成字符串（除了特殊字符），所以我们写出比较好看的代码，但是现在这种写法基本有``替换了
	
修改前：
document.body.innerHTML =
	 "<div>" +
		 "<span></span>" +
	"</div>"
	
修改后：
document.body.innerHTML = "
	<div>\
		<span></span>\
	</div>\
"

1. 元字符

1. \w === [0-9A-z_]         \s === [五个红色的元字符]
2. \b的匹配：
	var reg = /\bs/g;
	var str = 'adas sfw df';
	str.match(reg); // s 

3. \t的匹配：
	var reg = /\ts/;
	var str = 'as\ts'; 
	var str1 = 'a	s';
	reg.test(str); // true
	reg.test(str1); // false，必须要写出来,不然匹配不了

4. \u(Unicode编码)：有16层,用十六进制表示(第一层可以省略01，一般第一层可以表示平常所用)
	\u010000  -   \u01ffff // 第一层
	\u020000  -   \u02ffff // 第二层
	-
	-
	\u100000  -  \u100000 // 第十六层

5. 匹配xxxx这样的语句
	var str = 'aaaa';
	// 括号里的值叫做子表达式,后面的\1表示反调用第一个子表达式
	var reg = /(\w)\1\1\1/g;
	
6. 匹配aabb这样的语句
	var str = 'aabb';
	var reg = /(\w)\1(\w)\2/g;

2. 表达式

3. 量词

正向预查: b只是条件查找a的条件
	var str = 'abaa';
	var reg = /a(?=b)/g;
	str.match(reg); // ["a"]
	var reg1  = /a(?!b)/g;
	str.match(reg1); // ["a","a"]

贪婪原则：能多就多
	1. 基本使用
	var str = 'aaaa';
	var reg = /\w+/g;
	str.match(reg);
	
	2. 小知识点
	var str = 'abc';
	var reg = /\w*/g;
	var reg1 = /\d*/g;
	str.match(reg); // ["abc"," "]
	str.match(reg1); // [" "," "," "," "] 
	解析：因为有全局g,当字符串匹配第一个时,发现有可以匹配的值,遵守贪婪原则,就会打印,而结束后,有全局g的存在,使字符串还有逻辑上的空格,而第二个打印出四个空格是因为他每一个都发现没有匹配成功,所以出现了四个空格

非贪婪：能少则少,在量词后面加一个
	var reg = /a+?/g;