正则表达式括号的作⽤不管哪门语⾔中都有括号。正则表达式也是⼀门语⾔，⽽括号的存在使这门语⾔更为强⼤。
对括号的使⽤是否得⼼应⼿，是衡量对正则的掌握⽔平的⼀个侧⾯标准。
括号的作⽤，其实三⾔两语就能说明⽩，括号提供了分组，便于我们引⽤它。
引⽤某个分组，会有两种情形：在 JavaScript ⾥引⽤它，在正则表达式⾥引⽤它。
本章内容虽相对简单，但我也要写长点。
内容包括：
分组和分⽀结构
分组引⽤
反向引⽤
⾮捕获括号
相关案例
分组和分⽀结构
这⼆者是括号最直觉的作⽤，也是最原始的功能，强调括号内的正则是⼀个整体，即提供⼦表达式。
分组
我们知道 /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( st("I love JavaScript") );
console.log( st("I love Regular Expression") );
// => true
// => true
如果去掉正则中的括号，即：/^I love JavaScript|Regular Expression$/
匹配字符串是 "I love JavaScript" 和 "Regular Expression"，当然这不是我们想要的。
分组引⽤
这是括号⼀个重要的作⽤，有了它，我们就可以进⾏数据提取，以及更强⼤的替换操作。
⽽要使⽤它带来的好处，必须配合使⽤实现环境的 API。
以⽇期为例。假设格式是 yyyy-mm-dd 的，我们可以先写⼀个简单的正则：
var regex = /\d{4}-\d{2}-\d{2}/;
其可视化形式是：
然后再修改成括号版的：
var regex = /(\d{4})-(\d{2})-(\d{2})/;
其可视化形式是：
对⽐这两个可视化图⽚，我们发现，与前者相⽐，后者多了分组编号，如 Group #1。
其实正则引擎也是这么做的，在匹配过程中，给每⼀个分组都开辟⼀个空间，⽤来存储每⼀个分组匹配到的数据。
既然分组可以捕获数据，那么我们就可以使⽤它们。
提取数据
⽐如提取出年、⽉、⽇，可以这么做：
var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";
console.log( string.match(regex) );
// => ["2017-06-12", "2017", "06", "12", index: 0, input: "2017-06-12"]
NOTE： match 返回的⼀个数组，第⼀个元素是整体匹配结果，然后是各个分组（括号⾥）匹配的内容，然后是匹配下标，最后是输⼊的⽂本。另外，正则表达式是否有修饰符 g，match返回的数组格式是不⼀样的。
另外也可以使⽤正则实例对象的 exec ⽅法：
var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";
正则匹配括号里的内容console.log( (string) );
// => ["2017-06-12", "2017", "06", "12", index: 0, input: "2017-06-12"]
同时，也可以使⽤构造函数的全局属性 $1 ⾄ $9 来获取：
var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";
//(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 = place(regex, "$2/$3/$1");
console.log(result);
// => "06/12/2017"
其中 replace 中的，第⼆个参数⾥⽤ $1、$2、$3 指代相应的分组。等价于如下的形式：
var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";
var result = place(regex, function () {
return RegExp.$2 + "/" + RegExp.$3 + "/" + RegExp.$1;
});
console.log(result);
// => "06/12/2017"
也等价于：
var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";
var result = place(regex, function (match, year, month, day) {
return month + "/" + day + "/" + year;
});
console.log(result);
// => "06/12/2017"
反向引⽤
除了使⽤相应 API 来引⽤分组，也可以在正则本⾝⾥引⽤分组。但只能引⽤之前出现的分组，即反向引⽤。
还是以⽇期为例。
⽐如要写⼀个正则⽀持匹配如下三种格式：
2016-06-12
2016/06/12
2016.06.12
最先可能想到的正则是:
var regex = /\d{4}(-|\/|\.)\d{2}(-|\/|\.)\d{2}/;
var string1 = "2017-06-12";
var string2 = "2017/06/12";
var string3 = "2017.06.12";
var string4 = "2016-06/12";
console.log( st(string1) ); // true
console.log( st(string2) ); // true
console.log( st(string3) ); // true
console.log( st(string4) ); // true
其中 / 和 . 需要转义。虽然匹配了要求的情况，但也匹配 "2016-06/12" 这样的数据。
假设我们想要求分割符前后⼀致怎么办？此时需要使⽤反向引⽤：
var regex = /\d{4}(-|\/|\.)\d{2}\1\d{2}/;
var string1 = "2017-06-12";
var string2 = "2017/06/12";
var string3 = "2017.06.12";
var string4 = "2016-06/12";
console.log( st(string1) ); // true
console.log( st(string2) ); // true
console.log( st(string3) ); // true
console.log( st(string4) ); // false
其可视化形式是：
注意⾥⾯的 \1，表⽰的引⽤之前的那个分组 (-|\/|\.)。不管它匹配到什么（⽐如 -），\1 都匹配那个同样的具体某个字符。我们知道了 \1 的含义后，那么 \2 和 \3的概念也就理解了，即分别指代第⼆个和第三个分组。
看到这⾥，此时，恐怕你会有⼏个问题。
括号嵌套怎么办？
以左括号（开括号）为准。⽐如：
var regex = /^((\d)(\d(\d)))\1\2\3\4$/;
var string = "1231231233";
console.log( st(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"。
此正则的可视化形式是：
\10 表⽰什么呢？
另外⼀个疑问可能是，即 \10 是表⽰第 10 个分组，还是 \1 和 0 呢？
答案是前者，虽然⼀个正则⾥出现 \10 ⽐较罕见。测试如下：
var regex = /(1)(2)(3)(4)(5)(6)(7)(8)(9)(#) \10+/;
var string = "123456789# >#"
console.log( st(string) );
// => true
TIP：如果真要匹配 \1 和 0 的话，请使⽤ (?:\1)0 或者 \1(?:0)。
引⽤不存在的分组会怎样？
因为反向引⽤，是引⽤前⾯的分组，但我们在正则⾥引⽤了不存在的分组时，此时正则不会报错，只是匹配反向引⽤的字符本⾝。例如 \2，就匹配 "\2"。注意 "\2" 表⽰对 "2" 进⾏了转义。
var regex = /\1\2\3\4\5\6\7\8\9/;
console.log( st("\1\2\3\4\5\6\7\8\9") );
console.log( "\1\2\3\4\5\6\7\8\9".split("") );
Chrome 浏览器打印的结果：
分组后⾯有量词会怎样？
分组后⾯有量词的话，分组最终捕获到的数据是最后⼀次的匹配。⽐如如下的测试案例：
var regex = /(\d)+/;
var string = "12345";
console.log( string.match(regex) );
// => ["12345", "5", index: 0, input: "12345"]
从上⾯看出，分组 (\d) 捕获的数据是 "5"。
同理对于反向引⽤，也是这样的。测试如下：
var regex = /(\d)+ \1/;
console.log( st("12345 1") );
// => false
console.log( st("12345 5") );
// => true
⾮捕获括号
之前⽂中出现的括号，都会捕获它们匹配到的数据，以便后续引⽤，因此也称它们是捕获型分组和捕获型分⽀。
如果只想要括号最原始的功能，但不会引⽤它，即，既不在 API ⾥引⽤，也不在正则⾥反向引⽤。
此时可以使⽤⾮捕获括号 (?:p) 和 (?:p1|p2|p3)，例如本章第⼀个例⼦可以修改为：
var regex = /(?:ab)+/g;
var string = "ababa abbb ababab";
console.log( string.match(regex) );
// => ["abab", "ab", "ababab"]
同理，第⼆例⼦可以修改为：
var regex = /^I love (?:JavaScript|Regular Expression)$/;
console.log( st("I love JavaScript") );
console.log( st("I love Regular Expression") );
// => true
// => true
相关案例
⾄此括号的作⽤已经讲完了，总结⼀句话，就是提供了可供我们使⽤的分组，如何⽤就看我们的了。
字符串 trim ⽅法模拟
trim ⽅法是去掉字符串的开头和结尾的空⽩符。有两种思路去做。
第⼀种，匹配到开头和结尾的空⽩符，然后替换成空字符。如：
function trim(str) {
place(/^\s+|\s+$/g, '');
}
console.log( trim(" foobar ") );
// => "foobar"
第⼆种，匹配整个字符串，然后⽤引⽤来提取出相应的数据：
function trim (str) {
place(/^\s*(.*?)\s*$/g, "$1");
}
console.log( trim(" foobar ") );
// => "foobar"
这⾥使⽤了惰性匹配 *?，不然也会匹配最后⼀个空格之前的所有空格的
当然，前者效率⾼。
将每个单词的⾸字母转换为⼤写
function titleize (str) {
LowerCase().replace(/(?:^|\s)\w/g, function (c) {
UpperCase();
});
}
console.log( titleize('my name is epeli') );
// => "My Name Is Epeli"
思路是到每个单词的⾸字母，当然这⾥不使⽤⾮捕获匹配也是可以的。
驼峰化
function camelize (str) {
place(/[-_\s]+(.)?/g, function (match, c) {
return c ? c.toUpperCase() : '';
});
}
console.log( camelize('-moz-transform') );
/
/ => "MozTransform"
其中分组 (.) 表⽰⾸字母。单词的界定是，前⾯的字符可以是多个连字符、下划线以及空⽩符。正则后⾯的 ? 的⽬的，是为了应对 str 尾部的字符可能不是单词字符，⽐如 str 是 '-moz-transform '。
中划线化
function dasherize (str) {
place(/([A-Z])/g, '-$1').replace(/[-_\s]+/g, '-').toLowerCase();
}
console.log( dasherize('MozTransform') );
// => "-moz-transform"
驼峰化的逆过程。
HTML 转义和反转义
// 将HTML特殊字符转换成等值的实体
function escapeHTML (str) {
var escapeChars = {
'<' : 'lt',
'>' : 'gt',
'"' : 'quot',
'&' : 'amp',
'\'' : '#39'
};
place(new RegExp('[' + Object.keys(escapeChars).join('') +']', 'g'),
function (match) {
return '&' + escapeChars[match] + ';';
});
}
console.log( escapeHTML('<div>Blah blah blah</div>') );
// => "<div>Blah blah blah</div>";
其中使⽤了⽤构造函数⽣成的正则，然后替换相应的格式就⾏了，这个跟本章没多⼤关系。
倒是它的逆过程，使⽤了括号，以便提供引⽤，也很简单，如下：
// 实体字符转换为等值的HTML。
function unescapeHTML (str) {
var htmlEntities = {
nbsp: ' ',
lt: '<',
gt: '>',
quot: '"',
amp: '&',
apos: '\''
};
place(/\&([^;]+);/g, function (match, key) {
if (key in htmlEntities) {
return htmlEntities[key];
}
return match;
});
}
console.log( unescapeHTML('<div>Blah blah blah</div>') );
// => "<div>Blah blah blah</div>"
通过 key 获取相应的分组引⽤，然后作为对象的键。
匹配成对标签
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
Java正则提取中括号中的内容操作示例
« 上一篇
【IT专家】如何使用正则表达式获取括号内的内容?
下一篇 »
发表评论