正则

元字符：

    水平制表符Tab
v    垂直制表符

　　换行

　　回车

     空字符

f      换页符

cX    ctrl+X

字符类：

[]　　a[ab]c=>aac、abc

[^]　　表示取反

范围类：

[a-z]

预定义类及边界：

.　　　任意字符（除回车和换行）

d　　数字　　   D　　非数字

s　　空白符　　S　　非空白符

w　  单词（字母、数字、下划线）　　W　　非单词

　　单词边界　　B　　非单词边界

^　　  开始

$　　  结束

量词：

？　　    0|1，出现0次或1次
+　　     1+，至少出现一次

*　　     0|1|1+，任意次

{n}　　   出现n次

{n,m}　　出现n~m次

{n,}　　  至少出现n次

贪婪模式、非贪婪模式：

d{3,6}　　  贪婪模式， 尽可能最多的匹配

d{3,6}?　　非贪婪模式，最少匹配

分组：

()　　分组

|　　 或

var str = '2013-16-17';
var re = /(d{4})-(d{2})-(d{2})/g;
str = str.replace(re, ($0, $1, $2, $3) => {
    console.log($0, $1, $2, $3);      // $0: 2013-16-17    $1: 2013   $2: 16   $3: 17
    return $1 + '.' + $2 + '.' + $3
})
str = str.replace(re, '$1.$2.$3')  // 2013.16.17　

前瞻：

exp(?=assert)　　正向前瞻

exp(?!assert)　　 负向前瞻

正向前瞻：

var str = 'a2*34vv';
var re = /w(?=d)/g; // 匹配(字母、数字、下划线) ，再往后看是不是(数字) ， 真正的替换是w
str.replace(re, '=');   // 结果： =2*=4vv

负向前瞻：

str.replace(/w(?!d)/g, '=')   // 再往后看不是数字，结果： a=*3===

　　

对象属性：

global　　 全局，默认false，/reg/g

ignore case　　  忽略大小写，默认false，/reg/i

multiline　　多行，默认false，/reg/m

lastIndex　　匹配完的下一个位置

source　　正则表达式的文本字符串

test、exec方式：

RegExp.prototype.test(str)    => reg.test(str)，返回Boolean

RegExp.prototype.exec(str)   => reg.exec(str)，返回Array

str = 'a1b2cc3d4'
re = /(?<firstNum>d).(d)/g  // 分组中的?<name>，表示为分组起个名字
re.exec(str)  // ["1b2", "1", "2", index: 1, input: "a1b2cc3d4", groups: {firNum:"1"}]

字符对象方法：

String.protoptype.search(reg)　　=> str.search(reg)，替换

String.prototype.match(reg)　　  => str.match(reg), 返回Array，当没有加g时，结果和exec一样，加了g，只显示匹配的

String.prototype.split(reg)　　     => str.split(reg),返回Array

重复子项（1或2......）：

re = (a)(b)(c)/2
re.test('abcb')   //true, 这里/2表示b,因此匹配成功

//使用场景
re = /w/w    //表示不同的字符，如：c9
re = (/w)/1  //表示相同，如:cc、99

找重复项最多的字符和个数

let str = 'aabbcccffccc';
str = str.split('').sort().join('');   // aabbccccccff

let re = /(w)1+/g;
let mArr = str.match(re)  // ["aa", "bb", "cccccc", "ff"]

let moreValue = ''
let len = 0

mArr.forEach((value, index) => {
    if (value.length > len) {
        len = value.length
        moreValue = value.charAt(0)
    }
})

console.log('最多的字符：' + moreValue + '，总共出现了' + len + '次');

　　

 千位符正则

let num1 = 123   // 123
let num2 = 1234 // 1,234
let num3 = 12345 // 12,345
let num4 = 123456 // 123,456
let num5 = 1234567 // 1,234,567
let num6 = 1234567.00012  //1,234,567.00012


let re_int = /(d)(?=(d{3})+$)/g
let re_float = /(d)(?=(d{3})+.)/g

function replace(num) {
    if (/./.test(num)) {
        console.log('float')
        return num.toString().replace(re_float, ($0, $1) => {
            return $1 + ','
        })
    } else {
        console.log('int')
        return num.toString().replace(re_int, ($0, $1) => {
            return $1 + ','
        })
    }

}