js regular expression lazy matching and greedy matching usage analysis

The examples in this article describe the usage of lazy matching and greedy matching of js regular expressions. Share it with everyone for your reference, the details are as follows:

Before talking about greedy mode and lazy mode, let’s review the basics of JS regularity:

Writing basics:

①Not required Double quotes, directly use //contain => /wehfwue123123/.test();

②Backslash\ represents escape=>/\.jpg$/

③Usage Basics: .test(str);

Syntax:

①Anchor class

/^a/=>Begins with "a"

/\.jpg$/=>Ending with ".jpg"

②Character class

[abc]: a or b or c

[0-9]: A number

[a-z]: A letter

. : Any character

③ Metacharacter

^: Used in [] to indicate non, in [] indicates the beginning with

\d: [0-9]

\s: white space character

\w: [A-Za-z0-9_]

\D：[^\d]-Non-number

\S：Non-whitespace character

④Quantifier

{m,n}：m to n times of

metacharacters represent:

*：{0,}

?：{0,1}

+：{1,}

Difficulty: Greedy mode/lazy mode

Greedy mode--on the premise of successful matching, match as many as possible

Lazy mode--on the premise of successful matching Next, match as little as possible

Explanation 1: Code and text

Using greedy and lazy quantifiers in regular expressions can control the expression matching process. Do we know quantifiers? , *, + means, you can specify the number of occurrences of the relevant pattern. By default, we use the greedy quantifier. Its matching process is to start looking at the entire string. If it does not match, remove the last one and see if Match, and loop like this until matching or the string is empty, such as:

vars ="abbbaabbbaaabbb1234";
varre1=/.*bbb/g;//*是贪婪量词
re1.test(s);

This matching process will start from the entire string:

re1.test("abbbaabbbaaabbb1234");//false ，则去掉最后一个字符4再继续
re1.test("abbbaabbbaaabbb123");//false ，则去掉最后一个字符3再继续
re1.test("abbbaabbbaaabbb12");//false ，则去掉最后一个字符2再继续
re1.test("abbbaabbbaaabbb1");//false ，则去掉最后一个字符1再继续
re1.test("abbbaabbbaaabbb");//true ，结束

Add one more after the greedy quantifier? It becomes a lazy quantifier. Its matching process is the opposite, starting from the first one in front, and adding one if it does not match, so Loop until the end of the string, using the above example.

vars ="abbbaabbbaaabbb1234";
varre1=/.*?bbb/g;//*?是惰性量词
re1.test(s);

The matching process is as follows:

re1.test("a");//false, 再加一个
re1.test("ab");//false, 再加一个
re1.test("abb");//false, 再加一个
re1.test("abbb");//true, 匹配了，保存这个结果，再从下一个开始
re1.test("a");//false, 再加一个
re1.test("aa");//false, 再加一个
re1.test("aab");//false, 再加一个
re1.test("aabb");//false, 再加一个
re1.test("aabbb");//true, 匹配了，保存这个结果，再从下一个开始

Summary:

The default greedy matching is from back to front, maximum length matching, lazy matching is to add after the quantifier? Start matching from the front of the string, and match the minimum length

I hope this article will be helpful to everyone in JavaScript programming.

For more js regular expression lazy matching and greedy matching usage analysis related articles, please pay attention to the PHP Chinese website!