1, Concept of regular expression

Regular expression is a logical formula for string operation. It uses some specific characters defined in advance and the combination of these specific characters to form a "regular string". This "regular string" is used to express a filtering logic for strings.

2, Composition of regular expressions

Regular expressions consist of metacharacters, character classes, and quantifiers / ^ ([character classes] {quantifiers}) ([character classes] {quantifiers})$/

3, Regular object RegExp

1. Declare regular objects with the new keyword

		//  Regular rule: it can be string type or regular type
		
		var patt = new RegExp(Regular rules,  Modifier )
		var patt = new RegExp('a',  'g')
		var patt = new RegExp(/a/,  'g')

1. Literal form

		var patt = /Regular rules/Modifier 

The difference between the two methods

Variables cannot be accepted in literal form

4, Regular object method

1. test(): performs a search to see if the regular expression matches the specified string. Returns true or false.

2. exec(): performs a search match in a specified string. Returns an array of results (containing all matching results) or null (null if there is no match). If you want to retrieve all matching results, you need to use a loop
   When the method is executed, the end position of each matching will be recorded through the lastIndex attribute, and the next execution will start from the position recorded by lastIndex; When no matching result is found, the lastIndex property is reset to 0, starting from scratch

		var patt = /o/g;
		var str = 'hello world oo';
		var res1 = patt.exec(str) 
		var res2 = patt.exec(str) 
		var res3 = patt.exec(str) 
		
		//  Get all the results with a loop
		let res;
		while(res = patt.exec(str)){
		 console.log(res)
		}

5, Modifier

• g: global matching
• i: Case insensitive
• m: Multiline matching

6, Metacharacter

• ^: what does matching begin with
• $: match what is the end
• (): grouping or backreferencing
• |: or

7, Character class

• [xyz]: a collection of character classes that matches any character in parentheses
• [^ xyz]: an inverted character set. That is, it matches any character not contained in square brackets
  In character classes, you can use - to represent a collection of ranges
• [0-9]: match numbers 0 to 9
• [a-z]: match lowercase letters
• [A-Z]: match uppercase letters
• [A-Za-z]: match case letters
• [A-Za-z0-9]: match upper and lower case letters and numbers
• . : The default matches any single character except the newline character.

For common matching rules, you can use the abbreviated equivalent form

• \w: equivalent form [A-Za-z0-9#]

• \W: matches a non word character. Equivalent to [^ A-Za-z0-9_]

• \d: equivalent to [0-9]

• \D: matching a non numeric character is equivalent to [^ 0-9]

• \s: match any whitespace

• \S: Other than whitespace

8, Quantifier

Quantifiers limit the number of occurrences of character classes; Quantifiers are divided into greedy and inert

• *: matches 0 or more times, equivalent form {0,}
• +: match 1 or more times, equivalent form {1,}
• ? : Match 0 or 1 times, equivalent form {0,1}
• {n} : match n times
• {n,}: match at least N times, unlimited
• {n,m}: at least n matches and at most M matches

9, Escape character\

If you need to match special characters (characters used in regular rules) in regular expressions, you need to use escape characters \ special characters; sometimes, in order to avoid uncontrollable problems, you need to use double escape \ \ characters

10, Grouping

() grouping and back reference;
Group only, no reference:?: ()

Back reference

The back reference refers to the result of the match, not the rule of the match
Backreference \ nthe number n is the order of the left parenthesis

//  Back reference
var patt = /^<(h1)>\w{1,}<\/\1>/
var str = '<h1>hello</h1>';
var res = patt.test(str)

//  Group only, no reference
var patt = /^((?:(ECMA)Script)Hello)$/
var str = 'ECMAScriptHello';
var res = patt.test(str);
//  Back reference $n: n is the order of left parentheses; If it is the attribute of a regular object, use $n; If used in a regular expression, use \ n

console.log(RegExp.$1);
console.log(RegExp.$2);
console.log(RegExp.$3);
console.log(RegExp.$4);

11, Or

var patt = /hello(red)|(black)/
var patt = /hello[a|b]/

12, Assert

• x(?=y): match 'x' only if 'x' is followed by 'y' This is called forward-looking assertion (forward-looking).
• x(?!y): match 'x' only when 'x' is not followed by 'y', which is called positive negative lookup (negative forward looking).

13, Matching pattern

There are two matching patterns of regular rules: greedy pattern and inert pattern

• Greedy pattern: match as many as possible

  var str = '123456789012345678900';
  var res = str.match(/\d{3,6}/g);

• Lazy pattern: match as little as possible
  Can I add after greedy mode? Become inert mode +? *? {n,}? {n,m}? ??

var str = '123456789012345678900';
var res = str.match(/\d{3,6}?/g);

14, Regular correlation method in string

• replace(): replace the string matching the regular expression; The default replacement is the first matching string; If you want to replace all, you need a global match

'hello world'.replace(/o/, 'javascript')// Replace first by default
'hello world'.replace(/o/g, 'javascript') // replace all

• match(): find one or more result arrays matching regular expressions,

var str = 'hella world';
// let res = str.match(/o/g);  //    If there is a global modifier g, the result is an array ['O ','O']
let res = str.match(/o/);
console.log(res);
/* //  Result resolution without global modifier g:
    0: "o" // Result of index value matching (index value of contents in array)
    groups: undefined 
    index: 4 //  The index value of the first occurrence of the matched character in the specified string
    input: "hello world"  // Matches the specified character
    length: 1 // Length of array
 */

• search(): matches whether the specified character is contained in the specified string; It returns the location index that matches, or - 1 on failure.

    var str = 'hello';
    // var res = str.search(/e/)
    var res = str.search(/a/)
    console.log(res);

• split(): String splitting

    var str = 'haksdf2324hwehej2313jkfghwer5345634adf';
    var res = str.split(/\d{1,}/)
    console.log(res);