正则表达式基础知识，持续更新…

两个网站

正则可视化

正则入门三十分钟

基本内容

定义

正则描述了一种字符串的匹配的模式 ,可以用来检查一个字符串是否包含某个子串或者是替换某个子串;一般用于表单验证,数据过滤,格式检查,数据采集,数据隐藏.

元字符

所谓元字符是用来说明匹配类型的,比如

.	匹配换行符以外的任意字符
\w word	匹配数字，字母，下划线，汉字
\s space	匹配任意的空白符
\d digital	匹配0-9之间数字
\b border	匹配单词的开始或结束 作为边界
^	匹配字符串的开始，以XX开头
	^在[]里面表示否定，除了[]之外的
$	匹配字符串的结尾，以XX结尾

限定符

规定紧接着的匹配的数量，与全局匹配global不一样，这里的是单个

*	重复零次或更多
+	重复一次或更多
?	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多
{n,m}	重复n-m次
\	转义字符，匹配需要的元字符

处理选项

i ignoreCase	忽略大小写
m multiline	多行匹配
g global	全局匹配
lastIndex	当前表达式匹配内容的最后一个字符串的下一个位置
source	正则的文本字符串

以上代码演示

var str='cat ,greatacatbat cat'
console.log(str.replace(/(\bcat\b)/g,'*'))//* ,greatacatbat *

var str='123abc'
console.log(str.replace(/\d?/,'*'))       // *23abc
console.log(str.replace(/\d+/,'*'))       // *abc
console.log(str.replace(/\d{2,3}/,'*'))   // *abc

贪婪和懒惰

看上面的代码可知，限定符总是尽可能多的匹配，我们称之为贪婪 ，但是有时候不需要这么贪婪，反而需要的是懒惰，也就是尽少的匹配，那么？即可表示

*？	重复任意次，但尽少匹配
+？	重复最少一次，但尽少匹配
??	重复0或1次，但尽少匹配
{n,m}?	重复n-m次，但尽少匹配
{n,}?	重复至少n次，但尽少匹配

字符类

匹配自己规定的字符，一般用方括号[]，[abcd]匹配abcd中任意一个

这样前面的元字符可有[0-9]匹配\d [a-zA-Z0-9]匹配\w

分支条件 有时候不只是一种匹配规则，比如电话号码，那么就需要| 把不同的规则分开

0\d{2}-\d{8}|0\d{3}-\d{7}

匹配的就是两种不同的电话号码

反义

所谓反义就是匹配除了之外的所有

\W \D \S \B	与原来的相反
[^abcd]	匹配除abcd以外的任意字符

分组

重复单个字符直接加元字符；重复多个字符则需要用()括起来再加元字符

(\d{1,3}\.){3}

匹配1-3为数字加点 重复3次

调整分组 每个分组都可以用$数字表示，第一个即$1 这是在replace中表示；在正则自己中则用\数字

忽略分组 ?: 用来忽略组，原来的组就被忽略了，数字也就变化了

正向前瞻 (?=\d) 负向前瞻 (?!\d) 预测前方是否符合条件

 

var data='2014-02-12'
console.log(data.replace(/(\d{4})-(\d{2})-(\d{2})/,'$3/$2/$1')) //  12/02/2014

var number='123456789'
console.log(number.replace(/(\d{3})(?=\d{3})/g,'$1,'))   // 123,456,789

var str='foo foo bar'
console.log(/(\w+)\s\1/.test(str))   //true    在正则自己中用\数字表示分组

var one='a1b1c1'
console.log(one.replace(/[a-z]\d/g,'*'))   //***

/?:(\d+)/  //忽略此次分组

js中正则的使用属性

RegExp实例属性

这些属性基本没多大用，只是个属性而已，都能在正则的字面量或构造函数中得出

global ignoreCase lastIndex multiline source

js中的RegExp对象

javascript通过内置对象RegExp支持正则表达式两种方法实例化RegExp对象

字面量方法 var reg=/\d/gim

构造函数方法 var reg=new RegExp('\d','g')

RegExp的实例方法

exec方法 返回包含第一个匹配项信息的数组(没有则null)，返回结果有input属性(应用正则的字符串)和index属性(匹配项在字符串中位置)；对于exec而言，没有设置g index始终为第一个匹配的，设置g index则会依次从下一个开始；但是结果是一样的

var text="mom and dad and child"
var reg1=/mom( and dad( and child)?)?/gim
var result1=reg1.exec(text)

console.log(result1)    //["mom and dad and child", " and dad and child", " and child"]   index: 0  input: "mom and dad and child"
console.log(result1.index)  //0
console.log(result1.input)  //mom and dad and child
console.log(result1[0])     //mom
console.log(result1[1])     //and dad and child
console.log(result1[2])     //and child

test()方法 返回布尔值，检验字符串是否与正则相匹配，常与if语句，表单验证结合

toString方法 返回正则字面量

toLocaleString()方法 返回正则字面量

valueOf方法 返回的是正则本身 typeof 则为Object

var reg=/\d/
console.log(reg.test('123'))       // true

console.log(reg.toString())        // /\d/
console.log(reg.toString().length) //4
console.log(reg.toLocaleString())  // /\d/
console.log(typeof reg.valueOf())  // object

与正则相关的string的方法

search方法 接受一个参数：正则或字符串 返回的是第一个的索引，没有则null

split方法 字符串切割为数组

replace方法 两个参数：第一个参数为字符串或正则；第二个参数为字符串或函数；函数接受三个参数，match匹配的字符串、index匹配项在字符串位置、origin原字符串

var one='u3n12'
console.log(one.search(/\d/))  //3
console.log(one.split(''))   //[ "u", "3", "n", "1", "2"]
console.log(one.replace(/\d/g,'*'))
console.log(one.replace(/\d/g,function(match,index,origin){
return parseInt(match)+1    //u4n23
}))

match方法 接受一个参数：正则或RegExp对象 返回的是一个匹配文本有关的数组，没有则null

有g时，则全局匹配，返回数组存放字符串中所有匹配子串，没有input和index属性

没有g时，则非全局匹配，返回数组的第一个元素存放的是匹配文本，其余元素存放的是与正则的子表达式匹配的文本；数组两个对象属性，index和input，和正则的exec方法相似

var one='u3n12'
console.log(one.match(/\d/))    //["3"] index: 1, input: "u3n12"
console.log(one.match(/\d/g))   //["3", "1", "2"]

var text="mom and dad and child"
var reg1=/mom( and dad( and child)?)?/im
var reg2=/mom( and dad( and child)?)?/gim
console.log(text.match(reg1))  //["mom and dad and child", " and dad and child", " and         child"]  //index: 0 input: "mom and dad and child"
console.log(text.match(reg2))  //["mom and dad and child"]

比较exec和match

exec是正则表达式的方法；match是字符串的方法；但是返回结果都是数组

当没有子串时

exec结果不受g影响，返回的数组为第一项匹配；match返回的结果受g影响，当没有g则返回第一项匹配，当有g则返回整个数组

当有子串时

exec返回结果不受g影响，返回的是多项数组；match返回结果受g影响，当没有g则返回多项数组，当有g则只返回整个数组

讨论的两种情况
var str='mom234mom45'
var reg=/\w{3}/
var reg2=/\w{3}/gim
console.log(str.match(reg))   //["mom"]
console.log(reg.exec(str))    //["mom"]
console.log(str.match(reg2))  //["mom", "234", "mom"]
console.log(reg2.exec(str))   //["mom"]

一些实际例子

将ab,cd,ef 字母倒置

var name='ab,cd,ef'
var name2=name.split(';')  //分为数组
for(var i=0;i<name2.length;i++){
name2[i]=name2[i].replace(/(\w)(\w)/,"$2$1")   //遍历倒置
}
console.log(name2)  //ba,dc,fe