Regular Expressions - Syntax

Ordinary characters

Ordinary characters are not explicitly designated as metacharacters all printable and non-printable characters. This includes all uppercase and lowercase letters, all digits, all punctuation and other symbols.

Non-printing characters

Non-printing characters can also be a part of the regular expression. The following table lists the escape sequences that represent non-printing characters:

Special characters

The so-called special characters, is that some characters have special meaning, as it says "* .txt" in *, simply means that the string representation of any meaning. If you want to find the file name with * file, you need to escape the *, that is a plus in front \. ls \ *. txt.

Many metacharacters require special treatment when trying to match them. To match these special characters, you must first make the character "escape", that is, the backslash character (\) in front of them. The following table lists the regular expression special characters:

Qualifier

Qualifier is used to specify the regular expression of a given component must appear many times to meet the match. There * or + or? Or {n} or {n,} or {n, m} a total of 6.

Regular expressions qualifiers are:

Since the chapter number in a large input document will likely more than nine, so you need a way to deal with two or three chapters numbers. Qualifier gives you this ability. The following regular expression matches any number of bits numbered chapter titles:

/Chapter [1-9][0-9]*/

Please note that the qualifier appears after the range expression. Thus, it applies to the entire range of expression, in this case, only the specified number from 0-9 (including 0 and 9).

+ Qualifier is not used here, as in the second position or the rear position do not necessarily need to have a number. Nor use? Character, because it limits the chapter numbers to only two digits. You need to match at least one number Chapter and space characters back.

If you know the chapter number is limited to only 99 chapters, you can use the following expression to specify at least one but at least two digits.

/Chapter [0-9]{1,2}/

The disadvantage of the above expression is greater than 99 chapters still number only matches the beginning of two digits. Another disadvantage is that Chapter 0 will also match. Better matching of only two digits of expression is as follows:

/Chapter [1-9][0-9]?/

or

/Chapter [1-9][0-9]{0,1}/

*, +, And? Qualifiers are greedy because they match as much text, only behind them, plus a? Can be achieved non-greedy or minimal match.

For example, you might search for HTML documents to find enclosed in H1 tags section headings. The text in your document as follows:

<H1>Chapter 1 – Introduction to Regular Expressions</H1>

All contents match the following expressions starting from less than sign (<) to close the H1 tag is greater than symbol (>) between.

/<.*>/

If you only need to match the beginning of H1 tags, the following "non-greedy" expression matches only <H1>.

/<.*?>/

By *, +, or? After the qualifier place? The expressions can switch from "greedy" to "non-greedy" or minimal expression matching.

Locator

Locator enables you to regular expression is fixed to the beginning or end of the line. They also allow you to create such a regular expression, these regular expressions appear in a word, a word at the beginning or end of a word.

Locator used to describe the string or word boundary, ^ and $ refer to the beginning and end of the string, \ b boundary description before or after the word, \ B represents a non-word boundary.

Regular expressions qualifiers are:

Note: You can not use the qualifier and anchor point. Because immediately before or after the wrapping or word boundaries can not have more than one location, and therefore does not allow such an expression like ^ *.

To match a line of text at the beginning of the text, please start using the expression n ^ character. ^ Do not use this use the expression in parentheses within the confusion.

To match text at the end of a line of text, see the end of the expression using $ characters in the positive.

To use the section headings in the search when the anchor point, the following regular expression matches a chapter title, the title contains only two followed by a number, and the start of the line:

/^Chapter [1-9][0-9]{0,1}/

True chapter headings appear only at the beginning of the line, but it is the only text in the row. It appears the line first appeared at the end of the same row. The following expression can be sure that the specified match only match without matching the cross-reference section. By creating only match the beginning and end of a line of text of the regular expression, you can do it.

/^Chapter [1-9][0-9]{0,1}$/

Match word boundary is slightly different, but the regular expressions a very important capability. Word boundary is the location and the space between the words. Non-word boundary is any other location. The following expression matches the beginning of the word Chapter three characters, because these three characters appear after a word boundary:

/\bCha/

\ B character position is very important. If it is located at the beginning of the string to be matched, it looks for a match in the beginning of the word. If it is at the end of the string, it looks for a match at the end of a word. For example, the following expression matching words Chapter string ter, as it appears in front of the word boundary:

/ter\b/

The following expression matches the string Chapter apt, but does not match the string aptitude apt:

/\Bapt/

Apt word string appears in Chapter non-word boundary, but the word appears in the aptitude of the word boundary. For \ B non-word boundary operator, position is not important, because the match does not care whether it is at the beginning or end of a word.

select

Use parentheses to enclose all of the selections, with options between adjacent separated by |. But there is a side effect of using parentheses, is relevant matches will be cached, available at this time:? On the first option to eliminate this side effect.

Wherein:? Non-capture one element, there are two non-capturing element is = and the two have more meaning, the former Positive pre-investigation, in any start being matched parentheses is the expression??! positional pattern to match the search string, which is negative pre-investigation, in any start position does not match the regular expression pattern to match the search string.

Backreferences

For a regular expression pattern or part of the pattern on both sides will result in added parentheses relevant match to a temporary storage buffer, each sub-captured are stored in order from left to right match appear in a regular expression pattern. Buffer No. 1 from the beginning, can store up to 99 captured subexpression. Each buffer can use '\ n' visit, where n is a one or two decimal digits identify the specific buffer.

You can use the non-capturing metacharacters':? ', Or to rewrite the capture, save to ignore the relevant match' =? '?!'.

Backreferences easiest, one of the most useful is the ability to provide the text to find two identical adjacent word matches. An example in the following sentence:

Is is the cost of of gasoline going up up?

The above sentence obviously have many repeated words. If we can devise a method to locate the sentence, rather than find duplicate occurrences of each word, that the more good. The following regular expression uses a single subexpression to achieve this:

/\b([a-z]+) \1\b/gi

Capture expressions, as [az] + specified, including one or more letters. The second part of the regular expression is to match a child previously captured reference, that is, the second occurrence of the word just matched by the expression in parentheses. \ 1 specifies the first sub-match. Word boundary metacharacters ensure that only detect the entire word. Otherwise, phrases such as "is issued" or "this is" and the like are not correctly identify this expression.

Regular expression after global tag (g) indicates, this expression is applied to the input string can find as many matches. Expression case insensitive at the end of (i) tag specifies case-insensitive. Potential match multi-line tag specifies line breaks can occur on both sides.

Backreferences can also be a Universal Resource Indicator (URI) into its components. Suppose you want to be broken down into the following URI protocol (ftp, http, etc.), domain addresses and page / path:

http://www.w3cschool.cc:80/html/html-tutorial.html

The following regular expression provides this functionality:

/(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/

The first parenthetical subexpression captures the protocol part of the Web address. The subexpression matches any word colon and two forward slashes in front of. The second parenthetical subexpression captures the domain address part of the address. One or more characters other than: subexpression match / and. The third parenthetical subexpression capture the port number (if one is specified). The sub-expression matches zero or more digits after the colon. It can only be repeated once the sub-expression. Finally, the fourth parenthetical subexpression captures the path specified Web address and / or page. This does not include the sub-expression matches any character sequence # or space characters.

The regular expression applied to the above URI, the sub-matching entry contains the following elements:

• The first parenthetical subexpression contains "http"
• The second parenthetical subexpression contains "www.w3cschool.cc"
• The third parenthetical subexpression with ": 80"
• The fourth parenthetical subexpression contains "/html/html-tutorial.html"