正则表达式

(?=p)就是p前面的那个位置

var result = /^^hello$$$/.test("hello");
console.log(result); 
// => true

/.^/

把12345678，变成12,345,678

使用(?=d{3}$)

var result = "12345678".replace(/(?=d{3}$)/g, ",");
console.log(result);
//12345,678

逗号出现的位置，要求后面3个数字一组，也就是d{3}至少出现一次

可以使用量词+

var result = "12345678".replace(/(?=(d{3})+$)/g, ",");
console.log(result);
//12,345,678

匹配位置不是开头(?!^)

var string1 = "12345678";
var string2 = "123456789";
var reg = /(?!^)(?=(d{3})+$)/g;
var result1 = string1.replace(reg, ",");
console.log(result1);
//12,345,678
var result2 = string2.replace(reg, ",");
console.log(result2);
//123,456,789

密码长度6-12位，由数字、小写字符和大写字母组成，但必须至少包括2种字符。

简化

不考虑“但至少包括2种字符”这个条件

var reg = /^[0-9A-Za-z]{6,12}$/;

判断是否含有某一种字符

如果要求必须包含数字，可以使用(?=.*[0-9])

var reg = /(?=.*[0-9])^[0-9A-Za-z]{6,12}$/;

同时包含具有两种字符

同时包含数字和小写字母，可以用(?=.*[0-9](?=.*[a-z]))

var reg = /(?=.*[0-9])(?=.*[a-z])^(0-9A-Za-z){6,12}$/;

同时包含数字和小写字母

同时包含数字和大写字母

同时包含小写字母和大写字母

同时包含数字、小写字母和大写字母

var reg = /((?=.*[0-9])(?=.*[a-z])|(?=.*[0-9])(?=.*[A-Z])|(?=.*[a-z])(?=.*[A-Z]))^[0-9A-Za-z]{6,12}$/;

括号提供分组

引用某个分组，有两种情形：在JS中引用，在正则表达式中应用

/a+/匹配连续出现的a，要匹配连续出现的ab时，需要使用/(ab)+/

括号提供分组功能，使量词+作用于ab这个整体

var regex = /(ab)+/g;
var string = "ababa abbb ababab";
console.log(string.match(regex));
//[ "abab", "ab", "ababab" ]

多选分支结构(p1|p2)中括号的作用是提供了子表达式的所有可能

I love JavaScript
I love Regular Expression

var regex = /^I love (JavaScript|Regular Expression)$/;
console.log( regex.test("I love JavaScript") );
console.log( regex.test("I love Regular Expression") );
// => true
// => true

括号的重要作用，可以进行数据提取，以及更强大的替换操作

匹配日期yyyy-mm-dd

提取数据

提取出年、月、日

var regex = /(d{4})-(d{2})-(d{2})/;
var string = "2018-06-18";
console.log(string.match(regex));
//[ "2018-06-18", "2018", "06", "18", index: 0, input: "2018-06-18" ]

match返回的一个数组，第一个元素是整体匹配结果，然后是各个分组（括号）匹配的内容，然后是匹配下标，最后是输入的文本。（正则是否有修饰符g，match返回的数组格式是不一样）

可以使用正则对象的exec方法

可以使用构造函数的全局属性$1至$9来获取

var regex = /(d{4})-(d{2})-(d{2})/;
var string = "2017-06-12";

regex.test(string); // 正则操作即可，例如
//regex.exec(string);
//string.match(regex);

console.log(RegExp.$1); // "2017"
console.log(RegExp.$2); // "06"
console.log(RegExp.$3); // "12"

替换

把yyyy-mm-dd格式，替换成mm/dd/yyyy

var regex = /(d{4})-(d{2})-(d{2})/;
var string = "2017-06-12";
var result = string.replace(regex, "$2/$3/$1");
console.log(result); 
// => "06/12/2017"

其中replace中第二个参数用$1、$2、$3指代相应的分组。等价于var regex=/(d{4})-(d{2})-(d{2})/

写一个正则支持匹配以下三种格式：

2016-06-12
2016-06-12
2016.06.12

要求分割符前后一致，使用反向引用

var regex = /d{4}(-|/|.)d{2}1d{2}/;
var string1 = "2017-06-12";
var string2 = "2017/06/12";
var string3 = "2017.06.12";
var string4 = "2016-06/12";
console.log( regex.test(string1) ); // true
console.log( regex.test(string2) ); // true
console.log( regex.test(string3) ); // true
console.log( regex.test(string4) ); // false

1，表示的引用之前的分组(-|/|.)。不管它匹配到什么（比如-），1都匹配那个同样的具体某个字符

2和3分别指代第二个和第三个分组

括号嵌套

以左括号（开括号）为准

var regex = /^((d)(d(d)))1234$/;
var string = "1231231233";
console.log( regex.test(string) ); // true
console.log( RegExp.$1 ); // 123
console.log( RegExp.$2 ); // 1
console.log( RegExp.$3 ); // 23
console.log( RegExp.$4 ); // 3

正则匹配模式

第一个字符是数字，比如说1，

第二个字符是数字，比如说2，

第三个字符是数字，比如说3，

接下来的是1，是第一个分组内容，那么看第一个开括号对应的分组是什么，是123，

接下来的是2，找到第2个开括号，对应的分组，匹配的内容是1，

接下来的是3，找到第3个开括号，对应的分组，匹配的内容是23，

最后的是4，找到第3个开括号，对应的分组，匹配的内容是3。

引用不存在的分组

反向引用，引用前面的分组，在正则里引用了不存在的分组，正则不会报错，只是匹配反向引用的字符本身

前面出现的分组，都会捕获它们匹配的数据，以便后续引用，因此也称它们是捕获型分组

非捕获分组?:p

var regex = /(?:ab)+/g;
var string = "ababa abbb ababab";
console.log(string.match(regex));
//[ "abab", "ab", "ababab" ]

trim方法是去掉字符串的开头和结尾的空白符

第一种，匹配到开头和结尾的空白符，然后替换成空白符

function trim(str) {
    return str.replace(/^s+|s+$/g, "")
}

第二种，匹配整个字符串，然后用引用来提取出相应的数据

function trim(str) {
    return str.replace(/^s*(.*?)s*$/g, "$1");
}

这里使用了惰性匹配*?，不然也会匹配最后一个空格之前的所有空格

function titleize(str) {
    return str.toLowerCase().replace(/(?:^|s)w/g, function (c) {
        return c.toUpperCase();
    })
}
console.log(titleize("my name is epeli"));
//My Name Is Epeli

思路是找到每个单词的首字母，这里不适用非捕获匹配也是可以的

function camelize(str) {
    return str.replace(/[-_s]+(.)?/g, function (match, c) {
        return c ? c.toUpperCase() : "";
    })
}
console.log(camelize("-moz-transform"));
//MozTransform

其中分组(.)表示首字母。单词的界定是，前面的字符可以是多个连字符、下划线以及空白符。
正则后面的？的目的，是为了应对str尾部的字符可能不是单词字符。

驼峰化的逆过程

function dasherize(str) {
    return str.replace(/([A-Z])/g,"-$1").replace(/[-_s]+/g,"-").toLowerCase();
}
console.log(dasherize("MozTransform"));
//-moz-transform

要求匹配

laoyao bye bye

不匹配

";
var string2 = "
laoyao bye bye
";
var string3 = "