RegExp object

RegExp object

Represents compiled regular expresion.

RE Syntax supported:

Character
Meaning
\

For characters that are usually treated literally, indicates that the next character is special and not to be interpreted literally.

For example, /b/ matches the character ‘b’. By placing a backslash in front of b, that is by using /\b/, the character becomes special to mean match a word boundary.

or

For characters that are usually treated specially, indicates that the next character is not special and should be interpreted literally.

For example, * is a special character that means 0 or more occurrences of the preceding character should be matched; for example, /a*/ means match 0 or more "a"s. To match * literally, precede it with a backslash; for example, /a\*/ matches ‘a*’.

^

Matches beginning of input. If the multiline flag is set to true, also matches immediately after a line break character.

For example, /^A/ does not match the ‘A’ in "an A", but does match the first ‘A’ in "An A."

$

Matches end of input. If the multiline flag is set to true, also matches immediately before a line break character.

For example, /t$/ does not match the ‘t’ in "eater", but does match it in "eat".

*

Matches the preceding item 0 or more times.

For example, /bo*/ matches ‘boooo’ in "A ghost booooed" and ‘b’ in "A bird warbled", but nothing in "A goat grunted".

+

Matches the preceding item 1 or more times. Equivalent to {1,}.

For example, /a+/ matches the ‘a’ in "candy" and all the a’s in "caaaaaaandy".

?

Matches the preceding item 0 or 1 time.

For example, /e?le?/ matches the ‘el’ in "angel" and the ‘le’ in "angle."

If used immediately after any of the quantifiers *, +, ?, or {}, makes the quantifier non-greedy (matching the minimum number of times), as opposed to the default, which is greedy (matching the maximum number of times).

Also used in look ahead assertions, described under (?=), (?!), and (?:) in this table.

x{n}

Where n is a positive integer. Matches exactly n occurrences of the preceding item x.

For example, /a{2}/ doesn’t match the "a" in "candy", but it matches all of the "a"’s in "caandy", and the first two "a"’s in "caaandy".

x{n,}

Where n is a positive integer. Matches at least n occurrences of the preceding item x.

x{n,m}

Where n and m are positive integers. Matches at least n and at most m occurrences of the preceding item x.

.

(The decimal point) matches any single character except the newline characters: \n \r \u2028 or \u2029. ([\s\S] can be used to match any character including newlines.)

For example, /.n/ matches ‘an’ and ‘on’ in "nay, an apple is on the tree", but not ‘nay’.

(x)

Matches x and remembers the match. These are called capturing parentheses.

For example, /(foo)/ matches and remembers ‘foo’ in "foo bar." The matched substring can be recalled from the resulting array’s elements [1], ..., [n] or from the predefined RegExp object’s properties $1, ..

(x?=y)

Matches x only if x is followed by y.

x(?!y)

Matches x only if x is not followed by y.

x|y

Matches either x or y.

For example, /green|red/ matches ‘green’ in "green apple" and ‘red’ in "red apple."

\b

Matches a word boundary, such as a space. (Not to be confused with [\b].)

For example, /\bn\w/ matches the ‘no’ in "noonday"; /\wy\b/ matches the ‘ly’ in "possibly yesterday."

\B

Matches a non-word boundary.

For example, /\w\Bn/ matches ‘on’ in "noonday", and /y\B\w/ matches ‘ye’ in "possibly yesterday."

\d

Matches a digit character from any alphabet.

For example, /\d/ or /[0-9]/ matches ‘2’ in "B2 is the suite number."

Note: that is different from JavaScript where \d matches only [0-9] characters.

\D

Matches any non-digit character in any alphabet.

For example, /\D/ or /[^0-9]/ matches ‘B’ in "B2 is the suite number."

\a

Matches any alpha character from any alphabet.

\A

Matches any non-alpha character from any alphabet.

\w

Matches any alpha or digit character from any alphabet.

Note: that is different from JavaScript where \w matches only ASCII characters and digits.

\W

Matches any non-alpha and non-digit character from any alphabet.

\s

Matches any space character from any alphabet.

\S

Matches any non-space character from any alphabet.

Properties

length
integer, number of matches after last exec or match methods calls.
input
string, last inspected string.
source
string, source code of the regular expression – string this RegExp was build from.
index
integer, character position where the first successful match begins in a searched string, read-only.
lastIndex
integer, character position where the next match begins in a searched string.
[index]
string | undefined, read-only, returns n-th matched fragment. Index is a zero based index, integer.

Methods

this

(regular-expresion [,flags])

Used for intitalization of new instance of RegExp object. regular-expresion is a string – source of the regular expression. В flags is an optional string and if provided may contain characters ‘i’ for case insensitive search and/or ‘g’ – for global search – to find all occurences of source in the input string.
Use this constructor as: var re = new RegExp(…);

test

(input) : true | false

Checks input string to see if a pattern exists within a string and returns true if so, and false otherwise.

exec

(input) : null | RegExp object

Returns this RegExp object with length and list of matches set if pattern exists in input string or null otherwise.

positions
(matchIdex:0… length – 1) : (start:integer, end:integer)

Valid after the exec() call, returns pair of integers – start and end positions of matched sub-expressions in input string