Detailed explanation of JavaScript regular expressions that everyone knows-JS Tutorial-php.cn

If this is a summary about regular expressions, I prefer to regard it as a manual.

Three major methods of RegExp

The RegExp in this article uses direct quantity syntax: /pattern/attributes. There are three options for attributes, i, m and g. m (multi-line matching) is not commonly used and can be omitted directly, so a pattern (matching pattern) can be expressed as follows:

var pattern = /hello/ig;

Copy after login

i (ignore) means not case sensitive ( Local searchmatch), which is relatively simple and will not be described in the following examples; g (global) means global (search match), that is, continue to search after finding one, which is relatively complicated. The following methods will be particularly introduce.

Since they are the three major methods of RegExp, they are all in the format of pattern.test/exec/complie.

test

Main function: detect whether the specified string contains a certain substring (or matching pattern) and return true or false.

The example is as follows:

var s = &#39;you love me and I love you&#39;;
var pattern = /you/;
var ans = pattern.test(s);
console.log(ans); // true

Copy after login

If attributes use g, you can continue to search, which will also involve the lastIndexattribute (refer to the introduction of g in exec).

exec

Main function: Extract the required substring (or matching pattern) in the specified string and return a Array stores the matching results; if not, null is returned. (You can also write your own method Loop to extract all or specified index data)

exec can be said to be an upgraded version of test, because it can not only detect, but also directly extract the results after detection.

The example is as follows:

var s = &#39;you love me and I love you&#39;;
var pattern = /you/;
var ans = pattern.exec(s);
console.log(ans); // ["you", index: 0, input: "you love me and I love you"]
console.log(ans.index); // 0
console.log(ans.input); // you love me and I love you

Copy after login

The output is very interesting. The 0th element of this array is the text that matches the regular expression, the 1st element is the text that matches the 1st subexpression of RegExpObject (if any), the 2nd element is the text that matches the 2nd subexpression of RegExpObject (if any), and so on.

What is "text that matches a subexpression"? Look at the following example:

var s = &#39;you love me and I love you&#39;;
var pattern = /y(o?)u/;
var ans = pattern.exec(s);
console.log(ans);   // ["you", "o", index: 0, input: "you love me and I love you"]
console.log(ans.length) // 2

Copy after login

The so-called subexpression is the thing inside () in pattern (for details, please refer to the introduction of subexpressions below). Looking at the array length in the above example, it is 2! ! index and input are just array attributes (the above output in chrome may be misleading).

In addition to the array elements and length properties, the exec() method also returns two properties. The index attribute declares the position of the first character of the matched text. The input attribute stores the retrieved string string. We can see that when calling the exec() method of the non-global RegExp object, the array returned is the same as the array returned by calling the String.match() method .

If you use the "g" parameter, the working principle of exec() is as follows (still the above example ps: if test uses the g parameter it is similar):

Find the first "you" and store its position
If you run exec() again, start retrieval from the stored position (lastIndex) and find the next "you" and store it Location

The behavior of exec() is a little more complicated when the RegExpObject is a global regular expression. It starts retrieving the string string at the character specified by the RegExpObject's lastIndex property. When exec() finds text that matches an expression, it sets the RegExpObject's lastIndex property to the position next to the last character of the matching text after the match. This means that we can iterate through all matching text in a string by calling the exec() method repeatedly. When exec() no longer finds matching text, it returns null and resets the lastIndex property to 0. The lastIndex attribute is introduced here, which only works when combined with g and test (or g and exec). It is an attribute of pattern, a integer, indicating the character position where the next matching begins.

The example is as follows:

var s = &#39;you love me and I love you&#39;;
var pattern = /you/g;
var ans;
do {
  ans = pattern.exec(s);
  console.log(ans);
  console.log(pattern.lastIndex);
}
while (ans !== null)

Copy after login

The result is as follows:

It should be easy to understand. When the third loop is performed, " you", so null is returned, and the lastIndex value also becomes 0.

如果在一个字符串中完成了一次模式匹配之后要开始检索新的字符串（仍然使用旧的pattern），就必须手动地把 lastIndex 属性重置为 0。

compile

主要功能：改变当前匹配模式（pattern）

这货是改变匹配模式时用的，用处不大，略过。详见JavaScript compile() 方法

String 四大护法

和RegExp三大方法分庭抗礼的是String的四大护法，四大护法有些和RegExp三大方法类似，有的更胜一筹。

既然是String家族下的四大护法，所以肯定是string在前，即str.search/match/replace/split形式。

既然是String的方法，当然参数可以只用字符串而不用pattern。

主要功能：搜索指定字符串中是否含有某子串（或者匹配模式），如有，返回子串在原串中的初始位置，如没有，返回-1。

是不是和test类似呢？test只能判断有木有，search还能返回位置！当然test()如果有需要能继续找下去，而search则会自动忽略g（如果有的话）。实例如下：

var s = &#39;you love me and I love you&#39;;
var pattern = /you/;
var ans = s.search(pattern);
console.log(ans);  // 0

Copy after login

话说和String的indexOf方法有点相似，不同的是indexOf方法可以从指定位置开始查找，但是不支持正则。

match

主要功能：和exec类似，从指定字符串中查找子串或者匹配模式，找到返回数组，没找到返回null

match是exec的轻量版，当不使用全局模式匹配时，match和exec返回结果一致；当使用全局模式匹配时，match直接返回一个字符串数组，获得的信息远没有exec多，但是使用方式简单。

实例如下：

var s = &#39;you love me and I love you&#39;;
console.log(s.match(/you/));    // ["you", index: 0, input: "you love me and I love you"]
console.log(s.match(/you/g));   // ["you", "you"]

Copy after login

replace

主要功能：用另一个子串替换指定字符串中的某子串（或者匹配模式），返回替换后的新的字符串 str.replace(‘搜索模式’,'替换的内容’) 如果用的是pattern并且带g，则全部替换；否则替换第一处。

实例如下：

var s = &#39;you love me and I love you&#39;;
console.log(s.replace(&#39;you&#39;, &#39;zichi&#39;)); // zichi love me and I love you
console.log(s.replace(/you/, &#39;zichi&#39;)); // zichi love me and I love you
console.log(s.replace(/you/g, &#39;zichi&#39;));    // zichi love me and I love zichi

Copy after login

如果需要替代的内容不是指定的字符串，而是跟匹配模式或者原字符串有关，那么就要用到$了（记住这些和$符号有关的东东只和replace有关哦）。

怎么用？看个例子就明白了。

var s = &#39;I love you&#39;;
var pattern = /love/;
var ans = s.replace(pattern, &#39;$`&#39; + &#39;$&&#39; + "$&#39;");
console.log(ans); // I I love you you

Copy after login

没错，’$`’ + ‘$&’ + “$’”其实就相当于原串了！

replace的第二个参数还能是函数，看具体例子前先看一段介绍：

注意：第一个参数是匹配到的子串，接下去是子表达式匹配的值，如果要用子表达式参数，则必须要有第一个参数（表示匹配到的串），也就是说，如果要用第n个参数代表的值，则左边参数都必须写出来。最后两个参数跟exec后返回的数组的两个属性差不多。

var s = &#39;I love you&#39;;
var pattern = /love/;
var ans = s.replace(pattern, function(a) {　　// 只有一个参数，默认为匹配到的串（如还有参数，则按序表示子表达式和其他两个参数）
  return a.toUpperCase();
});
console.log(ans); // I LOVE you

Copy after login

split

主要功能：分割字符串

字符串分割成字符串数组的方法（另有数组变成字符串的join方法）。直接看以下例子：

var s = &#39;you love me and I love you&#39;;
var pattern = &#39;and&#39;;
var ans = s.split(pattern);
console.log(ans);   // ["you love me ", " I love you"]

Copy after login

如果你嫌得到的数组会过于庞大，也可以自己定义数组大小，加个参数即可：

var s = &#39;you love me and I love you&#39;;
var pattern = /and/;
var ans = s.split(pattern, 1);
console.log(ans);   // ["you love me "]

Copy after login

RegExp 字符

\s 任意空白字符 \S相反空白字符可以是：空格符 (space character) 制表符 (tab character) 回车符 (carriage return character) 换行符 (new line character) 垂直换行符 (vertical tab character) 换页符 (form feed character)
\b是正则表达式规定的一个特殊代码，代表着单词的开头或结尾，也就是单词的分界处。虽然通常英文的单词是由空格，标点符号或者换行来分隔的，但是\b并不匹配这些单词分隔字符中的任何一个，它只匹配一个位置。（和^ $ 以及零宽断言类似）
\w 匹配字母或数字或下划线 [a-z0-9A-Z_]完全等同于\w

贪婪匹配和懒惰匹配

什么是贪婪匹配？贪婪匹配就是在正则表达式的匹配过程中，默认会使得匹配长度越大越好。

var s = &#39;hello world welcome to my world&#39;;
var pattern = /hello.*world/;
var ans = pattern.exec(s);
console.log(ans)  // ["hello world welcome to my world", index: 0, input: "hello world welcome to my world"]

Copy after login

以上例子不会匹配最前面的Hello World，而是一直贪心的往后匹配。

那么我需要最短的匹配怎么办？很简单，加个‘？’即可，这就是传说中的懒惰匹配，即匹配到了，就不往后找了。

var s = &#39;hello world welcome to my world&#39;;
var pattern = /hello.*?world/;
var ans = pattern.exec(s);
console.log(ans)  // ["hello world", index: 0, input: "hello world welcome to my world"]

Copy after login

懒惰限定符（？）添加的场景如下：

子表达式

表示方式

用一个小括号指定：

var s = &#39;hello world&#39;;
var pattern = /(hello)/;
var ans = pattern.exec(s);
console.log(ans);

Copy after login

子表达式出现场景

在exec中数组输出子表达式所匹配的值：

var s = &#39;hello world&#39;;
var pattern = /(h(e)llo)/;
var ans = pattern.exec(s);
console.log(ans); // ["hello", "hello", "e", index: 0, input: "hello world"]

Copy after login

在replace中作为替换值引用：

var s = &#39;hello world&#39;;
var pattern = /(h\w*o)\s*(w\w*d)/;
var ans = s.replace(pattern, &#39;$2 $1&#39;)
console.log(ans); // world hello

Copy after login

后向引用 & 零宽断言

子表达式的序号问题

简单地说：从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推。

复杂地说：分组0对应整个正则表达式实际上组号分配过程是要从左向右扫描两遍的：第一遍只给未命名组分配，第二遍只给命名组分配－－因此所有命名组的组号都大于未命名的组号。可以使用(?:exp)这样的语法来剥夺一个分组对组号分配的参与权．

后向引用

如果我们要找连续两个一样的字符，比如要找两个连续的c，可以这样/c{2}/，如果要找两个连续的单词hello，可以这样/(hello){2}/，但是要在一个字符串中找连续两个相同的任意单词呢，比如一个字符串hellohellochinaworldworld，我要找的是hello和world，怎么找？

这时候就要用后向引用。看具体例子：

var s = &#39;hellohellochinaworldworld&#39;;
var pattern = /(\w+)\1/g;
var a = s.match(pattern);
console.log(a); // ["hellohello", "worldworld"]

Copy after login

这里的\1就表示和匹配模式中的第一个子表达式（分组）一样的内容，\2表示和第二个子表达式（如果有的话）一样的内容，\3 \4 以此类推。（也可以自己命名，详见参考文献）

或许你觉得数组里两个hello两个world太多了，我只要一个就够了，就又要用到子表达式了。因为match方法里是不能引用子表达式的值的，我们回顾下哪些方法是可以的？没错，exec和replace是可以的！

exec方式：

var s = &#39;hellohellochinaworldworld&#39;;
var pattern = /(\w+)\1/g;
var ans;
do {
　　ans = pattern.exec(s);
　　console.log(ans);
} while(ans !== null);

// result
// ["hellohello", "hello", index: 0, input: "hellohellochinaworldworld"] index.html:69
// ["worldworld", "world", index: 15, input: "hellohellochinaworldworld"] index.html:69
// null

Copy after login

如果输出只要hello和world，console.log(ans[1])即可。

replace方式：

var s = &#39;hellohellochinaworldworld&#39;;
var pattern = /(\w+)\1/g;
var ans = [];
s.replace(pattern, function(a, b) {
　ans.push(b);
});
console.log(ans);   // ["hello", "world"]

Copy after login

如果要找连续n个相同的串，比如说要找出一个字符串中出现最多的字符：

String.prototype.getMost = function() {
  var a = this.split(&#39;&#39;);
  a.sort();
  var s = a.join(&#39;&#39;);
  var pattern = /(\w)\1*/g;
  var a = s.match(pattern);
  a.sort(function(a, b) {
    return a.length < b.length;
  });
  var letter = a[0][0];
  var num = a[0].length;
  return letter + &#39;: &#39; + num;
}

var s = &#39;aaabbbcccaaabbbcccccc&#39;;
console.log(s.getMost()); // c: 9

Copy after login

如果需要引用某个子表达式（分组），请认准后向引用！

零宽断言

别被名词吓坏了，其实解释很简单。

它们用于查找在某些内容(但并不包括这些内容)之后的东西，也就是说它们像\b,^,$那样用于指定一个位置，这个位置应该满足一定的条件(即断言)

(?=exp)

零宽度正预测先行断言，它断言自身出现的位置的后面能匹配表达式exp。

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

Copy after login

(?!exp)

零宽度负预测先行断言，断言此位置的后面不能匹配表达式exp

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

Copy after login

javascript正则只支持前瞻，不支持后瞻（(?<=exp)和(?

关于零宽断言的具体应用可以参考综合应用一节给字符串加千分符。

其他

字符转义

因为某些字符已经被正则表达式用掉了，比如. * ( ) / \ []，所以需要使用它们（作为字符）时，需要用\转义

var s = &#39;http://www.cnblogs.com/zichi/&#39;;
var pattern = /http:\/\/www\.cnblogs\.com\/zichi\//;
var ans = pattern.exec(s);
console.log(ans); // ["http://www.cnblogs.com/zichi/", index: 0, input: "http://www.cnblogs.com/zichi/"]

Copy after login

分支条件

如果需要匹配abc里的任意字母，可以用[abc]，但是如果不是单个字母那么简单，就要用到分支条件。

分支条件很简单，就是用|表示符合其中任意一种规则。

var s = "I don&#39;t like you but I love you";
var pattern = /I.*(like|love).*you/g;
var ans = s.match(pattern);
console.log(ans); // ["I don&#39;t like you but I love you"]

Copy after login

答案执行了贪婪匹配，如果需要懒惰匹配，则：

var s = "I don&#39;t like you but I love you";
var pattern = /I.*?(like|love).*?you/g;
var ans = s.match(pattern);
console.log(ans); // ["I don&#39;t like you", "I love you"]

Copy after login

综合应用

去除字符串首尾空格（replace）

String.prototype.trim = function() {
  return this.replace(/(^\s*)|(\s*$)/g, "");
};
var s = &#39;    hello  world     &#39;;
var ans = s.trim();
console.log(ans.length);    // 12

Copy after login

给字符串加千分符（零宽断言）

String.prototype.getAns = function() {
  var pattern = /(?=((?!\b)\d{3})+$)/g;
  return this.replace(pattern, &#39;,&#39;);
}

var s = &#39;123456789&#39;;
console.log(s.getAns());  // 123,456,789

Copy after login

找出字符串中出现最多的字符（后向引用）

String.prototype.getMost = function() {
  var a = this.split(&#39;&#39;);
  a.sort();
  var s = a.join(&#39;&#39;);
  var pattern = /(\w)\1*/g;
  var a = s.match(pattern);
  a.sort(function(a, b) {
    return a.length < b.length;
  });
  var letter = a[0][0];
  var num = a[0].length;
  return letter + &#39;: &#39; + num;
}

var s = &#39;aaabbbcccaaabbbcccccc&#39;;
console.log(s.getMost()); // c: 9

Copy after login

常用匹配模式（持续更新）

只能输入汉字：/^[\u4e00-\u9fa5]{0,}$/

Summary

test: Check whether there is a certain substring (or a matching pattern) in the specified string, return true or false; perform a global pattern search if necessary.
exec: Check whether there is a certain substring (or matching pattern) in the specified string, and if so, return an array (the array is rich in information, please refer to the introduction above ), if null is not returned; if necessary, a global search can be performed to find the information of all substrings (or matching patterns). The information contains the string corresponding to the subexpression in the matching pattern.
compile: Modify the pattern in the regular expression
search: Check the specified characters Is there a certain substring (or matching pattern) in the string? If so, returns the starting position of the substring (or matching pattern) in the original string. If not, returns -1. Global search is not possible.
match: Check whether there is a certain substring (or matching pattern) in the specified string. In non-global mode, the returned information is consistent with exec; such as global search , directly returns a string array. (If you don’t need more information about each match, it is recommended to use match instead of exec)
replace: Check whether there is a certain substring in the specified string (or matching pattern), and replace it with another substring (the substring can be related to the original string or the searched substring); if g is enabled, it will be replaced globally, otherwise only the first one will be replaced. The replace method can reference the value corresponding to the subexpression.
split: Split the string using a specific pattern and return a string array; exactly the opposite of the join method of Array.
Subexpression: A regular matching expression enclosed in parentheses, which can be referenced with a back reference; it can also be obtained with exec or replace its true matching value.
Backward reference: Reference the group where the subexpression is located.
Zero-width assertion: A positional concept similar to \b ^ and $.

The above is the detailed content of Detailed explanation of JavaScript regular expressions that everyone knows. For more information, please follow other related articles on the PHP Chinese website!