Javascript Regular Expression symbols

Document directory

• C {n}
• C {m, n}
• C {n ,}
• *, + ,?
• Greedy and non-greedy
• Matching results of sub-regular expressions are not recorded
• Forward pre-Query
• ?!
• Global match, modifier g
• Case-insensitive, modifier I
• The end of the first line, modifier m
• Exec method Return Value
• Update the regular expression using the exec Method
• Match Method
• Replace Method
• Search Method and split method

Method 1:

VaR Reg =/pattern /;

Method 2:

VaR Reg = new Regexp ('pattern ');

Introduction to the exec method of Regular Expressions

Syntax:

Reg.exe C (STR );

STR is the target string for executing the regular expression.

For example:

<SCRIPT type = "text/Java Script"> var Reg =/test/; var STR = 'teststring'; var result = reg.exe C (STR); alert (result ); </SCRIPT>

The test is output, because the regular expression Reg matches the 'test' substring in STR ('teststring') and returns it.

We use the following function to perform regular expression matching exercises:

Function execreg (Reg, STR) {var result = reg.exe C (STR); alert (result );}

The function accepts a regular expression parameter Reg and a target string parameter Str. After execution, alert returns the matching result between the regular expression and the string.

The above example is tested using this function:

<SCRIPT type = "text/Java Script"> function execreg (Reg, STR) {var result = reg.exe C (STR); alert (result );} vaR Reg =/test/; var STR = 'teststring'; execreg (Reg, STR); </SCRIPT>

The above example uses the test in the regular expression to match the test in the string. It is really boring. The same task can be completed using the indexof method. With regular expressions, more powerful functions are required:

One tablet, two tablets, three or four slices.

The above subtitles are translated into regular {1}, {2}, {3, 4}, {1 ,}.

C {n}

{1} indicates a meaning.

/C {1}/only one C can be matched.

/C {2}/matches two consecutive C.

And so on,

/C {n}/matches n consecutive C.

See the following example:

Reg =/c {1}/; STR = 'cainiao'; execreg (Reg, STR );

Return Result c

Reg =/c {2}/; STR = 'cainiao'; execreg (Reg, STR );

The returned result is null, indicating that no matching is successful.

Reg =/c {2}/; STR = 'ccvc jelly free'; execreg (Reg, STR );

Return result CC.

C {m, n}

C {3, 4} indicates three consecutive C or four C.

For example

Reg =/c {3, 4}/; STR = 'ccvc freeze '; execreg (Reg, STR );

The returned result is null, indicating that no matching is successful.

Reg =/c {3, 4}/; STR = 'ccctest'; execreg (Reg, STR );

The result returns CCC.

Reg =/c {3, 4}/; STR = 'cctest'; execreg (Reg, STR );

The result returns CCCC, which indicates that the regular expression will have as many brands as possible. If the regular expression can be 3 to 4, it will match one more.

Reg =/c {3, 4}/; STR = 'ccctest'; execreg (Reg, STR );

Only four C instances are matched.

From the above example, we can infer that c {m, n} represents m to n C, and m is less than or equal to n.

C {n ,}

C {1,} indicates more than one C. For example:

Reg =/c {1,}/; STR = 'cainiao'; execreg (Reg, STR );

Returns C.

Reg =/c {1,}/; STR = 'ccctest'; execreg (Reg, STR );

Return CCCCC, again indicating that the regular expression will match as much as possible.

Reg =/c {2,}/; STR = 'cainiao'; execreg (Reg, STR );

Return NULL, c {2,} indicates more than 2 C, and cainiao contains only 1 C.

The above example shows that c {n,} represents at least n c, but not limited to a number.

*, + ,?

* Indicates 0 or multiple times, equivalent to {0,}, that is

C * and c {0,} are meanings.

+ Indicates one or more times, equivalent to {1,}, that is

C + and c {1,} are meanings.

Last ,? 0 or 1 time, equivalent to {0, 1}, that is

C? And c {0, 1.

Greedy and non-greedy

People are greedy, and so are regular expressions. In the example Reg =/c {3, 4}/; STR = 'cctest';, we can see that regular expressions will never match three values when four values can be matched. All the regular expressions described above are like this. If they are legal, they will try to match as many characters as possible. This is called greedy mode.

If we want the regular expression to match as few characters as possible, we can add a? symbol after the symbol that represents a number ?. Form:

{N ,}?, *?, + ?, ??, {M, n }?

Let's take an example:

Reg =/c {1 ,}? /; STR = 'ccccc '; execreg (Reg, STR );

Only one C is returned. Although five C can be matched, the regular expression is not greedy, so only one is matched.

/^ Starts with and ends with $/

^ Indicates that only the start of the string is matched. See the following example:

Reg =/^ C/; STR = 'vitamin C'; execreg (Reg, STR );

The result is null. Because the string 'vitamin C' does not start with C, the matching fails.

Reg =/^ C/; STR = 'cainiao'; execreg (Reg, STR );

This time, C is returned. The matching is successful because cainiao starts with C.

In contrast to ^, $ matches only the characters at the end of the string. For example:

Reg =/C $/; STR = 'cainiao'; execreg (Reg, STR );

Returns NULL, indicating that the regular expression cannot find the character C at the end of the string.

Reg =/C $/; STR = 'vitamin C'; execreg (Reg, STR );

The returned result is C, indicating that the matching is successful.

Click '.'

'.' Matches all the characters except line break/N in the string, for example

Reg =/./; STR = 'cainiao'; execreg (Reg, STR );

The result shows that the regular expression matches the character C.

Reg =/./; STR = 'blueidea '; execreg (Reg, STR );

This is B.

Reg =/. +/; STR = 'blueidea -- classic Forum haoku _. '; Execreg (Reg, STR );

The result is "blueidea-classic Forum haok _. "That is to say, all characters are matched, including a space, a slide line, and a broken line.

Reg =/. +/; Reg =/. +/; STR = 'bbs .blueidea.com '; execreg (Reg, STR );

Similarly, the entire string --bbs.blueidea.com is directly returned, and "." Also matches.

Reg =/^./; STR = '/ncainiao'; execreg (Reg, STR );

The result is null and finally fails. The regular expression requires that the first character of the string is not a line break, but the character starts with/n.

Either. In the regular expression, or, "|"

B | C indicates that B or C is matched.

For example:

Reg =/B | C/; STR = 'blueidea '; execreg (Reg, STR );

The result is B.

Reg =/B | C/; STR = 'cainiao'; execreg (Reg, STR );

The result is C.

Reg =/^ B | C. +/; STR = 'cainiao'; execreg (Reg, STR );

Match the entire cainiao.

Reg =/^ B | C. +/; STR = 'bbs .blueidea.com '; execreg (Reg, STR );

The result is only one B, not the entire string. The above regular expression indicates that B or C. + at the beginning is matched.

Brackets

Reg =/^ (B | C). +/; STR = 'bbs .blueidea.com '; execreg (Reg, STR );

The result of this operation is the entire string bbs.blueidea.com. After the brackets on the machine, this regular expression indicates that if the string starts with B or C, then match B or C at the beginning and all non-line characters After B or C.

If you have done the experiment, you will find that the returned result is followed by ", B", which is the Matching content of B | C in. The content written in the brackets in the regular expression will be considered as a subregular expression, and the matching results will be recorded for later use. We will ignore this feature for the moment.

Character Set combination [ABC]

[ABC] indicates any character in A, B, or C. For example:

Reg =/^ [ABC]/; STR = 'bbs .blueidea.com '; execreg (Reg, STR );

The returned result is B.

Reg =/^ [ABC]/; STR = 'test'; execreg (Reg, STR );

This time the result is null.

We use the following representation in the character set: [A-Z], [A-Z], [0-9], indicating lowercase letters, uppercase letters, numbers, respectively. For example:

Reg =/^ [A-Za-Z] [a-zA-Z0-9 _] +/; STR = 'test'; execreg (Reg, STR );

The result is the entire test, which indicates that the regular expression must start with English letters, followed by English letters, numbers, and underscores.

Anti-Character Set combination [^ ABC]

^ Indicates the starting part of the regular expression. For example,/^ C/indicates the starting part of the regular expression. However, in the character set and medium, it indicates a meaning similar to "Non, for example, [^ ABC] indicates that it cannot be A, B, or C. For example:

Reg =/[^ ABC]/; STR = 'blueidea '; execreg (Reg, STR );

The returned result is l because it is the first non-ABC character (that is, the first B does not match ). Similarly:

Reg =/[^ ABC]/; STR = 'cainiao'; execreg (Reg, STR );

Returns I. The first two characters are in the [ABC] set.

[^ 0-9] indicates a non-digit, [^ A-Z] indicates a non-lowercase letter, and so on.

Boundary and non-Boundary

/B indicates the boundary, that is, only the start and end of a string are counted. For example, // BC/indicates the starting c of the string or the ending C. See the following example:

Reg = // BC/; STR = 'cainiao'; execreg (Reg, STR );

Return Result c. Matches the C character at the left boundary.

Reg = // BC/; STR = 'vitamin C'; execreg (Reg, STR );

C is returned, but C is returned at the right boundary.

Reg = // BC/; STR = 'bcb '; execreg (Reg, STR );

This match failed because the C in the BCB string is in the middle and neither left nor right boundary.

Corresponding to/B indicates non-boundary. For example:

Reg = // BC/; STR = 'bcb '; execreg (Reg, STR );

This time we will successfully match C in BCB ,. However

Reg = // BC/; STR = 'cainiao'; execreg (Reg, STR );

The return value is null. Because/B tells the regular expression that only the non-boundary C is matched.

Numbers and non-Numbers

/D indicates the meaning of a number. On the contrary,/D indicates a non-number. For example:

Reg = // D/; STR = 'cainiao8'; execreg (Reg, STR );

The returned matching result is 8 because it is the first numeric character.

Reg = // D/; STR = 'cainiao8'; execreg (Reg, STR );

Returns C, the first non-numeric character.

Blank

/F matches the newline character,/n matches the newline character,/r matches the carriage return,/t matches the tab, And/V matches the vertical tab.

/S matches a single space, which is equivalent to [/f/n/R/T/V]. For example:

Reg = // S. +/; STR = 'this is a test string. '; execreg (Reg, STR );

Returns "is a test string.", which means that the regular expression matches the first space and all non-line characters after it.

Similarly,/s indicates non-space characters.

Reg = // s +/; STR = 'this is a test string. '; execreg (Reg, STR );

The matching result is this. When the first space is entered, the regular expression stops matching.

Word character

/W represents word characters, equivalent to character set in combination with [a-zA-Z0-9 _]. For example:

Reg = // W +/; STR = 'blueidea '; execreg (Reg, STR );

Returns the complete blueidea string because all characters are word characters.

Reg = // W +/; STR = '. classname'; execreg (Reg, STR );

The result shows that the classname matches the string, and only the first "." -- the unique non-word character does not match.

Reg = // W +/; STR = 'what is Chinese? '; Execreg (Reg, STR );

If you try to match Chinese characters with word characters, then null is returned.

/W represents non-word characters, equivalent to [^ a-zA-Z0-9 _]

Reg = // W +/; STR = 'what is Chinese? '; Execreg (Reg, STR );

Returns the complete string, because, whether it is Chinese or "?" Both are non-word characters.

Reverse reference

The format is as follows:/(sub-Regular Expression)/1/

Examples are still used to illustrate:

1.

Reg = // w/; STR = 'blueidea '; execreg (Reg, STR );

Returns B.

2.

Reg =/(/W)/; STR = 'blueidea '; execreg (Reg, STR );

Return BL, B, l

BL is the content of the entire regular expression matching, B is the content of the sub-Regular Expression matching in the first bracket, and L is the content of the second matching bracket.

3.

Reg =/(/W)/1/; STR = 'blueidea '; execreg (Reg, STR );

The return value is null. Here, "/1" is called a reverse reference, which indicates the Matching content of the regular expression in the first square brackets. In the above example, the (/W) in the first bracket matches B, so "/1" also indicates B, and B cannot be found in the remaining string.

Compared with the second example, we can find that "/1" is equivalent to "1st matching brackets", rather than "content of the first parenthesis ".

Reg =/(/W)/1/; STR = 'bbs .blueidea.com '; execreg (Reg, STR );

This regular expression matches BB.

Similarly, we can use several reverse references with several subregular expressions. For example:

Reg =/(/W)/2/1/; STR = 'woow'; execreg (Reg, STR );

The matching is successful, because the first parentheses match W, and the second parentheses match o, while/2/1 indicates ow, which exactly matches the last two characters of the string.

Brackets (2)

We have discussed the issue of parentheses before. See the example below:

Reg =/^ (B | C). +/; STR = 'bbs .blueidea.com '; execreg (Reg, STR );

This regular expression is used to match only strings starting with B or C. It always matches with line breaks,. As we can see above, we can use "/1" to reverse reference the content matched by the sub-Regular Expression in this bracket. The exec method also saves the matching result of the regular expression to the returned result.

Matching results of sub-regular expressions are not recorded

Use an image like (? : Pattern) to avoid saving matching results in parentheses. For example:

Reg =/^ (? : B | C). +/; STR = 'bbs .blueidea.com '; execreg (Reg, STR );

We can see that the returned results do not include the multi-match content of the regular expression in the brackets.

Likewise, reverse reference is hard to make:

Reg =/^ (B | C)/1/; STR = 'bbs .blueidea.com '; execreg (Reg, STR );

Return BB and B. BB is the content that the entire regular expression matches, while B is the content that the first sub-Regular Expression matches.

Reg =/^ (? : B | C)/1/; STR = 'bbs .blueidea.com '; execreg (Reg, STR );

Returns null. Because there is no matching content in the brackets, there is naturally no way to reverse reference.

Forward pre-Query

Form :(? = Pattern)

The so-called forward pre-query means that the string to be matched must be followed by pattern!

We know that the regular expression/cainiao/will match cainiao. Similarly, it matches cainiao in cainiao9. However, we may expect that cainiao can only match cainiao in cainiao8. At this time, you can write as follows:/cainiao (? = 8)/, view two instances:

Reg =/cainiao (? = 8)/; STR = 'cainiao9'; execreg (Reg, STR );

Returns null.

Reg =/cainiao (? = 8)/; STR = 'cainiao8'; execreg (Reg, STR );

Match cainiao.

It should be noted that the content in the brackets does not participate in the real match, but only checks whether the subsequent characters meet the requirements. For example, the preceding regular expression returns cainiao instead of cainiao8.

Let's look at two examples:

Reg =/blue (? = Idea)/; STR = 'blueidea '; execreg (Reg, STR );

Match to blue instead of blueidea.

Reg =/blue (? = Idea)/; STR = 'bluetooth '; execreg (Reg, STR );

Null is returned because blue is not followed by idea.

Reg =/blue (? = Idea)/; STR = 'incluthidea '; execreg (Reg, STR );

Returns null.

?!

Form (?! Pattern) and? = On the contrary, the string must not be followed by a pattern. Take the following example:

Reg =/blue (?! Idea)/; STR = 'blueidea '; execreg (Reg, STR );

The return value is null. Because of Regular Expression requirements, the blue is not followed by idea.

Reg =/blue (?! Idea)/; STR = 'bluetooth '; execreg (Reg, STR );

Blue is returned.

Match metacharacters

First, we need to figure out what is metacharacters? We used *, + ,? Such symbols have special meanings in regular expressions. Similar Characters with special functions are called metacharacters. For example

Reg =/C */;

Indicates that there is any C, but what if we really want to match the 'C * 'string? You only need to escape *, as shown below:

Reg =/C/*/; STR = 'C * '; execreg (Reg, STR );

Returns the matched string: C *.

Similarly, to match other metacharacters, you only need to add a slash (/) to the front.

Global match of modifier of regular expression, modifier g

Format:/pattern/g

Example: Reg =/B/g;

The role of G will be discussed later. First, let's look at the two modifiers.

Case-insensitive, modifier I

Format:/pattern/I

Example:

VaR Reg =/B/; var STR = 'bbs '; execreg (Reg, STR );

Null is returned because it is case insensitive.

VaR Reg =/B/I; var STR = 'bbs '; execreg (Reg, STR );

Match B, which is the role of the I modifier.

The end of the first line, modifier m

Format:/pattern/m

The m modifier is used to modify the functions of ^ and $ in the regular expression, so that they indicate the beginning and end of the line, respectively. For example:

VaR Reg =/^ B/; var STR = 'test/nbbs '; execreg (Reg, STR );

Matching failed because the string does not start with B. However, after the M modifier is added:

VaR Reg =/^ B/M; var STR = 'test/nbbs '; execreg (Reg, STR );

Matching B is successful because ^ represents the first line after the M modifier is added. Because BBS is the first line of the second line of the string, it can be matched successfully.

Exec method details exec method Return Value

The exec method does not actually match the result string, but an object. simply modify the execreg function to verify this by doing an experiment:

Function execreg (Reg, STR) {var result = reg.exe C (STR); alert (typeof result);} var Reg =/B/; var STR = 'bbs .bblueidea.com '; execreg (Reg, STR );

The result is of the object type. It is an array-like object. You can use for in to know its property: Index input 0. Index indicates matching the index in the original string, and input indicates the input string;

0 indicates only one matching result. You can use subscript 0 to reference this matching result. This quantity may change. We can know the total number of matching results through the Length attribute of the returned value.

Based on the analysis of the returned values, modify the execreg function as follows:

Function execreg (Reg, STR) {var result = reg.exe C (STR); document. write ('index: '+ result. index + '<br/>' + 'input: '+ result. input + '<br/>'); for (I = 0; I <result. length; I ++) {document. write ('result ['+ I +']: '+ result [I] +' <br/> ')}}

Experiment now:

VaR Reg = // w/; var STR = 'bbs .bblueidea.com '; execreg (Reg, STR );

The result is as follows:

• Index: 0
• Input: bbs.bblueidea.com
• Result [0]: B

The input string is bbs.bblueidea.com;

The index of matched B in the original string is 0.

The matching result of the regular expression is A, B;

VaR Reg =/(/W) (. +)/; var STR = 'bbs .bblueidea.com '; execreg (Reg, STR );

Result:

Index: 0
Input: bbs.bblueidea.com
Result [0]: bbs.bblueidea.com
Result [1]: B
Result [2]: B
Result [3]: s.bblueidea.com

As shown in the preceding two examples, the returned object [0] is the content matched by the entire regular expression. The subsequent element is the Matching content of each sub-regular expression.

Update the regular expression using the exec Method

The exec method may update the original regular expression while returning the result object. It depends on whether the regular expression has a G modifier. Let's take a look at two examples:

VaR Reg =/B/; var STR = 'bbs .blueidea.com '; execreg (Reg, STR); execreg (Reg, STR );

The result is as follows:

Index: 0
Input: bbs.blueidea.com
Result [0]: B
Index: 0
Input: bbs.blueidea.com
Result [0]: B

That is to say, the two matching results are exactly the same. From the index, we can see that all matching results are the first B characters of the string.

Let's take a look at how G's regular expression works:

VaR Reg =/B/g; var STR = 'bbs .blueidea.com '; execreg (Reg, STR); execreg (Reg, STR );

The result is as follows:

Index: 0
Input: bbs.blueidea.com
Result [0]: B
Index: 1
Input: bbs.blueidea.com
Result [0]: B

It can be seen that the second matching is the second B of the string. This is the role of the G modifier. The following describes how exec treats g and non-G Regular Expressions differently.

If G is not set for the regular expression, the exec method will not affect the regular expression. If G is set, the lastindex attribute of the regular expression will be updated after exec is executed, indicates the index of the next character of the matched string after this match. The next time you use this regular expression to match the string, the match starts from the last lastindex attribute, that is why the results of the above two examples are different.

Test Method

The test method only checks whether STR can be matched and returns a Boolean value to indicate whether STR is successful. Create a simple test function:

Function testreg (Reg, STR) {alert (Reg. Test (STR ));}

Instance 1

VaR Reg =/B/; var STR = 'bbs .blueidea.com '; testreg (Reg, STR );

Success. output is true.

Instance 2

VaR Reg =/9/; var STR = 'bbs .blueidea.com '; testreg (Reg, STR );

Failed. False is returned.

Use the string method to execute the regular expression match Method

Format: Str. Match (REG );

Similar to the exec method of a regular expression, this method returns an object similar to an array with the input and index attributes. We define the following function for testing:

Function matchreg (Reg, STR) {var result = Str. match (REG); If (result) {document. write ('index: '+ result. index + '<br/>' + 'input: '+ result. input + '<br/>'); for (I = 0; I <result. length; I ++) {document. write ('result ['+ I +']: '+ result [I] +' <br/> ')} else {alert ('null: matching failed! ')}}

For example:

VaR Reg =/B/; var STR = 'bbs .blueidea.com '; matchreg (Reg, STR );

The result is as follows:

Index: 0
Input: bbs.blueidea.com
Result [0]: B

The result is the same as that of exec.

However, if the regular expression is configured with a G modifier, the behavior of exec and match may be different. See the following example:

Index: Undefined
Input: Undefined
Result [0]: B
Result [1]: B
Result [2]: B

The regular expression with the G modifier set does not stop after a successful match, but continues to find all the matching characters. The returned results include three B. However, the input and index information is not provided.

Replace Method

Format: Str. Replace (Reg, 'new str ');

It uses the ''new STR "code for the part matching REG in the STR string. It is worth noting that the original string is not modified, but is returned as the return value. Example:

VaR Reg =/B/; var STR = 'bbs .blueidea.com '; var newstr = Str. Replace (Reg, 'C'); document. Write (newstr );

The result is cbs.blueidea.com, and only the first B is replaced with C.

VaR Reg =/B/g; var STR = 'bbs .blueidea.com '; var newstr = Str. Replace (Reg, 'C'); document. Write (newstr );

Output ccs.clueidea.com

Because the G modifier is set, all B is replaced.

VaR Reg = // W +/g; var STR = 'bbs .blueidea.com '; var newstr = Str. Replace (Reg, 'word'); document. Write (newstr );

Output:

Word.

Use the $ Reference Sub-Regular Expression to match the content in the replace function.

Just like in a regular expression, we can use/1 to reference the content matched by the first sub-regular expression, we can also use $1 to reference the same content in the replace character of the replace function.

Let's look at an example:

VaR Reg =/(/W + ). (/W + ). (/W +)/; var STR = 'bbs .blueidea.com '; var newstr = Str. replace (Reg, '$1. $1. $ 1'); document. write (newstr );

The output result is:

BBS. bbs. BBS

First, we know that the first sub-Regular Expression matches BBS, so $1 represents BBS. Then we set the replacement string to '$1. $1. $ 1', which is actually "bbs. bbs. BBS ". Similarly, $2 is blueidea, and $3 is com.

Let's look at an example. The order of the two words before and after spaces is reversed.

VaR Reg =/(/W +)/S (/W +)/; var STR = 'cainiao gaoshou '; var newstr = Str. replace (Reg, '$2 $ 1'); document. write (newstr );

The result is: gaoshou cainiao, that is, the words before and after spaces are exchanged.

Because $ has a special meaning in the Replace text, if we want to use $, We need to write it as $, for example:

VaR Reg =/(/W +)/S (/W +)/; var STR = 'cainiao gaoshou '; var newstr = Str. replace (Reg, '$'); document. write (newstr );

Result: $.

Search Method and split method

Similarly, regular expressions can also be used in the search and Split Methods of strings. The format is as follows:

Str. Search (REG );

Search returns the location where the regular expression matches for the first time. Example:

VaR Reg =/idea/; var STR = 'blueidea '; var Pos = Str. Search (REG); document. Write (POS );

The result is 4.

The following example shows the first non-word character:

VaR Reg = // w/; var STR = 'bbs .blueidea.com '; var Pos = Str. Search (REG); document. Write (POS );

The result is 3, that is, the position of the vertex.

Str. split (Reg, 'secret'); split returns the split array, for example, VAR Reg = // w/; var STR = 'bbs .blueidea.com '; var arr = Str. split (REG); document. write (ARR );

The result is: BBS, blueidea, and COM. It can be seen that the array is divided by non-word characters into arrays with three elements.

VaR Reg = // w/; var STR = 'HTTP: // www.baidu.com/'; var arr = Str. split (REG); document. write (ARR. length + '<br/>'); document. write (ARR );

Result:

7
HTTP, WWW, Baidu, COM,

It can be seen that the string is divided into arrays with seven elements, including three elements that are empty strings.