JavaScript RegExp 对象

// 1 创建正则表达式两种方式
// 1.1 用new
// 第1个参数模式是必须的 第2个模式修饰符参数可选
// i:忽略大小写 g:全局匹配 m:多行匹配
var box = new RegExp('Box');
var box = new RegExp('Box', 'gim');

// 1.2 用字面量的形式
// 两个反斜杠是正则表达式的字面量表示形成
var box = /Box/;
var box = /Box/gim;

// 2 使用正则表达式两种方式
// 2.1 test()
/*
* 只查找最多一个匹配，如果找到就立即返回true，否则返回false
*
* 如果为正则表达式设置了全局标志(g)，test()函数仍然只查找最多一个匹配，
* 不过我们再次调用该对象的test()函数将会从regExpObject.lastIndex索引位置处开始查找，从而找到下一个匹配。
* 如果想要重新使用test()函数从头开始查找，则需要手动将regExpObject.lastIndex的值重置为 0。
*
* regExpObject.lastIndex 本次匹配内容的最后一个字符的下一个索引位置。关闭全局 regExpObject.lastIndex 的值永远为 0。
*/
var pen = /Pen/i;
pen.test('pen'); // true
pen.test('pencil'); // true
pen.test('box'); // false

var pattern = /google/g;
var str = 'google google google';
pattern.test(str); // true
pattern.lastIndex; // 6
pattern.test(str); // true
pattern.lastIndex; // 13
pattern.lastIndex = 0;
pattern.test(str); // true
pattern.lastIndex; // 6

var pattern = /google/;
var str = 'google google google';
pattern.test(str); // true
pattern.lastIndex; // 0

// 2.2 exec()
/*
* 如果 exec() 找到了匹配的文本，则返回一个结果数组。
* 此数组的第 0 个元素是与正则表达式相匹配的文本，
* 第 1 个元素是与 RegExpObject 的第 1 个子表达式相匹配的文本（如果有的话），
* 第 2 个元素是与 RegExpObject 的第 2 个子表达式相匹配的文本（如果有的话），以此类推。
* RegExpObject 的 lastIndex 属性为匹配文本的最后一个字符的下一个位置。
*
* 如果 exec() 找不到匹配的文本，返回 null。lastIndex 属性重置为 0。
*
*/
var apple = /Apple/gi;
apple.exec('apple'); // ["apple"]
apple.exec('pineapple'); // ["apple"]
apple.exec('apple and pineapple'); // ["apple"]
apple.exec('pear'); // null

var email = /(\w+)@(\w+)\.(\w+)/g;
email.exec("zhang@yeah.net and dan@qq.com"); // ["zhang@yeah.net", "zhang", "yeah", "net"]
email.lastIndex; // 14
email.exec("zhang@yeah.net and dan@qq.com"); // ["dan@qq.com", "dan", "qq", "com"]
email.lastIndex; // 29
email.exec("zhang@yeah.net and dan@qq.com"); // null
email.lastIndex; // 0

// 3 使用String对象的正则表达式四种方法
// 3.1 match()
var bus = /Bus/i;
'bus'.match(bus); // ["bus"]
'Buses'.match(bus); // ["Bus"]
'This is a bus, it is my bus.'.match(bus); // ["bus"]
'These are buses, they are our buses.'.match(/Bus/gi); // ["bus", "bus"]
'car'.match(bus); // null

// 3.2 search()
var flower = /flower/ig;
'flower'.search(flower); // 0
'red flower and pink flower'.search(flower); // 4
'tree'.search(flower); // -1

// 3.3 replace(search, replacement)
// search 为正则表达式时 replacement可以使用 $1、$2、...、$99、$&、$`、$'、$$ 变量来动态确定用于替换的字符串内容
'stronger and stronger'.replace(/stronger/i, 'more'); // "more and stronger"
'stronger and stronger'.replace(/stronger/ig, 'more'); // "more and more"
'stronger and stronger'.replace(/and/, "$$"); // "stronger $ stronger"
'baidu google'.replace(/(.*)\s(.*)/, '$2 $1'); // "google baidu"

// 3.4 split()
var and = /And/i;
'pen And pencil and rule'.split(and); // ["pen ", " pencil ", " rule"]
'pen'.split(and); // ["pen"]
'and pencil'.split(and); // ["", " pencil"]
'pen and'.split(and); // ["pen ", ""]

// 4 正则表达式静态属性
// 所有静态属性只可读 匹配失败值不变 匹配成功值改变

// 4.1 RegExp.$1 - RegExp.$9
// 正则表达式是支持分组捕获的，最前面的9个匹配文本会依次存储在RegExp的静态属性$1-$9中。
/(\w)-(\w)-(\w)-(\w)-(\w)-(\w)-(\w)-(\w)-(\w)-(\w)/.test('a-b-c-d-e-f-g-h-i-j-k-l-m-n-o'); // true
RegExp.$1; // "a"
RegExp['$1']; // "a"
RegExp.$2;; // "b"
RegExp['$2']; // "b"
// ...
RegExp.$9; // "i"
RegExp['$9']; // "i"

// 4.2 RegExp.input
// 被匹配字符串 也可以表示成 RegExp['$_'] 或者 RegExp.$_
/pen/.test("pen and pencil"); // true
RegExp.input; // "pen and pencil"
RegExp['$_']; // "pen and pencil"
RegExp.$_; // "pen and pencil"

// 4.3 RegExp.leftContext
// 当前成功匹配文本之前的所有字符 也可以表示成 RegExp["$`"]
var pen = /pen/g;
pen.test("A pen and a pencil"); // true
RegExp.leftContext; // "A "
RegExp["$`"]; // "A "
pen.test("A pen and a pencil"); // true
RegExp.leftContext; // "A pen and a "
RegExp["$`"]; // "A pen and a "

// 4.4 RegExp.rightContext
// 当前成功匹配文本之后的所有字符 也可以表示成 RegExp["$'"]
var pen = /pen/g;
pen.test("A pen and a pencil"); // true
RegExp.rightContext; // " and a pencil"
RegExp["$'"]; // " and a pencil"
pen.test("A pen and a pencil"); // true
RegExp.rightContext; // "cil"
RegExp["$'"]; // "cil"

// 4.5 RegExp.lastMatch
// 最后匹配到的字符串 也可以表示成 RegExp['$&']
var pen = /pen/g;
pen.test("A pen and a pencil"); // true
RegExp.lastMatch; // "pen"
RegExp['$&']; // "pen"

// 4.6 RegExp.lastParen
// 最后带括号的子匹配 也可以表示成 RegExp["$+"]
/(\w)-(\w)-(\w)-(\w)-(\w)-(\w)-(\w)-(\w)-(\w)-(\w)/.test('a-b-c-d-e-f-g-h-i-j-k-l-m-n-o'); // true
RegExp.lastParen; // "j"
RegExp["$+"]; // "j"

// 5 正则表达式实例属性
// 5.1 regExpObject.global
// 正则表达式是否具有global标志
/google/.global; // false
/google/gim.global; // true

// 5.2 regExpObject.ignoreCase
// 正则表达式是否具有ignoreCase标志
/google/.ignoreCase; // false
/google/gim.ignoreCase; // true

// 5.3 regExpObject.multiline
// 正则表达式是否具有multiline标志
// IE不支持multiline属性 很多的浏览器也不支持该属性
/google/.multiline; // false
/google/gim.multiline; // true

// 5.4 regExpObject.source
// 正则表达式模式的文本内容
/google/.source; // "google"
/google/gim.source; // "google"

// 6 正则表达式模式
// ^n 以 n 开头
// n$ 以 n 结束

// n* 零个或多个 n
var patter = /go*gle/;
patter.test("ggle"); // true
patter.test("gogle"); // true
patter.test("google"); // true

// n+ 至少一个 n
var patter = /go+gle/;
patter.test("ggle"); // false
patter.test("gogle"); // true
patter.test("google"); // true

// n? 零个或一个 n
var patter = /go?gle/;
patter.test("ggle"); // true
patter.test("gogle"); // true
patter.test("google"); // false

// n{X} X 个 n
var patter = /go{2}gle/;
patter.test("gogle"); // false
patter.test("google"); // true
patter.test("gooogle"); // false

// n{X,} 至少 X 个 n
var patter = /go{2,}gle/;
patter.test("gogle"); // false
patter.test("google"); // true
patter.test("gooogle"); // true

// n{X,Y} 至少 X 个 n，最多 Y 个 n。
var patter = /go{2,3}gle/;
patter.test("gogle"); // false
patter.test("google"); // true
patter.test("gooogle"); // true
patter.test("goooogle"); // false

// ? 紧跟在*，+，?，{n}，{n,}，{n,m}）任何一个后面时，匹配模式是非贪婪的。
// 非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。
/[a-z]+/.exec('abcdef'); // ["abcdef"]
/[a-z]+?/.exec('abcdef'); // ["a"]

var greed = /[a-z]+/g;
greed.exec('abcdef'); // ["abcdef"]
greed.exec('abcdef'); // null
var lazy = /[a-z]+?/g;
lazy.exec('abcdef'); // ["a"]
lazy.exec('abcdef'); // ["b"]
lazy.exec('abcdef'); // ["c"]
lazy.exec('abcdef'); // ["d"]
lazy.exec('abcdef'); // ["e"]
lazy.exec('abcdef'); // ["f"]
lazy.exec('abcdef'); // null

'abcdef'.replace(/[a-z]+/, '贪婪'); // "贪婪"
'abcdef'.replace(/[a-z]+?/, '惰性'); // "惰性bcdef"

'abcdef'.replace(/[a-z]+/g, '贪婪'); // "贪婪"
'abcdef'.replace(/[a-z]+?/g, '惰性'); // "惰性惰性惰性惰性惰性惰性"

/[a-z]{3,6}/.exec('abcdef'); // ["abcdef"]
/[a-z]{3,6}?/.exec('abcdef'); // ["abc"]

// . 一个任意字符，除了换行和行结束符。
var patter = /g.gle/;
patter.test("ggle"); // false
patter.test("gogle"); // true
patter.test("g2gle"); // true
patter.test("google"); // false

// (pattern) 捕获性分组 匹配pattern并获取这一匹配
/(\d+)([a-z]+)(\d+)/.exec('123abc456'); // ["123abc456", "123", "abc", "456"]

// (pattern(pattern)) 嵌套分组 从外往内捕获
/(a?(b?(c?)))/.exec('abc'); // ["abc", "abc", "bc", "c"]

// (?:pattern) 非捕获性分组 匹配pattern但不获取匹配结果
/(\d+)(?:[a-z]+)(\d+)/.exec('123abc456'); // ["123abc456", "123", "456"]

// (?=pattern) 正向肯定预查 非获取匹配
var pattern = /goo(?=gle)/;
pattern.exec('good'); // null
pattern.exec('google'); // ["goo"]
RegExp.$1; // ""

var pattern = /pe(?=n)/g;
var str = 'a pen and a pencil';
pattern.exec(str); // ["pe"]
pattern.lastIndex; // 4
pattern.exec(str); // ["pe"]
pattern.lastIndex; // 14
pattern.exec(str); // null
pattern.lastIndex; // 0

// x|y 匹配x或y

// [abc] 方括号之间的任何一个字符，方括号内的字符可以是任何字符或字符范围。
var patter = /g[0-9a-zAB]gle/;
patter.test("ggle"); // false
patter.test("gogle"); // true
patter.test("g2gle"); // true
patter.test("gAgle"); // true
patter.test("gBgle"); // true
patter.test("google"); // false
patter.test("gABgle"); // false

// [A-Z] A-Z中的任意一个字符
// [a-z] a-z中的任意一个字符
// [A-z] A-z中的任意一个字符
// [0-9] 0-9中的任意一个数字
// [^abc] 不在方括号之间的任意一个字符
var patter = /g[^12]gle/;
patter.test("ggle"); // false
patter.test("gogle"); // true
patter.test("g2gle"); // false
patter.test("google"); // false
// \b 一个单词边界
// \B 一个单词非边界
// \d 一个数字
// \D 一个非数字
// \s 匹配任何空白字符，包括空格、制表符、换页符等等。
// \S 匹配任何非空白字符。
// \w 一个单词字符，包括：a-z、A-Z、0-9，以及下划线_ 。
// \W 一个非单词字符

正则表达式速查表