Detailed explanation of regular expressions and text processors for Shell programming notes

character

describe

\

Mark the next character as a special character, or an primitive character, or a backward reference, or an octal escape character. For example, 'n' matches the character "n". '\n' matches a newline character. The sequence '\\' matches "\" and "\(" matches "(".

^

Matches the start position of the input string. If the Multiline property of the RegExp object is set, ^ also matches the position after '\n' or '\r'.

$

Matches the end position of the input string. If the Multiline property of the RegExp object is set, $ also matches the position before '\n' or '\r'.

*

Matches the previous subexpression zero or multiple times. For example, zo* can match "z" and "zoo". * is equivalent to {0,}.

+

Matches the previous subexpression once or more times. For example, 'zo+' can match "zo" and "zoo", but not "z". + is equivalent to {1,}.

?

Matches the previous subexpression zero or once. For example, "do(es)?" can match "do" or "does" . ? is equivalent to {0,1}.

{n}

n is a non-negative integer. Match the n times that are determined. For example, 'o{2}' cannot match 'o' in "Bob", but can match two os in "food".

{n,}

n is a non-negative integer. Match at least n times. For example, 'o{2,}' cannot match 'o' in "Bob" but can match all os in "fooooood". 'o{1,}' is equivalent to 'o+'. 'o{0,}' is equivalent to 'o*'.

{n,m}

m and n are non-negative integers, where n <= m. Match at least n times and match up to m times. For example, "o{1,3}" will match the first three os in "fooooooood". 'o{0,1}' is equivalent to 'o?'. Please note that there cannot be spaces between commas and two numbers.

?

The matching pattern is non-greedy when the character is immediately followed by any other restriction character (*, +, ?, {n}, {n,}, {n,m}). The non-greedy pattern matches as few strings as possible, while the default greedy pattern matches as many strings as possible. For example, for the string "oooo", 'o+?' will match a single "o", and 'o+' will match all 'o'.

.

Match any single character except line breaks (\n, \r). To match any characters including '\n', use a pattern like "(.|\n)".

(pattern)

Match pattern and get this match. The obtained matches can be obtained from the generated Matches collection, using the SubMatches collection in VBScript, and the $0…$9 attribute in JScript. To match parentheses characters, use '\(' or '\)'.

(?:pattern)

Match pattern but does not get the matching result, that is, this is a non-get match and is not stored for future use. This is useful when using the "or" character (|) to combine various parts of a pattern. For example, 'industr(?:y|ies) is a simpler expression than 'industry|industries'.

(?=pattern)

Look ahead positive assert, matching the search string at the beginning of any string matching pattern. This is a non-get match, that is, the match does not need to be retrieved for later use. For example, "Windows(?=95|98|NT|2000)" can match "Windows" in "Windows2000", but cannot match "Windows" in "Windows3.1". Pre-checking does not consume characters, that is, after a match occurs, the next match's search begins immediately after the last match, rather than after the characters containing the pre-checking.

(?!pattern)

Negative assert, matching the search string at the beginning of any string that does not match the pattern. This is a non-get match, that is, the match does not need to be retrieved for later use. For example, "Windows(?!95|98|NT|2000)" can match "Windows" in "Windows3.1", but cannot match "Windows" in "Windows2000". Pre-checking does not consume characters, that is, after a match occurs, the next match's search begins immediately after the last match, rather than after the characters containing the pre-checking.

(?<=pattern)

The reverse (looking behind) positive pre-check is similar to the positive pre-check, but the direction is opposite. For example, "(?<=95|98|NT|2000)Windows" can match "Windows" in "2000Windows", but cannot match "Windows" in "3.1Windows".

(?<!pattern)

Reverse negative pre-examination is similar to forward negative pre-examination, but in the opposite direction. For example, "(?<!95|98|NT|2000)Windows" can match "Windows" in "3.1 Windows", but cannot match "Windows" in "2000Windows".

x|y

Match x or y. For example, 'z|food' can match "z" or "food". '(z|f)ood' matches "zood" or "food".

[xyz]

Character collection. Match any character contained. For example, '[abc]' can match 'a' in "plain".

[^xyz]

A collection of negative values ​​characters. Match any characters not included. For example, '[^abc]' can match 'p', 'l', 'i', 'n' in "plain".

[a-z]

Character range. Match any character in the specified range. For example, '[a-z]' can match any lowercase alphabetical characters in the range 'a' to 'z'.

[^a-z]

Negative value character range. Match any arbitrary characters that are not within the specified range. For example, '[^a-z]' can match any arbitrary character that is not in the range of 'a' to 'z'.

\b

Match a word boundary, which means the position between the word and space. For example, 'er\b' can match 'er' in "never" but not 'er' in "verb".

\B

Match non-word boundaries. 'er\B' can match 'er' in "verb", but cannot match 'er' in "never".

\cx

Matches the control characters specified by x. For example, \cM matches a Control-M or carriage return. The value of x must be one of A-Z or a-z. Otherwise, treat c as an original 'c' character.

\d

Match a numeric character. Equivalent to [0-9].

\D

Match a non-numeric character. Equivalent to [^0-9].

\f

Match a page break. Equivalent to \x0c and \cL.

\n

Match a newline character. Equivalent to \x0a and \cJ.

\r

Match a carriage return character. Equivalent to \x0d and \cM.

\s

Match any whitespace characters, including spaces, tabs, page breaks, etc. Equivalent to [ \f\n\r\t\v].

\S

Match any non-whitespace characters. Equivalent to [^ \f\n\r\t\v].

\t

Match a tab character. Equivalent to \x09 and \cI.

\v

Match a vertical tab. Equivalent to \x0b and \cK.

\w

Match letters, numbers, and underscores. Equivalent to '[A-Za-z0-9_]'.

\W

Match non-letters, numbers, and underscores. Equivalent to '[^A-Za-z0-9_]'.