JavaScript必会技能——正则表达式

摘要：语法参数必填项，字符串或正则表达式，该参数指定的地方分割可选该参数指定返回的数组的最大长度，如果设置了该参数，返回的子字符串不会多于这个参数指定的数组。该数组通过在指定的边界处将字符串分割成子字符串。把正则表达式拆分成小表达式。

RegExp 对象表示正则表达式，它是对字符串执行模式匹配的强大工具。

测试字符串内的模式。例如，可以测试输入字符串，以查看字符串内是否出现电话号码模式或信用卡号码模式。这称为数据验证。

替换文本。可以使用正则表达式来识别文档中的特定文本，完全删除该文本或者用其他文本替换它。

基于模式匹配从字符串中提取子字符串。可以查找文档内或输入域内特定的文本。

正则表达式有两种方法定义：

1.直接量语法

/pattern/attributes

2.创建 RegExp 对象的语法：

new RegExp(pattern, attributes);

参数：参数pattern是一个字符串，指定了正则表达式的模式；参数attributes是一个可选的参数，包含属性g，i，m，分别使用与全局匹配，不区分大小写匹配，多行匹配； 
返回值：一个新的RegExp对象，具有指定的模式和标志；

方括号包含一系列字符，可以匹配它所包含的任意字符；同时可以通过^符号来定义否定字符类

正则表达式中的特殊字符都有它们的特殊含义，所以当我们要匹配这些特殊字符本身时，需要对字符进行转义，转义只需要在字符前面加上，这些特殊字符包括$ ^ * + . [ ? { | ( ) 

1.test方法：该方法用于检测一个字符串是否匹配某个模式。

语法：RegExpObject.test(str)
参数：str是需要检测的字符串
返回值：如果字符串str中含有与RegExpObject匹配的文本的话，返回true，否则返回false

示例代码如下：

var str = "longen and yunxi";
console.log(/longen/.test(str)); // true
console.log(/longlong/.test(str)); //false

2.exec方法：该方法用于检索字符串中的正则表达式的匹配。

语法：RegExpObject.exec(str)
参数：str是需要检测的字符串
返回值：返回一个数组，存放匹配的结果，如果未找到匹配，则返回值为null

示例代码如下：

var str = "javascript html css";
console.log(/html/.exec(str)); // ["html", index: 11, input: "javascript html css"]
返回的数组的第一个元素是与正则表达式相匹配的文本，该方法还返回2个属性，index属性声明的是匹配文本的第一个字符的位置；input属性则存放的是被检索的字符串string。

// 假如没有找到的话，则返回null
console.log(/node/.exec(str)); // null

1.search方法：该方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的字符串。

语法：stringObject.search(regexp)
参数：regexp可以是在stringObject中检索的字符串，也可以是需要检索的RegExp对象
返回值：stringObject中第一个与regexp对象相匹配的子串的起始位置。如果没有找到任何匹配的子串，则返回-1；

示例代码如下：

var str = "hello world,hello world";
// 返回匹配到的第一个位置
console.log(str.search(/hello/)); // 0
// search方法不执行全局匹配，它将忽略标志g，同时它也没有regexp对象的lastIndex的属性，且总是从字符串开始位置进行查找，总是返回的是stringObject匹配的第一个位置。
console.log(str.search(/hello/g)); //0
console.log(str.search(/world/)); // 6

// 也可以是检索字符串中的字符
console.log(str.search("wo")); // 6

// 如果没有检索到的话，则返回-1
console.log(str.search(/longen/)); // -1

// 我们检索的时候 可以忽略大小写来检索
var str2 = "Hello";
console.log(str2.search(/hello/i)); // 0

2.match方法：该方法用于在字符串内检索指定的值，或找到一个或者多个正则表达式的匹配。该方法类似于indexOf()或者lastIndexOf(); 但是它返回的是指定的值，而不是字符串的位置。

语法：stringObject.match(regexp)
参数：regexp可以是在stringObject中检索的字符串，也可以是需要检索的RegExp对象
返回值：存放匹配成功的数组；如果没有找到任何的一个匹配，那么它将返回的是null。

示例代码如下：

var str = "hello world";
// 返回的数组内有三个元素，第一个元素的存放的是匹配的文本，还有二个对象属性；index属性表明的是匹配文本的起始字符在stringObject中的位置；input属性声明的是对stringObject对象的引用；
console.log(str.match("hello")); // ["hello", index: 0, input: "hello world"]
console.log(str.match("Hello")); // null
console.log(str.match(/hello/)); // ["hello", index: 0, input: "hello world"]

// 全局匹配也返回一个数组，但有些不一样；它的数组元素中存放的是 stringObject 中所有的匹配子串，而且也没有 index 属性或 input 属性。
var str2="1 plus 2 equal 3"
console.log(str2.match(/d+/g)); //["1", "2", "3"]

3.replace方法：该方法用于在字符串中使用一些字符替换另一些字符，或者替换一个与正则表达式匹配的子字符串。

语法：stringObject.replace(regexp/substr,replacement);
参数：regexp/substr可以是字符串或者是需要替换模式的RegExp对象；replacement可以是替换的文本或者是生成替换文本的函数。
返回值：返回替换后的新字符串。

字符串 stringObject 的 replace() 方法执行的是查找并替换的操作。它将在 stringObject 中查找与regexp 相匹配的子字符串，然后用 replacement 来替换这些子串。如果 regexp 具有全局标志 g，那么replace() 方法将替换所有匹配的子串。否则，它只替换第一个匹配子串。 
replacement可以是字符串，也可以是函数。如果它是字符串，那么每个匹配都将由字符串替换。但是 replacement 中的 $字符具有特定的含义。如下表所示，它说明从模式匹配得到的字符串将用于替换。

示例代码如下：

var str = "hello world";
// 使用字符串替换字符串
var s1 = str.replace("hello","a");
console.log(s1);// a world

// 使用正则替换字符串
var s2 = str.replace(/hello/,"b");
console.log(s2); // b world

// 使用正则全局替换字符串
var s3 = str.replace(/l/g,"");
console.log(s3); // heo word

// $1,$2 代表的是第一个和第二个子表达式相匹配的文本
// 子表达式需要使用小括号括起来,代表的含义是分组
var name = "longen    ,yunxi";
var s4 = name.replace(/(w+)s*,s*(w+)/,"$2 $1");
console.log(s4); // "yunxi,longen"

console.log("hello world".replace(/w/g, "$&")) //hello world
console.log("hello world".replace(/w/g, "$$")) //hello $orld
console.log("hello world".replace(/w/g, "$`")) //hello hello orld
console.log("hello world".replace(/w/g, "$"")) //hello orldorld

// replace 第二个参数也可以是一个function 函数
// 单词首字母大写
var name = "aaa bbb ccc";
var uw=name.replace(/w+/g, function(word){
    return word.substring(0,1).toUpperCase()+word.substring(1);}
);
console.log(uw) //Aaa Bbb Ccc


var name2 = "123cbc45678rtyu909876pjkl54321";
name2.replace(/d+/g,function(v){
    console.log(v); 
    /*
     * 第一次打印123
     * 第二次打印45678
     * 第三次打印909876
     * 第四次打印54321
     */
});
/*
 * 如下函数，回调函数参数一共有四个
 * 第一个参数的含义是 匹配的字符串
 * 第二个参数的含义是 正则表达式分组内容，没有分组的话，就没有该参数,
 * 如果没有该参数的话那么第四个参数就是undefined
 * 第三个参数的含义是 匹配项在字符串中的索引index
 * 第四个参数的含义是 原字符串
 */
 name2.replace(/(d+)/g,function(a,b,c,d){
    console.log(a);
    console.log(b);
    console.log(c);
    console.log(d);
    /*
     * 如上会执行四次，值分别如下(正则使用小括号，代表分组)：
     * 第一次： 123,123,0,123cbc45678rtyu909876pjkl54321
     * 第二次： 45678,45678,6,123cbc45678rtyu909876pjkl54321
     * 第三次： 909876,909876,15,123cbc45678rtyu909876pjkl54321
     * 第四次： 54321,54321,25,123cbc45678rtyu909876pjkl54321
     */
 });

4.split方法：该方法把一个字符串分割成字符串数组。

语法：stringObject.split(separator,howmany)
参数：
   1.separator[必填项]，字符串或正则表达式，该参数指定的地方分割stringObject; 
   2.howmany[可选] 该参数指定返回的数组的最大长度，如果设置了该参数，返回的子字符串不会多于这个参数指定的数组。如果没有设置该参数的话，整个字符串都会被分割，不考虑他的长度。
返回值：一个字符串数组。该数组通过在separator指定的边界处将字符串stringObject分割成子字符串。

示例代码如下：

var str="How are you doing today?"
console.log(str.split(" ")) //["How", "are", "you", "doing", "today?"]
console.log(str.split("")) //["H", "o", "w", " ", "a", "r", "e", " ", "y", "o", "u", " ", "d", "o", "i", "n", "g", " ", "t", "o", "d", "a", "y", "?"]
console.log(str.split(" ",3)) //["How", "are", "you"]

// 也可以使用正则表达式
console.log(str.split(/s+/)) //["How", "are", "you", "doing", "today?"]

Javascript中的正则表达式贪婪模式与非贪婪模式的区别是：被量词修饰的子表达式的匹配行为；贪婪模式在整个表达式匹配成功的情况下尽可能多的匹配；非贪婪模式在整个表达式匹配成功的前提下，尽可能少的匹配。

一些常见的修饰贪婪模式的量词如下：
{x,y}，{x,}，?，*和+

非贪婪模式就是在如上贪婪模式后加上一个问号（?），就可以变成非贪婪模式的量词；如下：
{x,y}?，{x,}?，??，*?，和+?

示例代码如下：

//贪婪模式，尽可能多的匹配
console.log("0123456789".replace(/d{3,6}/,"*")) //*6789

//非贪婪模式，尽可能少的匹配
console.log("0123456789".replace(/d{3,6}?/,"*")) //*3456789

分组，又称为子表达式。把正则表达式拆分成小表达式。

直接上代码：

//不分组，量词仅作用到最后一个字符(c)
console.log(/abc{2}/.test("abcabc")); // false
console.log(/abc{2}/.test("abcc")); //true

//分组，量词作用于整个括号里的子表达式
console.log(/(abc){2}/.test("abcabc")); // true
console.log(/(abc){2}/.test("abcc")); //false

分组经常和反向引用一起使用，反向引用在前面的replace方法就有了，只不过没有说他的概念，这里说一下：当一个正则表达式被分组后，每个分组自动被赋予一个组号，一左到右分别是 $1 $2…
再举个例子：

//格式化日期
var reg = /^(d{4})[/-](d{2})[/-](d{2})$/
console.log("2016/11/18".replace(reg, "$1年$2月$3日")) //2016年11月18日
console.log("2016-11-18".replace(reg, "$1年$2月$3日")) //2016年11月18日
console.log("2016-11-18".replace(reg, "$1$2$3")) //20161118

不是所有分组都能创建反向引用，有一种分组叫做非捕获性分组，非捕获性分组以(?:pattern)表示，在一些只需要分组匹配但是并不需要得到各个分组匹配的结果时，使用非捕获性分组可以提高匹配速度；非捕获分组的含义我们可以理解为如下：子表达式可以作为被整体修饰但是子表达式匹配的结果不会被存储；如下：

var reg = /(?:d{4})-(d{2})-(d{2})/
var date = "2012-12-21"
reg.test(date)
RegExp.$1  // 12
RegExp.$2  // 21

这里，(?:d{4})分组不会捕获任何字符串，所以$1为(d{2})捕获的字符串。

初学者第一次看到这个名词可能有点懵逼(我第一次也不懂)，这里说明一下。

零宽断言就是下结论，例如ab，正则：a(?=b)，匹配a并且向右看是b，得到的结果是a，断言不会在匹配的内容当中，如果是a(?=c)，则匹配不到任何内容，因为匹配a以后向右看并不是c。另外，零宽断言分两种：前瞻(Lookahead)和后顾(Lookbehind);但JavaScript只支持前瞻。

前瞻表达式的语法如下：

再两个例子：

// 获取字符串中以ing结尾的单词的前半部分
var str = "I love dancing but he likes singing";
var pattern = /w+(?=ing)/g;
var ans = str.match(pattern);
console.log(ans); // ["danc", "sing"]


// 获取第五位不是i的单词的前四位
var s = "I love dancing but he likes singing";
var pattern = /w{4}(?!i)/g;
var ans = s.match(pattern);
console.log(ans); // ["love", "like"]

正则表达式基础知识差不多这些够用了，后面就是多谢多运用。共勉！

最后推荐两个比较好的工具，能帮助我们写出更好更准确的正则表达式。
正则表达式图形化工具
正则表达式检测工具

JavaScript RegExp 对象
深入浅出的javascript的正则表达式学习教程