JavaScript知识之正则表达式（RegExp）

JavaScript RegExp 正则表达式

描述

字面量和构造函数

有两种方法可以创建一个 ​​RegExp​​ 对象：一种是字面量，另一种是构造函数。

• 字面量
  由斜杠(/)包围而不是引号包围。
• 构造函数的字符串参数
  由引号而不是斜杠包围。

以下三种表达式都会创建相同的正则表达式：

/ab+c/i; //字面量形式
new RegExp('ab+c', 'i'); // 首个参数为字符串模式的构造函数
new RegExp(/ab+c/, 'i'); // 首个参数为常规字面量的构造函数

当表达式被赋值时，字面量形式提供正则表达式的编译（compilation）状态，当正则表达式保持为常量时使用字面量。例如当你在循环中使用字面量构造一个正则表达式时，正则表达式不会在每一次迭代中都被重新编译（recompiled）。

而正则表达式对象的构造函数，如 ​​new RegExp('ab+c')​​ 提供了正则表达式运行时编译（runtime compilation）。如果你知道正则表达式模式将会改变，或者你事先不知道什么模式，而是从另一个来源获取，如用户输入，这些情况都可以使用构造函数。

​​构造函数中的标志参数(flags)​​

从 ECMAScript 6 开始，当第一个参数为正则表达式而第二个标志参数存在时，​​new RegExp(/ab+c/, 'i')​​​ 不再抛出 ​​TypeError​​​ （​​"从另一个RegExp构造一个RegExp时无法提供标志"​​）的异常，取而代之，将使用这些参数创建一个新的正则表达式。

当使用构造函数创造正则对象时，需要常规的字符转义规则（在前面加反斜杠 ​​\​​）。

比如，以下是等价的：

var re = new RegExp("\\w+");
var re = /\w+/;

​​构造函数​​

• ​​RegExp()​​​创建一个新的 ​​RegExp​​ 对象。

​​静态属性​​

• ​​get RegExp[@@species\]​​该构造函数用于创建派生对象。
• ​​RegExp.lastIndex​​该索引表示从哪里开始下一个匹配

​​实例属性​​

• ​​RegExp.prototype.flags​​​含有 ​​RegExp​​ 对象 flags 的字符串。
• ​​RegExp.prototype.dotAll​​​​.​​ 是否要匹配新行（newlines）。
• ​​RegExp.prototype.global​​针对字符串中所有可能的匹配项测试正则表达式，还是仅针对第一个匹配项。
• ​​RegExp.prototype.ignoreCase​​匹配文本的时候是否忽略大小写。
• ​​RegExp.prototype.multiline​​是否进行多行搜索。
• ​​RegExp.prototype.source​​正则表达式的文本。
• ​​RegExp.prototype.sticky​​搜索是否是 sticky。
• ​​RegExp.prototype.unicode​​Unicode 功能是否开启。

​​实例方法​​

• ​​RegExp.prototype.compile()​​运行脚本的期间（重新）编译正则表达式。
• ​​RegExp.prototype.exec()​​在该字符串中执行匹配项的搜索。
• ​​RegExp.prototype.test()​​该正则在字符串里是否有匹配。
• ​​RegExp.prototype[@@match]()​​对给定字符串执行匹配并返回匹配结果。
• ​​RegExp.prototype[@@matchAll]()​​对给定字符串执行匹配，返回所有匹配结果。
• ​​RegExp.prototype[@@replace]()​​给定新的子串，替换所有匹配结果。
• ​​RegExp.prototype[@@search]()​​在给定字符串中搜索匹配项，并返回在字符串中找到字符索引。
• ​​RegExp.prototype[@@split]()​​通过将给定字符串拆分为子字符串，并返回字符串形成的数组。
• ​​RegExp.prototype.toString()​​​返回表示指定对象的字符串。重写​​Object.prototype.toString()​​方法。

​​示例​​

​​使用正则改变数据结构​​

下例使用 ​​String​​​ 的 ​​replace()​​ 方法去匹配姓名 first last 输出新的格式 last, first。

在替换的文本中，脚本中使用 ​​$1​​​ 和 ​​$2​​ 指明括号里先前的匹配.

let re = /(\w+)\s(\w+)/;
let str = "John Smith";
let newstr = str.replace(re, "$2, $1");
console.log(newstr);

这将显示 “Smith, John”.

​​使用正则来划分带有多种行结束符和换行符的文本​​

对于不同的平台（Unix，Windows等等），其默认的行结束符是不一样的. 而下面的划分方式适用于所有平台。

let text = 'Some text\nAnd some more\r\nAnd yet\rThis is the end'
let lines = text.split(/\r\n|\r|\n/)
console.log(lines) // logs [ 'Some text', 'And some more', 'And yet', 'This is the end' ]

注意：在正则表达式中，以竖线分割的子模式的顺序会影响匹配结果。

​​在多行文本中使用正则表达式​​

let s = "Please yes\nmake my day!";

s.match(/yes.*day/);
// Returns null

s.match(/yes[^]*day/);
// Returns 'yes\nmake my day'

​​使用带有 sticky 标志的正则表达式​​

带有​​sticky​​​标志的正则表达式将会从源字符串的​​RegExp.prototype.lastIndex​​位置开始匹配，也就是进行“粘性匹配”。

let str = '#foo#'
let regex = /foo/y

regex.lastIndex = 1
regex.test(str)      // true
regex.lastIndex = 5
regex.test(str)      // false (lastIndex is taken into account with sticky flag)
regex.lastIndex      // 0 (reset after match failure)

​​ sticky 标志和 global 标志的不同点​​

如果正则表达式有粘性 ​​y​​​ 标志，下一次匹配一定在 ​​lastIndex​​​ 位置开始；如果正则表达式有全局 ​​g​​​ 标志，下一次匹配可能在 ​​lastIndex​​ 位置开始，也可能在这个位置的后面开始。

re = /\d/y;
while (r = re.exec("123 456")) console.log(r, "AND re.lastIndex", re.lastIndex);

// [ '1', index: 0, input: '123 456', groups: undefined ] AND re.lastIndex 1
// [ '2', index: 1, input: '123 456', groups: undefined ] AND re.lastIndex 2
// [ '3', index: 2, input: '123 456', groups: undefined ] AND re.lastIndex 3
//   ... and no more match.

如果使用带有全局标志​​g​​​的正则表达式​​re​​，就会捕获字符串中的所有6个数字，而非3个

​​使用正则表达式和 Unicode 字符​​

正如上面表格提到的，​​\w​​​ 或 ​​\W​​​ 只会匹配基本的 ASCII 字符；如 ​​a​​​ 到 ​​z​​​、 ​​A​​​ 到 ​​Z​​​、 ​​0​​​ 到 ​​9​​​ 及 ​​_​​。

为了匹配其他语言中的字符，如西里尔（Cyrillic）或 希伯来语（Hebrew），要使用 ​​\uhhhh​​​，​​hhhh​​ 表示以十六进制表示的字符的 Unicode 值。

下例展示了怎样从一个单词中分离出 Unicode 字符。

let text = "Образец text на русском языке";
let regex = /[\u0400-\u04FF]+/g;

let match = regex.exec(text);
console.log(match[1]);  // prints "Образец"
console.log(regex.lastIndex);  // prints "7"

let match2 = regex.exec(text);
console.log(match2[1]);  // prints "на" [did not print "text"]
console.log(regex.lastIndex);  // prints "15"

// and so on

​​Unicode属性转义特性​​​引入了一种解决方案，它允许使用像\p{scx=Cyrl}这样简单的语句。这里有一个外部资源，用来获取 Unicode 中的不同区块范围：​​Regexp-unicode-block​​

​​从 URL 中提取子域名​​

var url = "http://xxx.domain.com";
console.log(/[^.]+/.exec(url)[0].substr(7)); // logs "xxx"

使用浏览器内建的​​URL API​​而非正则表达式来解析URL是更好的做法

//get url 
let addr = new URL("https://developer.mozilla.org/en-US/docs/Web/API/URL_API");
let host = addr.host;
let path = addr.pathname;

正则匹配符号大全

2、String 中的正则

1）match()

​​match()​​​接受一个正则表达式作为参数。当正则表达式不具有全局属性 g ，该方法和 ​​RegExp​​​ 的 ​​exec()​​ 方法执行结果一样，如正则有全局标志 g 时，返回一个包含所有匹配项的纯数组。

格式：​​str.match(pattern)​​​ 功能：
　　​​match​​ 在功能上与正则对象自带的方法​​exec​​很类似。
　　​​match​​根据匹配规则pattern匹配指定的字符串str，如果匹配成功则返回一个数组格式的结果用于存放匹配文本有关的信息，如果没有匹配到则返回null。

var text = "mom and dad and baby";
var pattern = /mom( and dad( and baby)?)?/i;

var matches = text.match(pattern);
console.log(matches);// 0: "mom and dad and baby", 1: " and dad and baby", 2: " and baby", groups: undefined, index: 0, input: "mom and dad and baby", length: 3
console.log(pattern.lastIndex); // 20

var pattern = /mom( and dad( and baby)?)?/gi;
matches = text.match(pattern);
console.log(matches);// ["mom and dad and baby"]
console.log(pattern.lastIndex); // 0

text = "vat ,bat, sat, fat";
pattern = /.at/;

//与 pattern.exec(text) 相同
matches = text.match(pattern);
console.log(matches);  //0: "vat", groups: undefined, index: 0, input: "vat ,vat, sat, fat", length: 1
console.log(pattern.lastIndex); //0


//如果match的匹配规则具有全局g属性，那么match返回的匹配结果，便是一个包含所有匹配结果的纯数组
pattern = /.at/g;
matches = text.match(pattern);
console.log(matches);  //["vat", "bat", "sat", "fat"]
console.log(pattern.lastIndex); //0

2）search()

该方法接受一个正则表达式或者字符串作为参数，从字符串开头向后查找。

格式：str.search(pattern)；

功能：根绝匹配规则pattern在字符串中检索指定的结果，如果检索到则返回该结果首字母在原字符中的索引，否则返回-1。其功能类似于indexOf，只是indexOf并不支持正则匹配。

该方法忽略全局修饰符g，也不支持lastIndex也就是意味着它不能被多次调用，一旦检索到结果，便会停止检索。

var text = "vat ,bat, sat, fat";
var pattern = /at/;

var pos = text.search(pattern);
console.log(pos);  // 1
console.log( text.search("t") ); // 2

3）replace()

格式：​​str.replace(pattern,given)​​

功能：根据匹配规则​​pattern​​​来用指定的内容​​given​​​去替换str或其部分字符。其中​​pattern​​可以是str中的部分字符也可以是一个正则表达式。

​​pattern​​​可以是字符串，也可以是正则表达式；​​given​​所代表替换的指定内容，既可以是字符串，也可以是一个回调函数。

​​replace()​​方法只会返回原字符被操作后的副本，并不会对原字符串进行改动。

如果 ​​pattern​​是字符串，那么只会替换第一个匹配的子字符串。要想替换所有匹配的子串，需要 pattern 是正则表达式，且带全局标志 g。

var text = "cat ,bat, sat, fat";
var pattern = "at";

var result = text.replace(pattern,"ond");
console.log(result);  // "cond ,bat, sat, fat"

pattern = /at/g;
result = text.replace(pattern,"ond"); 
console.log(result); //"cond ,bond, sond, fond"

var str = '世界上最遥远的距离 不是生与死的距离 而是我就站在你的面前 你却不知道我爱你。',
 st = ['死','爱','距离'],
 pattern = '',
 alt = '',
 str1= "";

for(var i=0;i<st.length;i++){

    pattern = new RegExp(st[i],'g');
    for(var j=0;j<st[i].length;j++){
        alt+='*';
    }

    str1 = str.replace(pattern,alt);
    alt = '';
}

console.log(str); //世界上最遥远的距离 不是生与死的距离 而是我就站在你的面前 你却不知道我爱你。
console.log(str1); //世界上最遥远的** 不是生与*的** 而是我就站在你的面前 你却不知道我*你。

given若是回调函数

在只有一个匹配项，即没有捕获组的情况下，

其格式为： function(match,index,input){}。

如果有多个捕获组，

其格式为： function(match,[$1…$9],index,input){}。

match： 表示当前匹配的结果
[$1 - $9]： 存在分组的情况下，表示当前 1 - 9 个分组的内容。
index： 当前匹配内容首字母在字符创中索引。
input ：进行匹配的原字符创。

function htmlEscape(text){
    return text.replace(/[<>"&]/g,function(match,index,input){
        switch(match){
            case "<": return "<";
            case ">": return ">";
            case "&": return "&";
            case "\"": return """;
        }
    });
}
console.log(htmlEscape("<p class=\"greeting\">Hello world!</p>"));// <p class="greeting">Hello world!</p>

var str = '2016/10/29';
var pattern = /(\d+)(\/)/g;
var data = str.replace(pattern,function(result,$1,$2){
    return $1+'.';
});
console.log(data); //2016.10.29
console.log(str.replace(pattern,"$1.")); //2016.10.29
console.log(str.replace(/\//g,".")); //2016.10.29

4）split()

格式：str.split(pattern,length)
功能：
　 根据规则 pattern 将字符串拆分为数组，拆分后的数组并不包含作为拆分依据的那个参数。
　 默认情况下是空字符进行拆分，也就是每个任意的字符作为一个数组元素。
　　pattern参数，可以是正则表达式，也可以是单纯的字符或字符串。
　　length参数，用于设置拆分数组后数组最大的长度（即数组元素的个数）。缺省该项，表示将字符全部拆分为数组。

var str = 'hellow world!';
console.log(str.split('')); //  ["h", "e", "l", "l", "o", "w", " ", "w", "o", "r", "l", "d", "!"]
console.log(str.split('',5)); // ["h", "e", "l", "l", "o"]
console.log(str.split(/o/g)); //  ["hell", "w w", "rld!"]

ref

[MDN RegExp](​​RegExp(正则表达式) - JavaScript | MDN (mozilla.org)​​)

[MDN URL Api](​​URL API - Web APIs | MDN (mozilla.org)​​)

[js 中的正则表达式RegExp](​​js 中的正则表达式RegExp - zhanglw - 博客园 (cnblogs.com)​​)