RegExp object

Represents compiled regular expression.

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-expression [,flags])

Used for initialization of new instance of RegExp object. regular-expression 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